Gradle自动化构建(三) Groovy

闭包与字符串

String str = '2 + 3 = 5,abc'
println str.each { // 2 + 3 = 5,abc2 + 3 = 5,abc ， 字符串的遍历，返回值为变量 str 本身
    String tmp -> print tmp
}

println str.find { // 2 ， find的闭包是 由一个String形参，返回值为boolean 的闭包，true条件成立就返回
    String s -> s.isNumber()
}

def list = str.findAll { // 找到字符串中所有符合条件的字符，组成list，返回
    String s -> s.isNumber()
}
println list.toListString() // [2, 3, 5]

println str.any { String s -> s.isNumber() } // true ， any 只要符合条件就返回true，否则返回false
println str.every { String s -> s.isNumber() } // false ， every 表示str中每个字符都要满足条件返回true，否则返回false
// [2,  , +,  , 3,  , =,  , 5, ,, A, B, C] ， collect 对字符串中每个字符进行闭包中的处理，返回处理后字符组成的集合list
println str.collect { it.toUpperCase() }.toListString()

闭包more

// 闭包关键变量 this 、 owner 、 delegate    都是指向其最近的类
def closure = {
    println "1this : "+this          // 1this : part4.closureup@5f9b2141 ， this与java中的一样，代表闭包定义处的类
    println "1owner : "+owner        // 1owner : part4.closureup@5f9b2141 ， owner 代表闭包定义处的类或者对象
    println "1delegate : "+delegate  // 1delegate : part4.closureup@5f9b2141 ， delegate 代表任意对象，默认值是 owner
}
closure.call()

class Person { // class Person 表示定义了一个内部类
    def static classClosure = { // static 表示静态类型的闭包
        println "2this : "+this         // 2this : class part4.Person
        println "2owner : "+owner       // 2owner : class part4.Person
        println "2delegate : "+delegate // 2delegate : class part4.Person
    }
    def static say() {
        def classClosure = {
            println "3this : "+this         // 3this : class part4.Person
            println "3owner : "+owner       // 3owner : class part4.Person
            println "3delegate : "+delegate // 3delegate : class part4.Person
        }
        classClosure.call()
    }

    def cc = {
        println "4this : "+this         // 4this : part4.Person@505fc5a4
        println "4owner : "+owner       // 4owner : part4.Person@505fc5a4
        println "4delegate : "+delegate // 4delegate : part4.Person@505fc5a4
    }
    def nostatic() {
        def classClosure = {
            println "5this : "+this         // 5this : part4.Person@505fc5a4
            println "5owner : "+owner       // 5owner : part4.Person@505fc5a4
            println "5delegate : "+delegate // 5delegate : part4.Person@505fc5a4
        }
        classClosure.call()
    }
}
Person.classClosure.call() // 调用内部类中的静态成员闭包
Person.say() // 调用内部类中的静态函数
Person per = new Person()
per.cc.call() // 非静态成员 调用
per.nostatic()

def outClosure = {
    def innerClosure = { // 闭包中定义闭包
        println "6this : "+this         // 6this : part4.closureup@5f9b2141 ， this指向的是closureup.groovy的实例，与不嵌套的closure闭包的this是一样的
        println "6owner : "+owner       // 6owner : part4.closureup$_run_closure2@3bf9ce3e ， owner指向的是outClosure闭包的实例
        println "6delegate : "+delegate // 6delegate : part4.Person@505fc5a4 ， delegate没有修改的话，默认指向 part4.closureup$_run_closure2@3bf9ce3e
    }
    innerClosure.delegate = per // 修改innerClosure闭包的delegate对象，指向person实例对象
    innerClosure.call()
}
outClosure.call()
// 在一般情况下，闭包的 this owner delegate 值都一样
// 在闭包的闭包中， this 与 owner 值不一样，owner 与 delegate 的值一样 ， 如果修改了delegate值， owner 就与 delegate 值不一样了
// 闭包的 this 、 owner 的值是不能被修改的

// 闭包委托策略
class Student {
    String name
    def pretty = { "My name is $name" }
}
class Teacher {
    String name
}
def stu = new Student(name: 'hj') // new一个对象，并给name成员赋值
def tea = new Teacher(name: 'some')
println stu.pretty.call() // My name is hj
stu.pretty.delegate = tea
println stu.pretty.call() // My name is hj
stu.pretty.resolveStrategy = Closure.DELEGATE_ONLY // 修改闭包的委托策略(需要这两行代码一起作用才行)，默认值为 Closure.OWNER_FIRST
// 当修改的闭包的委托策略为 DELEGATE_FIRST，如果在teacher对象中没有与student对象的pretty闭包中的name变量一致的变量，那么pretty.call()时还是会取student对象中的name的值
// 当修改的闭包的委托策略为 DELEGATE_ONLY，如果teacher对象中没有name成员，那么程序会报错
println stu.pretty.call() // My name is some

Gradle自动化构建(三) Groovy

闭包与字符串

闭包more

猜你喜欢