Groovy语法入门

一、Groovy 是什么？

Apache Groovy 是一种基于 JVM（Java 虚拟机）的动态编程语言。它被设计为 Java 平台的增强版，与 Java 语法高度兼容，同时吸收了 Python、Ruby 等脚本语言的许多强大特性。

它的核心优势在于：

1. 无缝 Java 互操作：你可以在 Groovy 中直接使用任何 Java 类库，也可以将 Groovy 代码编译成标准的 Java 字节码，被 Java 代码调用。这意味着现有的庞大 Java 生态系统可以完全为其所用。

2. 语法糖和简洁性：相比 Java，Groovy 提供了大量简化的语法（例如，可选的分号、可选的类型声明、更简洁的集合操作），使得代码更短、更易读、更易写。

3. 动态和静态类型：Groovy 支持动态类型（使用 def 关键字），也支持静态类型（像 Java 一样声明类型），提供了极大的灵活性。

4. 领域特定语言 (DSL)：由于其简洁的语法和闭包特性，Groovy 非常适合创建内部领域特定语言，例如 Gradle 的构建脚本就是用 Groovy DSL 编写的。

5. 内置功能：原生支持集合操作、正则表达式、模板引擎、XML/JSON 处理等，无需引入第三方库。

主要应用场景：

• 构建工具：Gradle 的构建脚本。

• 测试：Spock 测试框架，功能非常强大。

• 自动化脚本：编写简洁的 CI/CD 脚本或系统管理脚本。

• 快速原型开发：得益于其动态性，可以快速验证想法。

• 在 Java 应用中嵌入：为 Java 应用提供灵活的扩展和配置能力。

---

二、环境搭建与运行

1. 安装 Java：确保你的系统已安装 JDK 8 或更高版本。

2. 安装 Groovy：

   • ** macOS**：brew install groovy

   • Linux (Ubuntu/Debian)：sudo apt-get install groovy

   • Windows：可以从 官网 下载安装包或使用 SDKMAN!。

   • 通用方法 (推荐)：使用 SDKMAN!：

     curl -s "https://get.sdkman.io" | bash
     # 然后打开新终端
     sdk install groovy

3. 验证安装：在终端运行 groovy --version，如果显示版本信息则安装成功。

运行 Groovy 代码的几种方式：

• Groovy Shell (交互式控制台)：在终端输入 groovysh，可以逐行输入代码并立即看到结果，非常适合学习和测试。

• Groovy Console (图形化界面)：输入 groovyConsole 启动一个带有简单编辑器的 GUI 窗口。

• 运行脚本文件：将代码保存为 .groovy 文件（例如 Hello.groovy），然后在终端运行 groovy Hello.groovy。

• 编译为 Java 字节码：使用 groovyc Hello.groovy 编译，它会生成 .class 文件，然后可以用 java 命令运行（需要将 groovy-all-x.x.x.jar 放入 classpath）。

---

三、详细语法入门

让我们通过对比 Java 来快速学习 Groovy 的核心语法。

1. Hello World

// Hello.groovy
// 分号是可选的！
println "Hello, World!" 
// 方法调用可以省略括号 (但有时需要为了避免歧义，保留括号是好习惯)
println("Hello, again!")

groovy Hello.groovy 输出：

Hello, World!
Hello, again!

2. 变量定义

Groovy 支持动态类型 (def) 和静态类型。

// 静态类型 (和Java一样)
String name = "Alice"
int age = 30// 动态类型 (使用 def 关键字)
def dynamicVar = "I can be anything"
dynamicVar = 42 // 现在它是个整数
dynamicVar = new Date() // 现在是个日期对象// 在方法内部，变量通常用 def 声明
def printMessage() {def message = "Inside method"println message
}

3. 字符串 (Strings)

Groovy 的字符串非常强大，支持三种形式。

• 单引号字符串：普通字符串，不对 $ 进行转义。

  def name = 'World'
  println 'Hello, $name' // 输出: Hello, $name

• 双引号字符串：GString，支持字符串插值。

  def name = "World"
  println "Hello, $name" // 输出: Hello, World
  println "计算 1 + 2 = ${1 + 2}" // 输出: 计算 1 + 2 = 3

• 三引号字符串：多行字符串。

  def multiLine = """This is amulti-linestring.
  """
  println multiLine

4. 集合 (Collections)

Groovy 为 List 和 Map 提供了原生的、更简洁的语法和大量便捷的方法。

List (列表)

// 定义列表 (默认是 ArrayList)
def list = [1, 2, 3, 4] 
// 更清晰的类型声明
List<String> names = ['Alice', 'Bob', 'Charlie']// 访问元素 (支持负索引)
println list[0] // 1
println list[-1] // 4 (最后一个元素)// 添加元素
list << 5 // 等同于 list.add(5)
list.add(6)// 每个集合都附带了大量便捷方法
list.each { println it } // 遍历每个元素
def doubled = list.collect { it * 2 } // [2, 4, 6, 8, 10, 12]
def evens = list.findAll { it % 2 == 0 } // [2, 4, 6]

Map (映射)

// 定义 Map (默认是 LinkedHashMap)
def map = [name: 'Alice', age: 30, city: 'London']
// 更清晰的类型声明
Map<String, Integer> scores = ['Math': 90, 'English': 85]// 访问元素
println map['name'] // Alice
println map.age // 30 (类似属性访问)// 添加/修改元素
map['country'] = 'UK'
map.job = 'Engineer'// 遍历
map.each { key, value -> println "$key: $value" 
}
map.each { entry -> println "$entry.key -> $entry.value" 
}

5. 闭包 (Closures)

闭包是 Groovy 的灵魂，它是一个可被赋值给变量、作为参数传递的代码块。

// 定义一个闭包
def greet = { name ->println "Hello, $name!"
}
// 调用闭包
greet('Alice') // Hello, Alice!// 如果只有一个参数，可以使用隐式参数 it
def shout = { println it.toUpperCase() }
shout('hello') // HELLO// 闭包作为方法参数 (非常重要！)
def processList(list, closure) {list.each(closure)
}processList([1, 2, 3], { println it }) // 遍历打印
// 如果闭包是最后一个参数，可以移到括号外面
processList([1, 2, 3]) { println it }
// 这种语法广泛用于 DSL，例如 Gradle

6. 控制结构

条件语句 (if-else)

和 Java 完全一样。

def score = 85
if (score >= 90) {println 'A'
} else if (score >= 80) {println 'B' // 输出 B
} else {println 'C'
}// Groovy 的 if 和 else 条件表达式更宽松
// 例如，可以判断非空、非零等
def str = "hi"
if (str) { // 如果 str 不是 null 且不是空字符串，则为 trueprintln "String is not empty"
}

循环

// 传统的 for 循环
for (int i = 0; i < 5; i++) {println i
}// for-in 循环
for (i in 0..4) { // 范围 (Range)println i
}// 使用 times 方法
5.times { i ->println "Iteration $i"
}// 使用 each 方法 (更 Groovy 的风格)
(0..4).each { i ->println "Index $i"
}
['A', 'B', 'C'].each { letter ->println letter
}

7. 方法 (Methods)

// 1. 定义方法 (可选的返回类型，可选的 return)
def add(a, b) {a + b // 最后一行表达式的结果就是返回值
}
// 显式声明返回类型和参数类型
int multiply(int a, int b) {return a * b
}// 2. 调用方法
println add(1, 2) // 3
println multiply(3, 4) // 12// 3. 默认参数
def greet(name, message = 'Hello') {println "$message, $name"
}
greet('Alice') // Hello, Alice
greet('Bob', 'Hi') // Hi, Bob// 4. 方法可以接收闭包作为参数
def executeTask(closure) {println "Task started"closure()println "Task completed"
}executeTask {println "I'm doing the real work inside the closure!"
}

8. 类 (Classes)

Groovy 的类与 Java 类非常相似，但更简洁。

// 定义一个简单的类
class Person {String name // 属性，默认带有 getter/setterint age// 方法String introduce() {"Hi, I'm $name, and I'm $age years old." // 返回一个字符串}
}// 使用类
def person = new Person(name: 'Alice', age: 30) // 使用命名参数简化初始化 (相当于调用了setter)
println person.name // 直接访问属性 (实际上调用了 getName())
person.age = 31 // 实际上调用了 setAge(31)
println person.introduce()

---

四、总结与后续学习

这份指南涵盖了 Groovy 最核心和常用的语法特性。要记住的关键点是：

• 省略：分号、括号、return 关键字经常可以省略。

• 动态性：善用 def 和动态类型。

• 字符串插值：使用 "$variable" 和 "${expression}"。

• 集合与闭包：这是 Groovy 的精华，each, collect, findAll 等方法与闭包配合使用，可以写出非常简洁和表达力强的代码。