groovy-语句

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