###闭包与字符串
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