class OuterClass {class InnerClass {def outerClosure = {def innerClosure = {}printfMsg("innerClosure", innerClosure)println("------")printfMsg("outerClosure", outerClosure)}void printfMsg(String flag, Closure closure) {def thisObject = closure.getThisObject()def ownerObject = closure.getOwner()def delegate = closure.getDelegate()println("$flagthis:${thisObject.toString()}")println("$flagowner:${ownerObject.toString()}")println("$flagdelegate:${delegate.toString()}")}}

def callInnerMethod() {def innerClass = new InnerClass()innerClass.outerClosure.call()println("------")println("outerClosure toString ${innerClass.outerClosure.toString()}")}

static void main(String[] args) {new OuterClass().callInnerMethod()}}

我们在 OuterClass 定义一个内部类 InnerClass，在 InnerClass 中定义了一个 outerClosure 闭包，在 outerClosure 中定义了一个 innerClosure 闭包，现在我们分别打印 innerClosure 和 outerClosure 闭包对应的 this，owner，delegate 对象和 outerClosure 对象的 toString 方法

innerClosure this: com.example.groovy.bean.OuterClass$InnerClass@e874448innerClosureowner:com.example.groovy.bean.OuterClass$InnerClass${}_{c}losure1@5bfbf16finnerClosuredelegate:com.example.groovy.bean.OuterClass$InnerClass$_closure1@5bfbf16f

outerClosure this: com.example.groovy.bean.OuterClass$InnerClass@e874448outerClosureowner:com.example.groovy.bean.OuterClass$InnerClass@e874448outerClosure delegate: com.example.groovy.bean.OuterClass$InnerClass@e874448

outerClosure toString com.example.groovy.bean.OuterClass$InnerClass$_closure1@5bfbf16f

分析结果：

• innerClosure

• this：结果是 OuterClass$InnerClass 对象

• owner：结果是 OuterClass$InnerClass$_closure1 对象 ，即 outerClosure

• delegate：同 owenr

• **outerClosure **

• this：结果是 OuterClass$InnerClass 对象

• owner：结果是 OuterClass$InnerClass 对象

• delegate：同 owenr

this，owner ，delegate 指向总结：this 永远是指定义该闭包类，如果存在内部类，则是最内层的类，但 this 不是指当前闭包对象 owenr 永远是指定义该闭包的类或者闭包，顾名思义，闭包只能定义在类中或者闭包中** delegate** 默认是指 owner，可以自己设置，自己设置的话又是什么情况

- delegate 才是重头戏

前面已经说了，闭包可以设置 delegate 对象，设置 delegate 的意义就是讲闭包和一个具体的对象关联起来，这个如何理解，看代码：

Person.groovy

class Person {String nameint age

void eat(String food) {println("你喂的 ${food}真难吃")}

@OverrideString toString() {return "Person{" +"name='" + name + ''' +", age=" + age +'}'}}

Main.groovy

def cc = {name = "hanmeimei"age = 26}

我们定义 Person 实体类，再定义一个名字叫 cc 的闭包，我们想在闭包里修改 Person 的 name 和 age，还想调用 eat 方法，这个怎么关联起来？

cc.delegate = perso

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》
浏览器打开：qq.cn.hn/FTe 免费领取

ncc.call()

怎么，这样就 ok 了吗，是的，就是这么简单，完整代码

class Main {def cc = {name = "hanmeimei"age = 26eat("油条")eat "油条"}static void main(String... args) {Main main = new Main()Person person = new Person(name: "lilei", age: 14)println person.toString()

main.cc.delegate = personmain.cc.call()println person.toString()}}

#打印结果 Person{name='lilei', age=14}你喂的油条真难吃 Person{name='hanmeimei', age=26}

上面我们知道了，在闭包中可以访问被代理对象的属性和方法，哦，那么我还有一个疑问，如果闭包所在的类或闭包中和被代理的类中有相同名称的方法，到底要调用哪个方法，其实这个问题 groovy 肯定考虑到了，为我们设定了几个代理的策略：

• Closure.OWNER_FIRST 是默认策略。优先在 owner 寻找，owner 没有再 delegate

• Closure.DELEGATE_FIRST：优先在 delegate 寻找，delegate 没有再 owner

• Closure.OWNER_ONLY：只在 owner 中寻找

• Closure.DELEGATE_ONLY：只在 delegate 中寻找

• Closure.TO_SELF：暂时没有用到，哎不知道啥意思

为了验证，我们现在修改一下 Main.groovy 代码

class Main {void eat(String food){println "我根本不会吃，不要喂我 ${food}"}def cc = {name = "hanmeimei"age = 26eat("油条")}

static void main(String... args) {Main main = new Main()Person person = new Person(name: "lilei", age: 14)println person.toString()

main.cc.delegate = person// main.cc.setResolveStrategy(Closure.DELEGATE_FIRST)main.cc.setResolveStrategy(Closure.OWNER_FIRST)main.cc.call()println person.toString()}}

我们在 Main 中也定义了同名的方法 eat（food）,因为当前 cc 闭包的 owner 正是 Main 对象，我们通过调用 setResolveStrategy 方法，修改策略，发现结果和预期的一致

闭包 delegate 的基本概念已经讲完，看完这些，相信你能进一步理解 android 开发中 build.gradle 中的写法，已经到达本次学习的目的，下面我们练习一下：

闭包练习

实现一个回调接口

做 Android 开发的同学对回调接口肯定不陌生，特别是事件的监听，现在，我们仿 View.setOnClickListener 用来闭包来实现一个回调接口

class View {private Closure onClickListenerTimer timer

View() {timer = new Timer()timer.schedule(new TimerTask() {@Overridevoid run() {perOnClick()}}, 1000, 3000)}void setOnClickListener(Closure closure) {this.onClickListener = closure}private void perOnClick() {if (onClickListener != null) {onClickListener(this)}}@OverrideString toString() {return "this is view"}}

定义一个 View 类，用 Timer 计时模拟事件的触发，暴露 setOnClickListener 方法，用于介绍闭包对象，那么调用者该如何写呢？

View view = new View()view.setOnClickListener { View v ->println v.toString()}

其实调用者也很简单，只需定义一个闭包，v 是传递过来的参数，打印出 toString 方法，结果如下

this is viewthis is viewthis is view...

仿照 Android DSL 定义闭包

在 Android 中我们熟悉的 build.gradle 配置，其实也是闭包，这下面肯定是你熟悉的代码

android {compileSdkVersion 25buildToolsVersion "25.0.2"

defaultConfig {minSdkVersion 15targetSdkVersion 25versionCode 1versionName "1.0"}}

我们要实现自己的闭包，我们要定义两个实体类 Android.groovy 和 ProductFlavor.groovy，代码如下

Android.groovy

class Android {private int mCompileSdkVersionprivate String mBuildToolsVersionprivate ProductFlavor mProductFlavor

Android() {this.mProductFlavor = new ProductFlavor()}

void compileSdkVersion(int compileSdkVersion) {this.mCompileSdkVersion = compileSdkVersion}

void buildToolsVersion(String buildToolsVersion) {this.mBuildToolsVersion = buildToolsVersion}

void defaultConfig(Closure closure) {closure.setDelegate(mProductFlavor)closure.setResolveStrategy(Closure.DELEGATE_FIRST)closure.call()}

@OverrideString toString() {return "Android{" +"mCompileSdkVersion=" + mCompileSdkVersion +", mBuildToolsVersion='" + mBuildToolsVersion + ''' +", mProductFlavor=" + mProductFlavor +'}'}}

ProductFlavor.groovy

class ProductFlavor {private int mVersionCodeprivate String mVersionName