Groovy04_闭包

Posted 2022-12-01 李樟清

1. 闭包的基本定义和调用

ls4_0.groovy

// 1. 闭包
def closure = 
    println 'grovvy'

println closure.getClass()      // class lsn4_0$_run_closure1
// 2. 调用闭包
closure.call()      // grovvy
closure()           // grovvy

// 3. 闭包默认能够接收一个参数
def closure1 = 
    println it

closure1('hello,closure')       // hello,closure

// 4. 给一个闭包指定一个参数列表
def closure2=
    //->      //  -> 前面不加东西  表示 不接收参数
    i='Grovvy',j ->
    println i + j

closure2('hello,closure','Zeking')  // hello,closureZeking
closure2('Zeking')                      // GrovvyZeking

// 5. 闭包的参数绑定(柯里化闭包)
def closure3=
    i,j->
        println i+ " "+j

def curriedClosurse = closure3.ncurry(1,'2')  //从左至右  closure3.rcurry()这个是从右到左

curriedClosurse('java')     // java 2

// 6. 方法调用闭包

def clouser4=
    i,j->
        println i + "-" + j

def func(clouser4)
    clouser4()


interface  Action1
    void call()


func()



func (new Action1()

    @Override
    void call() 
        println 'call'      // call
    
)
// 在一个对象上调用() ，表示调用这个对象上的call方法
class Action2
    def call()
        println 'call2'
    


new Action2()()     // call2  等于 new Action2().call()

2. this owner delegate

ls4_1.groovy

// Groovy的 元件

def closure = 
    int i->


// 1. 获取闭包的参数列表
println closure.parameterTypes              // [int]  参数类型
println closure.maximumNumberOfParameters   // 1

// 2. this owner delegate
def closure2 = 
    println "this is" +this             // this is      ls4_1@1184ab05
    println "owner is"+ owner           // owner is     ls4_1@1184ab05
    println "delegate is"+ delegate     // delegate is  ls4_1@1184ab05
                // 在这种情况下是一样的

closure2()

class TestClosure
    def closure2 = 
        println "this is " +this             // this is     TestClosure@22a637e7
        println "owner is "+ owner           // owner is    TestClosure@22a637e7
        println "delegate is "+ delegate     // delegate is TestClosure@22a637e7

    

new TestClosure().closure2()

class TestClosure2
    // static 他就不是一个TestClosure2的实例对象了，而是TestClosure2这个类的对象（TestClosure2.class）
    // 这时候这3个任然一样
    def static closure2 = 
        println "this is " +this             // this is     TestClosure2
        println "owner is "+ owner           // owner is    TestClosure2
        println "delegate is "+ delegate     // delegate is TestClosure2

    

TestClosure2.closure2()

class TestClosure3
    def closure1 = 
        def closure2 = 
            println "this is " +this             // this is     TestClosure3@6e4784bc
            println "owner is "+ owner           // owner is    TestClosure3$_closure1@34b7ac2f
            println "delegate is "+ delegate     // delegate is TestClosure3$_closure1@34b7ac2f
        
        closure2()
    

new TestClosure3().closure1()
// 闭包中的 this 指的是定义它的时候 所在的类的this，静态闭包当中为class
// owner 定义它的时候 所在类的对象
// delegate 默认就是owner
// owner（拥有者）没法改变，但是我们可以修改delegate（代理）

def func()
    println "func"


def closure3 = 
    func()


closure3()          // func

class TestFun
    def func2()
        println 'TestFun  func'
    


def closure4 = 
    func2()     //  报错，不能直接调用func2  因为不在同一个类里面


closure4.delegate = new TestFun()  // 所以我们就可以通过改变这个闭包的代理的方式，来让他能够调用 fun2
closure4()                     // TestFun  func


class TestFun5
    def fun5()
        println 'TestFun5 :  fun5'
    


def fun5()
    println "ls4_1 : fun5"


def closure5 = 
    def func5 = 
        println "closure5 : fun5"
    
    fun5()

closure5.delegate = new TestFun5()
//closure5.resolveStrategy = Closure.DELEGATE_FIRST  // 默认是  Closure.OWNER_FIRST  --》ls4_1 : fun5
                                                   //  Closure.DELEGATE_FIRST  -》TestFun5 :  fun5
                                                    // OWNER_ONLY 只在OWNER找
                                                    // DELEGATE_ONLY 只在代理找
                                                    // TO_SELF 只在自身找 就是在 closure5 闭包内部找（最没有意义的） --> closure5 : fun5
closure5()      // ls4_1 : fun5  为什么调用的是 ls4_1 : fun5？
                // 因为闭包有一个，代理策略