网站开发方案报价网站建设关于我们

Groovy 闭包是一个非常重要的特性，它是一个开放的、匿名的代码块，可以接受参数、返回值并赋值给变量。下面我将详细介绍 Groovy 闭包的语法和使用方法。

基本语法

// 基本闭包定义
def closure = { println "Hello, World!" }
closure() // 输出: Hello, World!// 带参数的闭包
def closureWithParams = { String name -> println "Hello, ${name}!" }
closureWithParams("Groovy") // 输出: Hello, Groovy!// 隐式参数 it
def implicitParam = { println "Hello, ${it}!" }
implicitParam("Groovy") // 输出: Hello, Groovy!// 多个参数
def multiParams = { a, b -> a + b }
println multiParams(3, 4) // 输出: 7

闭包作为参数

// 方法接受闭包作为参数
def timesTen(num, closure) {closure(num * 10)
}// 调用方法并传递闭包
timesTen(5) { result -> println "Result: $result" } // 输出: Result: 50// 更简洁的写法
timesTen(5) { println "Result: $it" } // 输出: Result: 50

闭包返回值

// 闭包返回最后一个表达式的值
def adder = { a, b -> a + b }
println adder(2, 3) // 输出: 5// 使用 return 显式返回值
def multiplier = { a, b -> return a * b }
println multiplier(2, 3) // 输出: 6

闭包与集合操作

def numbers = [1, 2, 3, 4, 5]// each - 遍历集合
numbers.each { println it }// collect - 转换集合
def doubled = numbers.collect { it * 2 }
println doubled // 输出: [2, 4, 6, 8, 10]// find - 查找元素
def even = numbers.find { it % 2 == 0 }
println even // 输出: 2// findAll - 查找所有匹配元素
def allEvens = numbers.findAll { it % 2 == 0 }
println allEvens // 输出: [2, 4]// every - 检查所有元素是否满足条件
def allEven = numbers.every { it % 2 == 0 }
println allEven // 输出: false// any - 检查是否有元素满足条件
def hasEven = numbers.any { it % 2 == 0 }
println hasEven // 输出: true

闭包作用域

def outerVar = "outer"def outerClosure = {def innerVar = "inner"return {println "Accessing outerVar: $outerVar"println "Accessing innerVar: $innerVar"}
}def innerClosure = outerClosure()
innerClosure()
// 输出:
// Accessing outerVar: outer
// Accessing innerVar: inner

闭包委托机制

Groovy 闭包有三个重要的属性：

• this：指向定义闭包的类

• owner：指向定义闭包的对象

• delegate：默认与 owner 相同，但可以修改

class Example {def run() {def closure = {println "this: ${this.getClass().name}"println "owner: ${owner.getClass().name}"println "delegate: ${delegate.getClass().name}"}closure()}
}new Example().run()

柯里化（Currying）

// 柯里化 - 固定部分参数
def multiply = { a, b -> a * b }
def twice = multiply.curry(2)
println twice(5) // 输出: 10// 右柯里化
def rightCurry = multiply.rcurry(3)
println rightCurry(4) // 输出: 12// 索引柯里化
def ncurry = multiply.ncurry(1, 5) // 将第二个参数固定为5
println ncurry(3) // 输出: 15

方法委托

class Person {String namedef sayHello = { "Hello, I'm $name" }
}def person = new Person(name: "Alice")
def greeting = person.sayHello
println greeting() // 输出: Hello, I'm Alice

闭包的内存考虑

// 注意闭包可能捕获外部变量导致内存泄漏
def createClosures() {def largeObject = new LargeObject()return {// 闭包捕获了largeObject，即使外部方法执行完毕，largeObject也不会被GClargeObject.doSomething()}
}

总结

Groovy 闭包是一个非常强大的特性，它：

1. 可以作为参数传递给方法

2. 可以访问和修改外部变量

3. 提供了简洁的集合操作方式

4. 支持柯里化和方法委托

5. 具有灵活的作用域控制

掌握闭包的使用可以让你编写更加简洁、表达力更强的 Groovy 代码。