"Gradle"系列: 一、Gradle相关概念理解，Groovy基础(3)

//1

{ params ->

   //do something

}


//2

{ 

   //do something

}

//定义一个闭包赋值给 closure 变量

def closure = { params1,params2 ->

    params1 + params2

}


//闭包调用方式1: 闭包可以通过 .call 方法来调用

def result1 = closure('erdai ','666')

//闭包调用方式2: 闭包可以直接用括号+参数来调用

def result2 = closure.call('erdai ','777')

//打印值

println result1

println result2

//打印结果

erdai 666

erdai 777


//定义一个无参闭包

def closure1 = {

    println('无定义参数闭包')

}

closure1() //或者调用 closure1.call()

//打印结果

无定义参数闭包

//定义一个闭包

def outerClosure = {

    println "this: " + this

    println "owner: " + owner

    println "delegate: " + delegate

}

//调用闭包

outerClosure.call()

//打印结果

this: variable.GroovyGrammar@39dcf4b0

owner: variable.GroovyGrammar@39dcf4b0

delegate: variable.GroovyGrammar@39dcf4b0

//证明当前三者都指向了GroovyGrammar这个脚本类对象

//定义一个 OuterClass 类

class OuterClass {

    //定义一个闭包

    def outerClosure = {

        println "this: " + this

        println "owner: " + owner

        println "delegate: " + delegate

    }

}


def outerClass = new OuterClass()

outerClass.outerClosure.call()


//打印结果如下：

this: variable.OuterClass@1992eaf4

owner: variable.OuterClass@1992eaf4

delegate: variable.OuterClass@1992eaf4

//结果证明这三者都指向了当前 OuterClass 类对象

def outerClosure = {

    def innerClosure = {

        println "this: " + this

        println "owner: " + owner

        println "delegate: " + delegate

    }

    innerClosure.call()


}

println outerClosure

outerClosure.call()


//打印结果如下

variable.GroovyGrammar$_run_closure4@64beebb7

this: variable.GroovyGrammar@5b58ed3c

owner: variable.GroovyGrammar$_run_closure4@64beebb7

delegate: variable.GroovyGrammar$_run_closure4@64beebb7

//结果证明 this 指向了当前GroovyGrammar这个脚本类对象 owner 和 delegate 都指向了 outerClosure 闭包对象

//创建一个香蕉类

class Banana{

    def name

}


//创建一个橘子类

class Orange{

    def name

}


//定义一个香蕉对象

def banana = new Orange(name: '香蕉')

//定义一个橘子对象

def orange = new Orange(name: '橘子')

//定义一个闭包对象

def closure = {

    //打印值

    println delegate.name

}

//调用闭包

closure.call()


//运行一下，发现结果报错了，如下

Caught: groovy.lang.MissingPropertyException: No such property: name for class: variable.GroovyGrammar

//大致意思就是GroovyGrammar这个脚本类对象没有这个 name 对象

//修改闭包的delegate

closure.delegate = orange

//我们在运行一下，打印结果:

橘子

//修改闭包的delegate

closure.delegate = banana

//我们在运行一下，打印结果:

香蕉

//定义一个 ClosureDepth 类

class ClosureDepth{

    //定义一个变量 str1 赋值为 erdai666

    def str1 = 'erdai666'

    //定义一个闭包

    def outerClosure = {

        //定义一个变量 str2 赋值为 erdai777

        def str2 = 'erdai777'

        //打印str1 分析1

        println str1


        //闭包中在定义一个闭包

        def innerClosure = {

            //分析2

            println str1

            println str2

        }

        //调用内部这个闭包

        innerClosure.call()

    }

}


//创建 ClosureDepth 对象

def closureDepth = new ClosureDepth()

//调用外部闭包

closureDepth.outerClosure.call()

//运行程序，打印结果如下

erdai666

erdai666

erdai777

class People1{

    def name = '我是People1'


    def action(){

        println '吃饭'

    }


    def closure = {

        println name

        action()

    }

}


class People2{

    def name = '我是People2'


    def action(){

        println '睡觉'

    }

}


def people1 = new People1()

def people2 = new People2()

people1.closure.delegate = people2

people1.closure.call()

//运行下程序，打印结果如下：

我是People1

吃饭

people1.closure.resolveStrategy = Closure.DELEGATE_FIRST

//运行下程序，打印结果如下：

我是People2

睡觉

public abstract class Closure<V> extends GroovyObjectSupport implements Cloneable, Runnable, GroovyCallable<V>, Serializable {

    /**

     * 熟悉的一堆闭包委托代理策略

     */

    public static final int OWNER_FIRST = 0;

    public static final int DELEGATE_FIRST = 1;

    public static final int OWNER_ONLY = 2;

    public static final int DELEGATE_ONLY = 3;

    public static final int TO_SELF = 4;

    /**

     * 闭包对应的三个委托对象 thisObject 对应的就是 this 属性，都是用 private 修饰的，外界访问不到

     */

    private Object delegate;

    private Object owner;

    private Object thisObject;

    /**

     * 闭包委托策略

     */

    private int resolveStrategy;


    /**

     * 在闭包的构造方法中：

     * 1、将 resolveStrategy 赋值为0，也是就默认委托策略OWNER_FIRST

     * 2、thisObject ，owner ，delegate都会被赋值，delegate 赋的是 owner的值

     */

    public Closure(Object owner, Object thisObject) {

        this.resolveStrategy = 0;

        this.owner = owner;

        this.delegate = owner;

        this.thisObject = thisObject;

        CachedClosureClass cachedClass = (CachedClosureClass)ReflectionCache.getCachedClass(this.getClass());

        this.parameterTypes = cachedClass.getParameterTypes();

        this.maximumNumberOfParameters = cachedClass.getMaximumNumberOfParameters();

    }


    /**

     * thisObject 只提供了 get 方法，且 thisObject 是用 private 修饰的，因此 thisObject 即 this 只读

     */

    public Object getThisObject() {

        return this.thisObject;

    }


    /**

     * owner 只提供了 get 方法，且 owner 是用 private 修饰的，因此 owner 只读

     */

    public Object getOwner() {

        return this.owner;

    }


    /**

     * delegate 提供了 get 和 set 方法，因此 delegate 可读写

     */

    public Object getDelegate() {

        return this.delegate;

    }


    public void setDelegate(Object delegate) {

        this.delegate = delegate;

    }


    /**

     * 熟悉的委托策略设置

     */

    public void setResolveStrategy(int resolveStrategy) {

        this.resolveStrategy = resolveStrategy;

    }

    public int getResolveStrategy() {

        return resolveStrategy;

    }

}