Groovy语法之闭包

最新推荐文章于 2024-05-16 14:20:13 发布
最新推荐文章于 2024-05-16 14:20:13 发布
阅读量1.3k 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Android Groovy 文章标签： groovy 闭包 代理模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tscyds/article/details/77450608
本文深入探讨Groovy的闭包概念，包括闭包的定义、格式、执行方式，以及代理策略中的this、owner和delegate的含义和区别。通过示例解释了不同代理策略对闭包行为的影响，强调了闭包在Groovy中的重要性和灵活性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

闭包概述

闭包就是一个特殊的匿名代码块，可以传递参数，有返回值，还能作为方法的参数进行传递。

闭包格式

  1. 闭包的格式定义如下：

    { [closureParameters -> ] statements }

    示例：

    { item++ }                                          

{ -> item++ }                                       

{ println it }                                      

{ it -> println it }                                

{ name -> println name }                            

{ String x, int y ->                                
    println "hey ${x} the value is ${y}"
}

{ reader ->                                         
    def line = reader.readLine()
    line.trim()
}

  2. closureParameters ：闭包参数是非必需的，与方法的参数十分类似，区别是：如果存在闭包参数，闭包参数与闭包语句之间需要使用箭头（->）的分割。

  3. 注意：如果没有指定参数，则默认存在一个it的参数，代表的是闭包本身。如下例子：

    def obj = {
    println(it)
}
obj('hello')

  4. statements：同样，闭包语句则可以类比于方法体，功能也相同。

  5. 变量可作为闭包的载体，原因是：闭包其实是Groovy中的Closure类的实例。如下三种示例：

    def listener = { e -> println "Clicked on $e.source" }      

//指明为Closure类型实例
Closure callback = { println 'Done!' }                      

//指明为Closure类型实例，并指定返回类型 
Closure<Boolean> isTextFile = {
    File it -> it.name.endsWith('.txt')                     
}

  6. 执行闭包有两种方式：一是直接调用；二是通过调用Closure的call方法。如下代码：

    def obj = {
    def item = 10
    return ++item
}
// 直接调用
println(obj())

//call调用
println(obj.call())

  7. 从字节码来看上述两种方式的区别：两种方式完全等效，都是通过call来完成

    public Object test() {
    CallSite[] var1 = $getCallSiteArray();
    class _test_closure1 extends Closure implements GeneratedClosure {
        public _test_closure1(Object _thisObject) {
            CallSite[] var3 = $getCallSiteArray();
            super(Closures.this, _thisObject);
        }

        public Object doCall(Object it) {
            CallSite[] var2 = $getCallSiteArray();
            Object item = Integer.valueOf(10);
            return var2[0].call(item);
        }

        public Object doCall() {
            CallSite[] var1 = $getCallSiteArray();
            return this.doCall((Object)null);
        }
    }

    Object obj = new _test_closure1(this);
    var1[2].callCurrent(this, var1[3].call(obj));
    return var1[4].callCurrent(this, var1[5].call(obj));
}
代理策略

  1. 代理在groovy的闭包中是非常重要的概念，与之相关的是this、owner和delegate这三种概念。

  2. this：指的是定义闭包所在的直接的外围类，具体有如下两种方式获取：

    class Test {
    void run() {
        // 方式一：使用getThisObject
        def enclosingThisObject = { getThisObject() }
        // 方式二：this操作符
        def enclosingThis = { this }

        def testThis = this
        def print = "enclosingThisObject=${enclosingThisObject()},enclosingThis=${enclosingThis()},testThis=$testThis"
        println(print)
   }
}
def test = new Test()
test.run()

    运行结果：

    enclosingThisObject=com.demo.test.cl.Test@4f209819,
enclosingThis=com.demo.test.cl.Test@4f209819,
testThis=com.demo.test.cl.Test@4f209819

    从字节码也可看出两种方式是等效的，因为this方式也会调用getThisObject，如下：

    public void run() {
    CallSite[] var1 = $getCallSiteArray();
    class _run_closure1 extends Closure implements GeneratedClosure {
        public _run_closure1(Object _thisObject) {
            CallSite[] var3 = $getCallSiteArray();
            super(Test.this, _thisObject);
        }

        public Object doCall(Object it) {
            CallSite[] var2 = $getCallSiteArray();
            return var2[0].callCurrent(this);
        }

        public Object doCall() {
            CallSite[] var1 = $getCallSiteArray();
            return this.doCall((Object)null);
        }
    }

    Object enclosingThisObject = new _run_closure1(this);
    class _run_closure2 extends Closure implements GeneratedClosure {
        public _run_closure2(Object _thisObject) {
            CallSite[] var3 = $getCallSiteArray();
            super(Test.this, _thisObject);
        }

        public Object doCall(Object it) {
            CallSite[] var2 = $getCallSiteArray();
            // this方式调用getThisObject方法
            return this.getThisObject();
        }

        public Object doCall() {
            CallSite[] var1 = $getCallSiteArray();
            return this.doCall((Object)null);
        }
    }

    Object enclosingThis = new _run_closure2(this);
    Object print = new GStringImpl(new Object[]{var1[0].call(enclosingThisObject), var1[1].call(enclosingThis), this}, new String[]{"enclosingThisObject=", ",enclosingThis=", ",testThis=", ""});
    var1[2].callCurrent(this, print);
}

    注意：在内部类中定义闭包，那么this指的是这个内部类；同样，嵌套的闭包定义，this指的是外层闭包所在的类。如下实例：

    class EnclosedInInnerClass {
    class Inner {
        Closure cl = { this }
    }

    void run() {
        def inner = new Inner()
        assert inner.cl() == inner
    }
}

class NestedClosures {
    void run() {
        def nestedClosures = {
            def cl = { this }
            cl()
        }
        assert nestedClosures() == this
    }
}

    小结：闭包需要依附于某个类中，不能单独存在；this其实是闭包与所在外部类的通信桥梁。

  3. owner： 指的是定义闭包的直接外围对象，可以是类或者闭包。与this相似，区别在于嵌套闭包，如下实例：

    class NestedClosures {
    void runOwner() {
        def nestedClosures = {
            def cl = { owner }
            cl()
        }
        assert nestedClosures() == nestedClosures
    }

    void runThis() {
        def nestedClosures = {
            def cl = { this }
            cl()
        }
        assert nestedClosures() == this
    }
}

    嵌套闭包中this与owner的区别：this是外围类的实例，而owner则是外层闭包实例。

    小结：闭包中的this侧重于直接外围类，而owner则偏向于闭包的宿主对象，它们都是闭包与外部环境的通信桥梁。

  4. delegate：获取闭包的delegate有如下两种方式，其返回的默认值是owner。

    // 方式一：调用getDelegate()方法
def obj1 = { getDelegate() }
// 方式二：delegate关键字
def obj2 = { delegate }
// delegate默认值是owner
println(obj1() == obj2.owner)
// 嵌套闭包delegate默认值也是owner
def enclosed = {
      { -> delegate }.call()
    }
assert enclosed() == enclosed

    如下通过不同的代理对象，闭包的行为是不同的：

    class Person {
    String name
}

class Thing {
    String name
}

def p = new Person(name: 'Norman')
def t = new Thing(name: 'Teapot')

def upperCasedName = { delegate.name.toUpperCase() }
upperCasedName.delegate = p
println(upperCasedName())//Norman

upperCasedName.delegate = t
println(upperCasedName())//Teapot

  5. 代理策略：上述例子中的闭包能正常运行，是因为闭包的代理策略影响了编译闭包代码时的解析策略。分为如下几种策略：

    • Closure.OWNER_FIRST：OWNER优先策略，也是默认策略，优先从owner中寻找属性或方法，找不到再从delegete中寻找。
    • Closure.DELEGATE_FIRST：与OWNER_FIRST相反。
    • Closure.OWNER_ONLY： 只在owner中寻找属性或方法。
    • Closure.DELEGATE_ONLY： 只在delegate中寻找属性或方法。
    • Closure.TO_SELF： 前提是用户需要实现的Closure的子类，只会在闭包自身中寻找属性或方法。
    class Person {
    String name
    int age
    def fetchAge = { age }
}

class Thing {
    String name
}

def p = new Person(name: 'Jessica', age: 42)
def t = new Thing(name: 'Printer')
def cl = p.fetchAge
// 注意：cl的默认代理对象就是p，可以省略
// cl.delegate = p
println(cl())//42

cl.delegate = t
println(cl())//42

//修改代理策略
cl.resolveStrategy = Closure.DELEGATE_ONLY
cl.delegate = p
println(cl())//42

cl.delegate = t
try {
    cl()
    assert false
} catch (MissingPropertyException ex) {
    // "age" is not defined on the delegate
}
从编译原理浅谈闭包
阳光真好
07-22 1万+
刚学完编译原理，再来看闭包这个东西，感觉理解真的深入不少。下面就从三个部分解释一下闭包。       第一部分：            当新增一个变量时，计算机会在一块内存空间内分配一个位置，并且记录下这个变量的名称与位置的对应关系。            而这块内存空间，我们暂且称之为环境。    第二部分：       在执行方法时，计算机会新开辟一块内存空间，用来存放方法中的局
Groovy闭包
weixin_42133024的博客
12-29 333
什么是闭包 闭包在Groovy 的类型是 groovy.lang.Closure，是Groovy的一大利器。 闭包可以视为代码块、语句块、可以访问周围范围内的所有变量或方法。 def z = { println "hello" } z() 很简单，闭包只是一个语句，用大括号包含。您可以将其分配给变量，然后像常规方法调用一样调用此闭包。闭包具有一个默认的隐式参数，称为it。还可以提供自定义的参数。同样，就像方法中的情况一样，闭包的最后一个表达式是闭包的返回值。但是，如果您觉得可读性更高，也可以使用retur
Groovy的闭包
孙健的专栏
02-19 2531
一个简单的例子 [1,2,3].each{entry -> print entry}   each是循环执行的意思，它是List.each方法需要一个闭包参数 {}是闭包的部分 entry是参数部分（当然可以是命名为你喜欢的任何非关键字 如 a,e,people等等） ->右边是要执行的代码块     def sum=0 1.upto(100){arg->sum+=arg-1}
Groovy 闭包
乐百川
03-05 873
本文介绍了Groovy闭包的有关内容。闭包可以说是Groovy中最重要的功能了。如果没有闭包，那么Groovy除了语法比Java简单点之外，没有任何优势。但是闭包，让Groovy这门语言具有了强大的功能。如果你希望构建自己的领域描述语言（DSL），Groovy是一个很好的选择。Gradle就是一个非常成功的例子。本文参考自Groovy 文档 闭包，为了方便，大部分代码直接引用了Groovy文档。定
Groovy之闭包
凉茶铺的博客
06-21 1023
闭包（Closure）是很多编程语言中很重要的概念，那么Groovy中闭包是什么，官方定义是“Groovy中的闭包是一个开放，匿名的代码块，可以接受参数，返回值并分配给变量”，简而言之，他说一个匿名的代码块，可以接受参数，有返回值，闭包的调用方式有两种：方式一：闭包名.call() 方式二：闭包名() 4、闭包与基本类型的结合使用 4.1、使用upto方法求阶乘 4.2、使用down方法求阶乘 4.3、使用times方法累计求和 5.2、fin
groovy闭包
u010361662的专栏
01-10 346
/* groovy闭包可以简单理解为方法（函数）有参数，因为闭包本身也是一个对象，所以也可以作为参数 */ //语法： //def 闭包名={参数->代码块} 备注：使用->将参数与代码分离,闭包的参数是可选的 //定义无参的闭包 def clos={println'hello,world'} clos.call() //定义有参的闭包 def closA={param->printl
groovy 闭包
yucf1988的专栏
06-01 1021
<br /><br />闭包<br />Groovy语言中闭包（closure）是一个非常重要的概念，而且深入的理解了闭包对充分用好Groovy有很大帮助。对闭包比较书面的一种解释“闭包是可以用作函数参数和方法参数的代码块”。其实Groovy的闭包更象是一个“代码块”或者方法指针，代码在某处被定义然后在其后的调用处执行。<br /> <br />现在支持闭包的语言有 Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Perl，Ruby 和 Python 。<br
Groovy语法（二）：闭包
漏气的可乐的博客
12-26 586
1、Groovy中闭包基础 •1.1 闭包的概念 闭包是被包装成对象的代码块，可以通过一个变量引用到它，也可以传递给别人进行处理（像处理一个对象一样处理闭包，比如作为参数传递、作为一个方法的返回值等） •1.2 闭包的定义和调用 //定义一个闭包（闭包是一些代码组成的代码块对象,用{}括起来的一段代码） def closure = { println 'Hello groovy!'} //调用（类...
Groovy中的闭包
weixin_30881367的博客
08-05 165
Closures（闭包） 本节主要讲groovy中的一个核心语法：closurs，也叫闭包。闭包在groovy中是一个处于代码上下文中的开放的，匿名代码块。它可以访问到其外部的变量或方法。 1. 句法 1.1 定义一个闭包 { [closureParameters -> ] statements } 其中[]内是可选的闭包参数，可省略。当闭包带有参数，就需要->来将参数和闭包体相分离。...
Groovy语法：闭包
happyeveryminuteFL的博客
06-07 471
什么是闭包？使用{}包起来的代码块就是闭包 println {}输出结果为： xx.com.xx.ClosureDemorunclosure1@102d1符合格式：类_run_closure1@102d1 符合格式：类匿名内部类@hash code闭包就是一个匿名内部类的对象。也可以创建一个有名字的闭包： def closure = { println ‘Hell
Groovy(六)groovy闭包
wzj_110的博客
03-19 3903
一 闭包 自己在'Python'、'Lua'、'Go'、'Perl'中都'遇到过闭包',后续对比差异 核心： 'Lua'和'Groovy'中闭包是一个核心点 疑惑： groovy为什么要闭包?闭包的'优势'?-->仅仅是能够'访问闭包外'的属性和方法吗? 各种语言里面闭包的定义 百度百科 编程语言中的闭包 （1）定义 书面解释: 闭包是可以用作'函数参数'和'方法参数'的'代码块' 官方理解： Groovy中的闭包是一个'开放、匿名'的'代码块,'可以'接受'参数、返回值 .
004--【工具】groovy之闭包语法
weixin_42288943的博客
08-03 142
1、写作背景 目前在进行开源项目学习中，有一些项目时用gradle进行版本控制的，所以在此记录 2、参考网址 闭包使用参考:https://www.jianshu.com/p/e8dec95c4326 3、学习目标 完成闭包的基础语法学习（炫技可耻） 传递单个参数 传递多个参数 传递数组对象 传递闭包到函数 4、闭包学习 // 1、单个字符...
groovy经典闭包方法
weixin_33812433的博客
06-06 121
2019独角兽企业重金招聘Python工程师标准>>> ...
groovy 闭包(Closure)
dark
05-16 719
{ [参数列表] -> 代码块 }// 使用默认参数类型（{}）i < repeat;i++) {// 显式声明 Closure 类型i < repeat;i++) {//方法。
groovy 闭包语法
最新发布
04-11
<think>好的，我现在需要帮助用户理解Groovy闭包的语法和用法，并提供示例。首先，我需要回顾自己关于Groovy闭包的知识，确保准确性。根据用户提供的引用，闭包在Groovy中是一个重要的特性，用于构建DSL、函数式编程和简化集合操作。 首先，用户需要语法和示例。根据引用[4]，闭包的基本定义是使用大括号{}，可以像函数一样调用，或者使用call方法。例如，def closure = { println "hello world!" }，然后调用closure()或closure.call()。 接下来，带参数的闭包。引用[4]提到，闭包可以接受参数，比如{ param -> ... }，如果只有一个参数，隐式参数it可用。例如，闭包{ println it }，在each方法中使用，如friends.each { println "Hello, $it" }（引用[3]）。 然后，闭包的委托机制。引用[1]详细说明了闭包的delegate属性，默认情况下delegate是owner，即定义闭包的外部类或闭包。用户可能需要示例来说明如何改变委托，比如在构建DSL时，将委托设置为其他对象，以访问该对象的方法和属性。 此外，闭包作为方法参数。引用[3]中的each方法接受闭包作为参数，展示了如何将闭包传递给集合方法。需要示例说明如何定义接受闭包作为参数的方法，以及闭包在其中的使用。 还需要注意闭包的返回值。如果闭包的最后一行是表达式，它将作为返回值。例如，闭包{ a + b }会返回a+b的结果。 现在，综合这些信息，我需要组织一个结构清晰的回答，包括基本语法、参数传递、委托机制、作为方法参数的示例，以及闭包的返回值。同时，确保所有代码示例正确使用闭包语法，比如参数使用箭头->，隐式参数it的情况，以及委托的设置。 可能还需要提到闭包的作用域和变量捕获，比如闭包可以访问外部变量，但需要说明闭包如何绑定这些变量。不过根据用户提供的引用，可能暂时不需要深入这点，除非用户的问题中有相关部分。当前用户的问题集中在语法和示例，所以应优先展示这些内容。 最后，根据用户提供的引用[2]，闭包在Groovy中的重要性，可以强调其灵活性和在集合操作中的应用，如each、collect等方法的使用。 检查是否有遗漏的部分，比如闭包的隐式参数、委托的设置方法（delegate属性或getDelegate方法），以及如何将闭包传递给方法。确保每个示例都能正确运行，并符合用户提供的引用中的代码风格。 现在，将这些内容组织成步骤分明的部分，每个部分包含示例代码，并适当引用用户提供的参考资料，比如在讨论委托时引用[^1]，在集合操作时引用[^3]和[^4]。</think>### Groovy闭包语法与用法详解 #### 1. **基本语法** Groovy闭包是用大括号`{}`定义的代码块，可以像函数一样被调用。 ```groovy // 定义无参数闭包 def closure = { println "Hello, Groovy!" } closure() // 输出: Hello, Groovy! closure.call() // 等效调用 ``` #### 2. **带参数的闭包** - **显式参数**：通过`->`声明参数。 ```groovy def add = { a, b -> a + b } println add(3, 5) // 输出: 8 ``` - **隐式参数**：若闭包只有一个参数，可通过`it`访问。 ```groovy def printItem = { println it } ["Apple", "Banana"].each(printItem) // 输出: Apple\nBanana ``` #### 3. **闭包作为方法参数** Groovy集合方法（如`each`、`collect`）常接收闭包处理元素[^3][^4]。 ```groovy // 直接传递闭包到each方法 (1..3).each { println "Number: $it" } // 输出: // Number: 1 // Number: 2 // Number: 3 ``` #### 4. **闭包的委托机制** 闭包可通过`delegate`属性访问外部作用域外的对象，常用于构建DSL[^1]。 ```groovy class Person { String name = "Alice" } def closure = { "Name: ${name}" } closure.delegate = new Person() // 设置委托对象 println closure() // 输出: Name: Alice ``` #### 5. **闭包返回值** 闭包默认返回最后一行表达式的值。 ```groovy def square = { num -> num * num } println square(4) // 输出: 16 ``` #### 6. **嵌套闭包与作用域** 嵌套闭包的`delegate`默认指向其直接所有者（Owner）[^1]。 ```groovy def outer = { def inner = { delegate } inner() } println outer() == outer // 输出: true（inner的delegate是outer） ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值