Groovy语法介绍-程序员宅基地

1. 介绍

Groovy 是基于 JRE 的脚本语言，和Perl，Python等等脚本语言一样，它能以快速简洁的方式来完成一些工作：如访问数据库，编写单元测试用例，快速实现产品原型等等。

Groovy 是由James Strachan 和 Bob McWhirter 这两位天才发明的（JSR 241 2004 年 3 月）。Groovy 完全以Java API为基础，使用了Java开发人员最熟悉的功能和库。Groovy 的语法近似Java，并吸收了 Ruby 的一些特点，因此 Groovy 在某些场合可以扮演一种 “咖啡伴侣”的角色。

官网地址：http://groovy.codehaus.org/

Groovy的主要特性：

Closure（闭包）的支持
本地的 List 和 Map 语法
Groovy 标记：支持多种标记语言，如 XML、HTML、SAX、W3C DOM
Groovy Path 表达式语言：类似 Xpath
Groovlet：用简单的 Groovy 脚本实现 Servlet
Groovy SQL：使得和 SQL 一起工作更简单
Groovy Bean：和 Bean 一起工作的简单语法
Groovy模版引擎：简单使用，集成了 Gpath 和编译成字节码
Ant 脚本化
正则表达式：简洁的脚本语法使用正则表达式
操作符重载：使 Collection 和 Map 的数据类型简单化
多形式的 iteration 和 Autoboxing
直接编译成 Java 字节码，很干净的和所有已存在的 Java 对象和类库一起工作

Groovy 可以作为 javac 的一种可选编译器来生成标准的 Java 字节码，在任何 Java 工程中使用。Groovy 可以作为一种动态的可选语言，如脚本化 Java对象、模版化、编写单元测试用例。

工具介绍：

Groovy ：运行 groovy 脚本文件。
Groovyc：编译 groovy 脚本成 java 的 bytecode 文件（.class）
Groovysh：运行命令行的控制台，可以输入 groovy 语句直接执行
GroovyConsole：GUI 形式的控制台，相当于简单的编辑器

2. 使用

使用压缩包安装，下载地址为 http://groovy.codehaus.org/Download，下载然后解压配置环境变量。

在 mac 上安装 groovy：

brew install groovy

Groovy 脚本可以直接用 Groovy 解析执行：

groovy hello.groovy

编译为字节码：

groovyc -d classes hello.groovy

运行编译好的groovy脚本：

java -cp %GROOVY_HOM E%/embeddable/groovy-all.jar;classes hello

你会发现其实就是运行 java 的 class 文件。

3. 语法

Groovy 的语法融合了 Ruby、Python 和 Smalltalk 的一些最有用的功能，同时保留了基于 Java 语言的核心语法。对于Java 开发人员，Groovy 提供了更简单的替代语言，且几乎不需要学习时间。

Groovy在语法上跟java有几点不同：

Groovy中，”= =”等同于java中的equals方法；”= = =”等同于java中的”= =”。
Groovy中缺省的标志符是public。

3.1 关键字

在 Groovy 可以用 def 定义无类型的变量(定义变量方面 def 与 JavaScript 中的 var 相似)，和返回值为无类型的方法

class Man {
      
  def name = "javachen"
  def introduce() {
      
    return "I'm $name" // return可以省略
  }
}

3.2 语句

Groovy的语句和Java类似，但是有一些特殊的地方。例如语句的分号是可选的。如果每行一个语句，就可以省略分号；如果一行上有多个语句，则需要用分号来分隔。

另外return关键字在方法的最后是可选的；同样，返回类型也是可选（缺省是Object）。

调用方法时可以不用括号，只要有参数，并且没有歧义。

一个示例：

package com.javachen.groovy.test

class Hello{
      
    static main(args){
      
        println "hello world"
    }
}

和Java一样，程序会从这个类的main方法开始执行，和Java的区别是：

class 前省略 public 修饰；
main 方法前省略 public 修饰；
main 方法省略返回值类型 void；
main 方法形参列表省略类型 String[]；

当然，这只是 Groovy 代码的一种写法，实际上执行 Groovy 代码完全可以不必需要一个类或 main 方法，所以更简单的写法如下：

package com.javachen.groovy.test

println "hello world"

将上述代码保存为 hello.groovy，然后运行：

$ groovy hello.groovy
hello world

可以看到正确的输出了 “hello world”

3.3 变量和类型

像其他 Script 一样，Groovy 不需要显式声明类型。在 Groovy 中，一个对象的类型是在运行时动态发现的，这极大地减少了要编写的代码数量。

在 Groovy 中，类型对于值(varibles)、属性(properties)、方法(method)和闭包(closure)参数、返回值都是可有可无的，只有在给定值的时候，才会决定它的类型，(当然声明了类型的除外）。

Groovy 对 boolean 类型放宽了限制：

常量true和false分别表示“真”和“假”；
null表示false，非null表示true；
空字符串”“表示false，非空字符串表示true；
0表示false，非0表示true；
空集合表示false，非空集合表示true；

3.4 字符串

Groovy 中的字符串允许使用双引号和单引号。当使用双引号时，可以在字符串内嵌入一些运算式，Groovy 允许您使用与 bash 类似的 ${expression} 语法进行替换。可以在字符串中包含任意的 Groovy 表达式。

大块文本：

如果有一大块文本（例如 HTML 和 XML）不想编码，你可以使用Here-docs。 here-docs 是创建格式化字符串的一种便利机制。它需要类似 Python 的三重引号(“”“)开头，并以三重引号结尾。

package com.javachen.groovy.test

// groovy中对字符串的使用做了大量的简化

// 获取字符串中的字符
s = "Hello"
println s[0]		// 输出'H'
// 遍历字符串中的所有字符
s.each {
      
	print it + ", "		// 遍历字符串中的所有字符
}
println ""

// 截取字符串
s1 = s[1..3]		// 截取s字符串标号从1到3的3个字符，组成新的字符串赋予s1
					// 该语法是String类的substring方法的简化
println s1

// 模板式字符串
n = 100
s1 = "The number n is ${n}"		// ${n}表示将变量n的值放在字符串该位置
println s1

// 带格式的长字符串
// """和"""之间的所有字符都会被算做字符串内容，包括// /*以及回车，制表符等
s = """
大家好
欢迎大家学习Groovy编程
Groovy is a better Java
"""
println s

// groovy中单引号的作用

// 在不定义类型时，单引号也表示字符串
c1 = 'A'
println c1.getClass().getName()

// 要明确的定义字符类型，需要给变量增加定义
char c2 = 'A'
println c2.getClass().getName()

// 取消转义字符
s = 'c:\\windows\\system'
println s
s = /c:\windows\system/		// 利用/字符串/定义的字符串
println s

// 字符串运算
s = "hello"
s = s + " world"			// +运算符用于连接字符串
println s
s -= "world"				// -可以从字符串中去掉一部分
println s
s = s * 2					// *可以让字符串重复n次
println s

// 字符串比较
s1 = "Abc"
s2 = "abc"

println s1 == s2 ? "Same" : "Different"		// 执行s1.equals(s2)
println s1 != s2 ? "Different" : "Same"		// 执行!s1.equals(s2)
println s1 > s2 ? "Great" : "Less"			// 执行s1.compareTo(s2) > 0
println s1 < s2 ? "Less" : "Great"			// 执行s1.compareTo(s2) < 0
println s1 <=> s2 == 1 ? "Same" : "Different"		// 执行s1.compareTo(s2)

Groovy增加了对字符串的如下操作：

集合操作，Groovy 将字符串看为字符的集合，可以通过 [n] 运算符直接访问字符串内的字符，也可以通过 each 循环遍历字符串的每一个字符；
截取子字符串的 substring 方法被简化为使用数值范围来进行截取，”hello”[1..3]表示截取字符串 “hello” 从下标为1到下标为3的部分，结果为 “ell”；
Groovy 增加了一个新的字符串类型 GString，这种字符串可以进行格式化，在 GString 字符串中使用 ${变量}，可以将该变量的值放入字符串的相应位置；
带格式的字符串，使用 “"”字符串内容””“(连续的三个引号)，这种字符串中可以包含直接输入的回车，TAB键，//或/*等字符，而这些在 Java 原本的字符串里，都必须通过转义字符来表示，例如只能用 \n 表示回车；
单引号问题，和 Javascript 和 PHP 类似，Groovy 中无论是单引号还是双引号都表示是字符串类型，例如 ‘a’ 和”a”都是字符串类型，所以如果要确定存储一个 char 类型变量，就必须使用 char 类型定义强类型变量；实际上 Groovy 认为 char 类型并不是必须的，大部分时候字符串类型更方便一些；
用 / 包围的字符串，即 /字符串内容/，可以避免在字符串中使用转义字符，但 \n 字符不包含在内；
Java 中对字符串的运算只有+运算，在 Groovy 中，字符串还可以使用 - 运算和 * 运算，减法运算可以从一个字符串中删除一部分，乘法运算可以将一个字符串重复n次；
Groovy 还为字符串加入了所有关系运算符，包括 ==, !=, >, <, >=, <=，这要归功于 Groovy 允许运算符重载，对于 == 和 !=，将调用 String 类的 equals 方法，对于 >, >=, <, <=，将调用 String 类的 compareTo 方法；Groovy 还增加了一个特殊的运算符<=>，这个运算符也会调用 compareTo 方法，返回 compareTo 方法的返回值；

3.5 switch语句

Groovy 的 switch 语句兼容 Java 代码，但是更灵活，Groovy 的 switch 语句能够处理各种类型的 switch 值，可以做各种类型的匹配：

1. case 值为类名，匹配 switch 值为类实例
1. case 值为正则表达式，匹配 switch 值的字符串匹配该正则表达式
1. case 值为集合，匹配 switch 值包含在集合中，包括 ranges
1. 除了上面的，case值与switch值相等才匹配。

Switch 语句的工作原理：switch 语句在做 case 值匹配时，会调用 isCase(switchValue) 方法，Groovy 提供了各种类型，如类，正则表达式、集合等等的重载。可以创建自定义的匹配类，增加 isCase(switchValue) 方法来提供自定义的匹配类型。

3.6 循环

package com.javachen.groovy.loops

public class LoopTest{
      
  public static void main(args){
      
  	def list = ["Lars", "Ben", "Jack"]
    // using a variable assignment
    list.each{
      firstName->
      println firstName
    }
    // using the it variable
    list.each{
      println it}

	5.times {
      println "Times + $it "}
	1.upto(3) {
      println "Up + $it "}
	4.downto(1) {
      print "Down + $it "}
	def sum = 0
	1.upto(100) {
      sum += 1}
	print sum
	
	(1..6).each {
      print "Range $it"}

	for (i in 0..9) {
      
      println ("Hello $i")
    }
  }  
}

Groovy对Java循环结构作了如下的修整：

对于 for 循环：除了传统三表达式的 for 循环和用于迭代的 for each 循环外，Groovy 允许 for 循环遍历一个范围（Range），例如 for (i in 1..10)，表示循环10次，i在1至10之间取值；
对于整数，Groovy 增加了如下几个方法来进行循环：
- upto：n.upto(m) 函数，表示循环 m- n 次，并且会有一个循环变量it，从 n 开始，每次循环增加1，直到 m。循环体写在upto方法之后大括号中，表示一个闭包，在闭包中，it 作为循环变量，值从 a 增长到 n；
- times：n.times 函数，表示循环 n 次，循环变量 it 从0开始到n结束。
- step：n.step(x, y) 函数，表示循环变量从 n 开始到 x 结束，每次循环后循环变量增加 y，所以整个循环次数为 (x - n) / y 次；