Groovy里面闭包中变量符号的查找与变量定义的限制

class a {
    def v1 = "v1 in a"
    static def v2 = "v2 in a"
    def v4 = "v4 in a"
    def v5 = "v5 in a"
    def va = "va in a"
    def b() {
        def v1 = "v1 in a.b()"
        def v2 = "v2 in a.b()"
        def v4 = "v4 in a.b()"
        def g = {
            def v0 = "v0 in closure g"
            def h = {
                //function b里面已经定义v4 = "v4 in a.b()"所以下面这行
                //报错:The current scope already contains a variable of the name v4
                //def v4 = "v4 in closure h"
            }
        }
        def c = {
            //下面的这行代码报错:The current scope already contains a variable of the name v1
            //def v1 = "v1 in closure c"
            println v1
            println owner
            println this
            //下面这行定义v5变量正常,输出的结果也是:v5 in closure c
            def v5 = "v5 in closure c"
            println  v5//v4
            println va
        }
        println "***" + c.toString() + "***"
        c()
        
       return "b func"
    }
    
    def d = {
        println v1;
        println v2;
        println v4;
        def v5 = "v5 in closure d"
        println v5
    }
    
    def e = {
        def v1 = "v1 in closure e"
        def f = {
            //下面这行代码报错:The current scope already contains a variable of the name v1
            //def v1 = "v1 in closure f"
            println v1
            
            //下面这行就没错,因为闭包e的v2是在后面定义的
            def v2 = "v2 in closure f"
    
            //下面这行报错,v3在f里面不可见
            //println v3
            
            def vf = "vf in closure f"
        }
        f()
        def v2 = "v2 in closure e"
        def v3 = "v3 in closure e"
        
        //在闭包e里面vf不可见
        //println vf
    }
}
def test(x) {
    println "func test start --- x:" + x
    def v1 = 1000
    def v2 = 2000
    def v3 = 3000
    
    x()
    println "func test--- end:"
}
test(new a().d)
println "--------------"
//println new a().v4
println new a().b()
new a().e()


/*
通过上面的测试代码可以看出:
1.在闭包a里面定义的闭包b,那么b中定义的变量不能和和闭包a里面定义的变量名字相同.
2.在函数a里面定义的闭包b,那么b中定义的变量不能和和函数a里面定义的变量名字相同.
3.由此也可以推导出:在函数a里面定义闭包b,在闭包b里面定义闭包c,那么c中定义
的变量也不能和函数a中定义的变量名字相同,对于任意多层闭包嵌套也是如此
在闭包里面的符号查找方面:
    首先在闭包里面查找,如果闭包里面没有定义,则有两种情况(假设delegate策略是Closure.OWNER_FIRST,其它策略是一样的):
        1.如果这个闭包的外层是函数,则现在函数里面查找,如果函数里面也没有定义,则进入delegate策略即在owner里面查找,
        如果owner里面没有,则在delegate里面查找,ruguo delegate里面没有就报错
        2.如果这个闭包没外层不是函数,则直接进入delegate策略即在owner里面查找,如果owner里面没有,则在delegate里面查找
        如果delegate里面没有就报错.

*/