Groovy是一门基于JVM的动态语言，很多语法和Java类似。大部分Java代码也同时是合法的Groovy代码。本文是快速入门，所以针对语法并不会做非常详细的介绍。如果需要详细语法，请直接查看Groovy官方文档。另外为了省事，本文中的大部分代码例子直接引用了Groovy文档。

基本内容

注释

单行注释，以//开头。

多行注释，/* */。

GroovyDoc注释，和JavaDoc注释类似。

标识符

大体上，Groovy标识符的命名规则和Java差不多。如果某个标识符在Groovy中合法，在Java中不合法，我们可以使用单引号或双引号将标识符包括起来。

字符串

字符串可以使用单引号'或双引号"包括起来。

def str="1234"
def str2='1234'

多行字符串可以使用三个连续的单引号或双引号包括。不论是单行还是多行字符串， 都可以使用反斜杠转义字符。

def multiline="""line1
line2
line3
"""

我们还可以将变量直接插入到字符串中，这叫做内插字符串（String interpolation）。语法和EL表达式类似。编译器会把美元和花括号中的内容替换成实际的值，内插字符串中还可以进行表达式计算。

def name = 'Guillaume' // a plain string
def greeting = "Hello ${name}"

当内插字符串可以由前后的符号区分出的时候，花括号可以省略。

def person = [name: 'Guillaume', age: 36]
assert "$person.name is $person.age years old" == 'Guillaume is 36 years old'

当使用内插字符串的时候，字符串字面值是Groovy的字符串类型GString。这一点需要注意。普通的Java字符串是不变的，而GString是可变的。另外它们的哈希值也不同。因此在使用Map等数据类型的时候需要格外注意，避免使用GString作为Map的键。

字符

Groovy没有字符字面量。如果需要向Java方法传入单个字符的话，可以使用下面的方法进行转换。

def c2 = 'B' as char 
assert c2 instanceof Character

def c3 = (char)'C' 
assert c3 instanceof Character

布尔类型

Groovy的布尔类型和Java类似，也有true和false两个值。不过Groovy的布尔语义更丰富。未到结尾的迭代器、非空对象引用、非零数字都认为是真；空集合、空字符串等认为是假。详情参见Groovy文档 core-semantics#Groovy-Truth

数字类型

Groovy支持byte、char 、short、 int、long和 BigInteger等几种数字类型。如果使用普通方式声明，它们和Java中的变量很相似。

int   i = 4

BigInteger bi =  6

如果使用def关键字声明，那么这些数字会自动选择可以容纳它们的类型。

def a = 1
assert a instanceof Integer

// Integer.MAX_VALUE
def b = 2147483647
assert b instanceof Integer

// Integer.MAX_VALUE + 1
def c = 2147483648
assert c instanceof Long

// Long.MAX_VALUE
def d = 9223372036854775807
assert d instanceof Long

// Long.MAX_VALUE + 1
def e = 9223372036854775808
assert e instanceof BigInteger

这些整数还可以添加0b、0和0x前缀，分别代表8进制数，8进制数和16进制数。

另外Groovy还支持float、double和BigDecimal三种浮点数类型。原理同上。还可以使用科学计数法1.123E10这样的形式代表浮点数。

Groovy的数字常量同样支持后缀区分字面值类型，这几种类型和Java中的类似。唯一不同的是Groovy还支持G和g后缀，代表BigInteger或BigDecimal类型，根据字面值是否含有小数点来区分。

数学计算

数字的计算结果和Java规则类似：小于int的整数类型会被提升为int类型，计算结果也是int类型；小于long的整数类型和long计算，结果是long类型；BigInteger和其它整数类型计算，结果是BigInteger类型；BigDecimal和其它整数类型计算，结果是BigDecimal类型；BigDecimal和float、double等类型计算，结果是double类型。

列表

Groovy中的列表比较灵活，有点像Python中的列表。使用[....]语法可以声明列表，默认情况下列表是ArrayList实现。我们也可以使用as运算符自己选择合适的列表底层类型。

def arrayList = [1, 2, 3]
assert arrayList instanceof java.util.ArrayList

def linkedList = [2, 3, 4] as LinkedList    
assert linkedList instanceof java.util.LinkedList

有了列表之后，就可以使用它了。使用方法和Python差不多。我们使用[索引]引用和修改列表元素。如果索引是负的，则从后往前计数。要在列表末尾添加元素，可以使用左移运算符<<。如果在方括号中指定了多个索引，会返回由这些索引对应元素组成的新列表。使用两个点加首位索引..可以选择一个子列表。

def letters = ['a', 'b', 'c', 'd']

assert letters[0] == 'a'     
assert letters[1] == 'b'

assert letters[-1] == 'd'    
assert letters[-2] == 'c'

letters[2] = 'C'             
assert letters[2] == 'C'

letters << 'e'               
assert letters[ 4] == 'e'
assert letters[-1] == 'e'

assert letters[1, 3] == ['b', 'd']         
assert letters[2..4] == ['C', 'd', 'e']   

列表还可以组合成复合列表。

def multi = [[0, 1], [2, 3]]     
assert multi[1][0] == 2   

数组

声明数组的方式和列表一样，只不过需要显示指定数组类型。数组的使用方法也和列表类似，只不过由于数组是不可变的，所以不能像数组末尾添加元素。

int[] intArray = [1, 2, 3, 4, 5]

def intArray2 = [1, 2, 3, 4, 5, 6] as int[]

Map

创建Map同样使用方括号，不过这次需要同时指定键和值了。Map创建好之后，我们可以使用[键]或.键来访问对应的值。默认情况下创建的Map是java.util.LinkedHashMap，我们可以声明变量类型或者使用as关键字改变Map的实际类型。

def colors = [red: '#FF0000', green: '#00FF00', blue: '#0000FF']   

assert colors['red'] == '#FF0000'    
assert colors.green  == '#00FF00' 

关于Map有一点需要注意。如果将一个变量直接作为Map的键的话，其实Groovy会用该变量的名称作为键，而不是实际的值。如果需要讲变量的值作为键的话，需要在变量上添加小括号。

def key = 'name'
def person = [key: 'Guillaume']      //键是key而不是name

assert !person.containsKey('name')   
assert person.containsKey('key') 

//这次才正确的将key变量的值作为Map的键
person = [(key): 'Guillaume']        

assert person.containsKey('name')    
assert !person.containsKey('key')  

运算符

和Java类似的运算符

Groovy的数学运算符和Java类似，只不过多了一个乘方运算**和乘方赋值**=。

Groovy的关系运算符（大于、小于等于这些）和Java类似。

Groovy的逻辑运算符（与或非这些）和Java类似，也支持短路计算。

Groovy的位运算符合Java类似。

Groovy的三元运算符条件?值1:值2和Java类似。

可空运算符

Groovy支持Elvis操作符，当对象非空的时候结果是值1，为空时结果是值2。或者更直接，对象非空是使用对象本身，为空时给另一个值，常用于给定某个可空变量的默认值。

displayName = user.name ? user.name : 'Anonymous'   
displayName = user.name ?: 'Anonymous'   

安全导航运算符

当调用一个对象上的方法或属性时，如果该对象为空，就会抛出空指针异常。这时候可以使用?.运算符，当对象为空时表达式的值也是空，不会抛出空指针异常。

def person = Person.find { it.id == 123 }    
def name = person?.name                      
assert name == null

字段访问运算符

在Groovy中默认情况下使用点运算符.会引用属性的Getter或Setter。如果希望直接访问字段，需要使用.@运算符。

class User {
    public final String name                 
    User(String name) { this.name = name}
    String getName() { "Name: $name" }       
}
def user = new User('Bob')
assert user.name == 'Name: Bob'   
assert user.@name == 'Bob'   

方法指针运算符

我们可以将方法赋给变量，这需要使用.&运算符。然后我们就可以像调用方法那样使用变量。方法引用的实际类型是Groovy的闭包Closure。这种运算符可以将方法作为参数，让Groovy语言非常灵活。

def str = 'example of method reference'            
def fun = str.&toUpperCase                         
def upper = fun()                                  
assert upper == str.toUpperCase()   

展开运算符

展开运算符*.会调用一个列表上所有元素的相应方法或属性，然后将结果再组合成一个列表。

class Car {
    String make
    String model
}
def cars = [
       new Car(make: 'Peugeot', model: '508'),
       new Car(make: 'Renault', model: 'Clio')]       
def makes = cars*.make                                
assert makes == ['Peugeot', 'Renault'] 

展开运算符是空值安全的，如果遇到了null值，不会抛出空指针异常，而是返回空值。

cars = [
   new Car(make: 'Peugeot', model: '508'),
   null,                                              
   new Car(make: 'Renault', model: 'Clio')]
assert cars*.make == ['Peugeot', null, 'Renault']     
assert null*.make == null  

展开运算符还可以用于展开方法参数、列表和Map。

范围运算符

使用..创建范围。默认情况下范围是闭区间，如果需要开闭区间可以在结束范围上添加<符号。范围的类型是groovy.lang.Range，它继承了List接口，也就是说我们可以将范围当做List使用。

def range = 0..5                                    
assert (0..5).collect() == [0, 1, 2, 3, 4, 5]       
assert (0..<5).collect() == [0, 1, 2, 3, 4]         
assert (0..5) instanceof List                       
assert (0..5).size() == 6   

比较运算符

<=>运算符相当于调用compareTo方法。

assert (1 <=> 1) == 0

成员运算符

成员运算符in相当于调用contains或isCase方法。

def list = ['Grace','Rob','Emmy']
assert ('Emmy' in list)

相等运算符

==运算符和Java中的不同。在Groovy中它相当于调用equals方法。如果需要比较引用，使用is。

def list1 = ['Groovy 1.8','Groovy 2.0','Groovy 2.3']        
def list2 = ['Groovy 1.8','Groovy 2.0','Groovy 2.3']        
assert list1 == list2    //比较内容相等                                   
assert !list1.is(list2)   //比较引用相等

转换运算符

我们可以使用Java形式的(String) i来转换类型。但是假如类型不匹配的话，就会抛出ClassCastException。而使用as运算符就会避免这种情况。

Integer x = 123
String s = x as String 

如果希望自己的类也支持as运算符的话，需要实现asType方法。

表达式和语句

声明变量

Groovy支持以传统方式使用变量类型 变量名的方式声明变量，也可以使用def关键字声明变量。使用def关键字的时候，变量类型由编译器自动推断，无法推断时就是Object类型。

Groovy可以同时声明多个变量。

def (a, b, c) = [10, 20, 'foo']

如果左边的变量数比右面的值多，那么剩余的变量就是null。

def (a, b, c) = [1, 2]
assert a == 1 && b == 2 && c == null

如果等号右面比左面多，那么多余的值会被忽略。

def (a, b) = [1, 2, 3]
assert a == 1 && b == 2

自定义对象也可以用多重赋值进行对象解构。该对象必须有getAt方法。

class CustomDestruction {
    int a
    int b
    int c
    //解构需要实现getAt方法
    def getAt(int i) {
        switch (i) {
            case 0: a; break
            case 1: b; break
            case 2: c; break
            default: throw new IllegalArgumentException()
        }
    }
    static void main(String[] args) {
        //对象解构
        def obj = new CustomDestruction(a: 3, b: 4, c: 5)
        def (x, y, z) = obj
        println("x=$x,y=$y,z=$z")
    }
}

条件语句

Groovy的if语句和Java的类似。不过在Groovy中布尔值的真假不仅看条件比较的结果，还可以以其他情况判断。前面已经介绍过了。switch语句同理，真值判断非常自由。详情可参见Groovy文档 真值判断。

循环语句

Groovy支持传统的Java的for(int i=0;i<N;i++)和for(int i :array)两种形式。另外还支持for in loop形式，支持迭代范围、列表、Map、数组等多种形式的集合。

// 迭代范围
def x = 0
for ( i in 0..9 ) {
    x += i
}
assert x == 45

// 迭代列表
x = 0
for ( i in [0, 1, 2, 3, 4] ) {
    x += i
}

while语句的形式和Java相同。

断言语句

前面我们看到了很多Groovy断言的例子。Groovy断言语句的功能很强大，以至于文档中写的是强力断言（Power assertion）。

Groovy断言的形式如下。Groovy断言和Java断言完全不同。Groovy断言是一项语言功能，一直处于开启状态，和JVM的断言功能-ea完全无关。所以它是我们进行单元测试的首选方式。

assert [left expression] == [right expression] : (optional message)

比如我们要断言1+1=3。结果应该类似这样。越复杂的表达式，断言效果越清晰。有兴趣的同学可以试试。

Caught: Assertion failed:

assert 1+1 == 3
        |  |
        2  false

面向对象编程

Groovy的面向对象编程和Java类似，但是提供了一系列功能简化面向对象开发。当然如果你想使用传统的Java语法来声明所有成员也可以，Groovy设计目的之一就是让Java程序员能够以低成本的方式切换到Groovy上。

• 字段默认是私有的，Groovy会自动实现Getter和Setter方法。
• 方法和属性默认是公有的。
• 类不必和文件名相同，
• 一个文件可以有多个类，如果一个类也没有，该文件就会被看做是脚本。

构造器

Groovy的构造器非常灵活，我们可以使用传统的Java方式声明和使用构造器，也可以完全不声明构造器。有时候不声明反而更简单。如果没有声明构造器的话，我们可以在构造对象的时候使用命名参数方式传递参数，这种方式非常方便，因为我们不需要声明所有参数，只要声明所需的参数即可。

如果希望对构造器进行限制，可以手动声明构造器，这样这种自动构造就不会进行了。

class Product {
    String name
    double price

    String toString() {
        return "Product(name:$name,price:$price)"
    }

    static void main(String[] args) {
        def product = new Product(name: 'AMD Ryzen 1700', price: 2499)
        println("隐式构造器:$product")
    }
}

方法

Groovy方法和Java方法基本相同。不过Groovy方法更方便：支持命名参数和默认参数。另外Groovy方法可以使用def关键字声明，这时候方法返回类型是Object。在Groovy中方法的返回语句可以省略，这时候编译器会使用方法的最后一个语句的值作为返回值。在前面我们还看到了def关键字定义变量，这时候变量的类型需要从代码中推断。

在使用命名参数的时候需要注意一点，方法参数需要声明为Map类型（不需要详细指定键和值的类型），在调用方法的时候使用命名参数方式传入参数。

def foo(Map args) { "${args.name}: ${args.age}" }
//调用方法
foo(name: 'Marie', age: 1)

另外方法的括号是可选的，我们可以省略括号直接像这样调用方法。

methodWithDefaultParam '555', 42

字段

Groovy中字段和Java中的概念类似。不过Groovy更加方便：默认情况下字段是私有的，Groovy自动生成字段的Getter和Setter。如果需要更精细的控制，把它当成Java字段用就行了。不过如果自定义字段的话，Groovy不会自动生成对应的属性了。

属性

如果字段上面没有声明访问修饰符（private、public这些），Groovy就会自动生成Gettter和Setter。如果字段是final的，那么只会生成Getter。这就是Groovy方便的属性功能。

当然Groovy的方便不止于此，我们的所有类似Java访问字段的语法，实际上都会调用字段对应的Getter和Setter。这样显著减少了代码量。如果在类内部的话，.字段语法会直接访问字段，这样做是为了防止无限递归调用属性。

下面的例子中，第一次调用p.name = 'Marge'如果在类内部，就直接写入字段，如果调用在类外部，就会使用Setter写入。第二次调用使用了方法语法，直接使用Setter写入，所以不管在类内还是类外，写入的值都是"Wonder$name"。

class Person {
    String name
    void name(String name) {
        this.name = "Wonder$name"       
    }
    String wonder() {
        this.name                       
    }
}
def p = new Person()
p.name = 'Marge'                        
assert p.name == 'Marge'                
p.name('Marge')                         
assert p.wonder() == 'WonderMarge' 

特征类

Groovy和Scala一样，支持特征类（trait）。特征类就好像自带实现的接口。在Java中只能继承一个类和多个接口。在Groovy中，我们可以继承多个特征类。特征类和普通的Groovy类一样，可以包括属性、字段、方法等，特征类也可以是抽象的。

使用特征类，我们可以在Groovy中实现类似C++的多重继承。另外，特征类支持运行时动态绑定，在某些情况下非常有用。

trait Readable {
    void read() {
        println("read...")
    }
}

trait Writable {
    void write(String text) {
        println("write $text")
    }
}

class Notebook implements Readable, Writable {
    static void main(String[] args) {
        //使用特性类
        def notebook = new Notebook()
        notebook.read()
        notebook.write("something")
    }
}

闭包

闭包是Groovy非常重要的一个功能，也是我们介绍的最后一个功能。要了解闭包，最好先知道Java的Lambda表达式、匿名内部类等概念。Groovy闭包和Lambda表达式概念相近，但是功能更强大。

声明闭包

闭包的形式如下。

{ [closureParameters -> ] statements }

以下都是合法的Groovy闭包。所有闭包都是groovy.lang.Closure类型的实例。闭包的参数类型是可选的。如果闭包只有单个参数，参数名也是可选的。Groovy会隐式指定it作为参数名。Kotlin语言也是类似的做法，有助于我们先出可读性很好的闭包。

{ 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()
}

调用闭包

闭包既可以当做方法来调用，也可以显示调用call方法。

def code = { 123 }
assert code() == 123
assert code.call() == 123

调用有参数的闭包也是类似的。

def isOdd = { int i-> i%2 == 1 }                            
assert isOdd(3) == true                                     
assert isOdd.call(2) == false  

使用闭包

Groovy闭包类似Java的Lambda表达式和匿名内部类，不过使用更方便，能让我们减少不少代码量。闭包还可以作为方法参数传递到其他地方，这让闭包更加灵活。

static void funWithClosure(Closure closure) {
    closure()
}

//在其他地方调用该方法
funWithClosure({ println("Hello yitian") })

//括号还可以省略，更加简练
funWithClosure { println("Hello yitian") }

关于闭包，还有几个精彩的例子，就是Gradle脚本和Groovy模板引擎，它们都利用了Groovy强大的闭包功能，构建出简练而强大的DSL，让我们用很少的代码就可以实现强大的功能（虽然学起来稍微复杂点）。

参考资料

Groovy官方文档 语法