groovy语句类似于java语句，但是在groovy中的分号”;”是可选的。比如：
1 |
def x = [1, 2, 3] |
2 |
println x |
3 |
def y = 5; def x = y + 7 |
4 |
println x |
5 |
assert x == 12 |
而且对于一些方法参数等复杂的事情，我们可以横跨多行：
1 |
def x = [1, 2, 3, |
2 |
4, 5, 6] |
3 |
println( |
4 |
x |
5 |
) |
6 |
if (x != null && |
7 |
x.size() > 5) { |
8 |
println("Works!") |
9 |
} |
10 |
else { |
11 |
assert false: "should never happen ${x}" |
12 |
} |
groovy支持一行给多个变量赋值：
1 |
def (a, b) = [1, 2] |
2 |
3 |
assert a == 1 |
4 |
assert b == 2 |
这就使得我们的方法可以返回多个值了，比如返回经纬度的方法：
1 |
def geocode(String location) { |
2 |
// implementation returns [48.824068, 2.531733] for Paris, France |
3 |
[48.824068, 2.531733] |
4 |
} |
5 |
6 |
def (_lat, _long) = geocode("Paris, France") |
7 |
8 |
assert _lat == 48.824068 |
9 |
assert _long == 2.531733 |
当然我们也可以定义方法的参数类型：
1 |
def (int i, String s) = [1, 'Groovy'] |
2 |
3 |
assert i == 1 |
4 |
assert s == 'Groovy' |
对于事先已经定义好的变量，我们在赋值的时候不需要def关键字：
1 |
def firstname, lastname |
2 |
3 |
(firstname, lastname) = "Guillaume Laforge".tokenize() |
4 |
5 |
assert firstname == "Guillaume" |
6 |
assert lastname == "Laforge" |
当然，在赋值的时候可能会出现两侧的数量不一致的情况，比如当左侧数量多于右侧的时候，左侧多出来的为null：
1 |
def elements = [1, 2] |
2 |
def (a, b, c) = elements |
3 |
4 |
assert a == 1 |
5 |
assert b == 2 |
6 |
assert c == null |
但是当右侧的多于左侧的时候，多出来的不赋值。
1 |
def elements = [1, 2, 3, 4] |
2 |
def (a, b, c) = elements |
3 |
4 |
assert a == 1 |
5 |
assert b == 2 |
6 |
assert c == 3 |
根据groovy的语法，我们可以在一行中swap两个变量：
1 |
// given those two variables |
2 |
def a = 1, b = 2 |
3 |
4 |
// swap variables with a list |
5 |
(a, b) = [b, a] |
6 |
7 |
assert a == 2 |
8 |
assert b == 1 |
注释：
1 |
print "hello" // This is a silly print statement |
2 |
3 |
/* This is a long comment |
4 |
about our favorite println */ |
5 |
println "hello" |
6 |
7 |
// This doesn't work: |
8 |
# Bad comment |
我们可以发现#其实并不是注释字符。
方法调用
groovy中的方法调用类似于java，比如：
1 |
class Foo { |
2 |
def calculatePrice() { |
3 |
1.23 |
4 |
} |
5 |
6 |
static void main(args) { |
7 |
def foo = new Foo() |
8 |
def p = foo.calculatePrice() |
9 |
assert p > 0 |
10 |
11 |
println "Found price: " + p |
12 |
} |
13 |
} |
可选的括号
在groovy中，Groovy中的方法调用可以省略括号，如果有至少一个参数，并且不存在任何含糊。比如：
1 |
println "Hello world" |
2 |
System.out.println "Nice cheese Gromit!" |
在命名参数的时候，也是可以省略的：
1 |
compare fund: "SuperInvestment", withBench: "NIKEI" |
2 |
monster.move from: [3,4], to: [4,5] |
命名参数传递
当调用一个方法时，你可以通过在命名参数。参数名称和值之间由一个冒号，比如：
1 |
def bean = new Expando(name:"James", location:"London", id:123) |
2 |
println "Hey " + bean.name |
3 |
assert bean.id == 123 |
给方法传递闭包
闭包也可以像其他对象一样传递给方法：
1 |
def closure = { param -> param + 1 } |
2 |
def answer = [1, 2].collect(closure) |
3 |
assert answer == [2, 3] |
上面的代码等价于：
1 |
answer = [1, 2].collect { param -> param + 1 } |
2 |
assert answer == [2, 3] |
属性
为了访问属性你可以使用属性名和.：
1 |
def bean = new Expando(name:"James", location:"London", id:123) |
2 |
def name = bean.name |
3 |
println("Hey ${name}") |
4 |
bean.location = "Vegas" |
5 |
println bean.name + " is now in " + bean.location |
6 |
assert bean.location == "Vegas" |
安全导航
如果你在访问属性的时候，避免出现空指针异常的话，那么安全导航操作符可能适合你：
1 |
def foo = null |
2 |
def bar = foo?.something?.myMethod() |
3 |
assert bar == null |
