Groovy的基础语法

Groovy 的基础语法
Groovy 的基础语法
Groovy 的语法融合了Ruby 、Python 和Smalltalk 的一些最有用的功能，同时保留了基于Java 语言的核心语法。

对于Java 开发人员，Groovy 提供了更简单的替代语言，且几乎不需要学习时间。

语句
Groovy 的语句和Java 类似，但是有一些特殊的地方。

例如语句的分号是可选的。

如果每行一个语句，就可以省略分号；如果一行上有多个语句，则需要用分号来分隔。

x = [1, 2, 3] println x y = 5; x = y + 7 println x assert x == 12 另外return 关键字在方法的最后是可选的；同样，返回类型也是可选(缺省是Object )。

动态类型
像其他Script 一样，Groovy 不需要显式声明类型。

在Groovy 中，一个对象的类型是在运行时动态发现的，这极大地减少了要编写的代码数量。

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

例如：//Groovy 动态类型myStr = "Hello World"由于使用了动态类型，不需要继承就可以得到多态的全部功
厶匕
能：
class Song{ Property length Property name } class Book{ def public name def public author } def doSomething(thing){ println "going to do something with a thing named = " + } 这里定义了两个Groovy 类，Song 和Book 。

这两个类都包含一个name 属性。

函数doSomething ，它以一个thing 为参数，并试图打印这个对象的name 属性，但doSomething 函数没有定义其输入参数的类型，所以只要对象包含一个name 属性，那么它就可以工作。

可见，Song 和Book 的实例都可以作为doSomething 的输入参数。

mySong = new Song(length:90, name:"Burning Down the House") myBook = new Book(name:"One Duck Stuck", author:"Phyllis Root") doSomething(mySong) //prints Burning Down the House doSomething(myBook) //prints One Duck Stuck def
doSth=this.&doSomething doSth(mySong) doSth(myBook) 在例子的最后，我们还创建了doSomething 的一个函数指针doSth ，最后的执行结果与调用doSoemthing 是一样的。

值得注意的是：与Groovy Beta 不同，在使用新的JSR
Groovy 类时，类里面的所有的变量都必须加上def 关键字或者private 、protected 或public 这样的修饰符。

当然，也可以用
@Property 关键字声明成员变量。

在Script 中则不必。

字符串
Groovy 中的字符串允许使用双引号和单引号。

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

可以在字符串中包含任意的Groovy 表达式。

name="James" println "My name is ${name},'00${6+1}'"
//prints My name is James,'007'
Groovy 还支持"uXXXX" 引用（其中X 是16 进制数），用来表示特殊字符，例如"u0040" 与"@" 字符相同。

大块文本如果有一大块文本（例如HTML 和XML ）不想编码，你可以使用Here-docs. here-docs 是创建格式化字符串的一种便利机制。

它需要类似Python 的三重引号（"""）开头，并以三重引号结尾。

hello there ${name} how are you today? ” "" assert text != null
println(text)
name = "James" text = ""
在Groovy-JSR 中，不再支持下面这种多
行字符串，个人觉得似乎与Here-docs 功能重叠：
foo = “ hello there how are things?
println(foo)
对字符串的操作
contains 字符串中是否包含子字符串，'groovy'.contains('oo') 将返回true;
count 返回字符串中子字符串出现的次数，'groooovy'.count('oo') 将返回 3.
tokenize 根据分隔符将字符串分解成子串，
'appabananaAgrap'.tokenize('A') 返回
['apple','banana','grape'] 。

减操作'groovy'-'oo' ，结果是'grvy' 。

乘操作'oo'*3 ，结果是'oooooo' 。

Groovy 主要结构接下来将展示Groovy 的一些结构，包逻辑分支，类、闭包逻辑分支if-else 语句Groovy 提供Java 相同的if-else 语句。

x = false y = false if ( !x ) { x = true }
assert x == true if ( x ) { x = false } else{ y = true } assert x == y Groovy 也支持三元操作符。

y = 5 x = (y > 1) ? "worked" : "failed" assert x == "worked" switch 语
句
Groovy 的switch 语句兼容Java 代码，但是更灵活，Groovy 的switch 语句能够处理各种类型的switch 值，可以做各种类型的匹配：
case 值为类名，匹配switch 值为类实例
case 值为正则表达式，匹配switch 值的字符串匹配该正则表达式case 值为集合，匹配switch 值包含在集合中，包括ranges 除了上面的，case 值与switch 值相等才匹配。

x = 1.23 result = "" switch ( x ) { case "foo": result = "found foo" // lets fall through case "bar": result += "bar" case [4, 5,
6, ‘ inList ‘ ]: result = "list" break case 12..30: result = "range" breakcase Integer: result = "integer" break case Number:
result = "number" break default: result ="default" } assert result == "number" Switch 语句的工作原理：switch 语句在做case 值匹配时，会调用
isCase(switchValue) 方法，Groovy提供了各种类型，如类，正则表达式、集合等等的重载。

可以创建自定义的匹配类，增加isCase(switchValue) 方法来提供自定义的匹配类型。

循环
while 和do 循环
Groovy 支持Java 相同的while 循环，但目前暂不支持do
循环
x = 0 y = 5 while ( y-- > 0 ){ x++ } assert x == 5
for 循环
Groovy 的for 循环更简单，而且能够和各种类型的数组、集合、Map、范围等一起工作，我们稍候会详细介绍这些内容。

// iterate over a range x = 0 for ( i in 0..9 ) { x += i }
assert x == 45
// iterate over a listx = 0 for ( i in [0, 1, 2, 3, 4] ) { x += i } assert x == 10// iterate over an array array = (0..4).toArray() x = 0 for ( i in array ) { x += i }
assert x == 10
// iterate over a mapmap = [ ‘abc‘:1, ‘def ‘:2, ‘xyz‘:3] x =
( e in map ) { x += e.value }
assert x == 6// iterate over values in a map x = 0 for ( v in map.values() ) {
x += v }
assert x == 6
// iterate over the characters in a string text = "abc" list = [] for (c in text)
{ list.add? } assert list == ["a", "b", "c"]
运行Groovy 脚本你可以象使用Perl 一样编写Groovy 脚本，不需要class ，不需要Main 入口点，也不需要声明变量；此外，你还可以用def 语句来定义自己的函数，并在脚本中使用它。

像许多脚本语言一样，Groovy 是在运行时解释的，无编译的代码在构建-运行周期中可以提供很多好处。

运行时编译使Groovy 成为快速原型设计、构建不同的实用程序和测试框架的理想平台。

通过以下代码可以很简单的运行Groovy.
groovy HelloWorld.groovy
除了利用解释器来运行Groovy脚本外，Groovy提供了两种不同的解释器Shell ，使所有有效的Groovy 表达式可以交互地执行：
运行groovysh 启动命令Shell ，可以输入Groovy 语句直接执行
运行groovyConsole 启动Swing 方式的Groovy 控制台，这是一个简单的Groovy 编辑器
Groovy 脚本实际上是字节码级别的Java 类。

因此，还可以用groovyc 编译
Groovy 脚本。

可以通过命令行或者Ant 使用groovyc 以生成脚本的类文件。

这
些类可以用普通java 命令运行，只要classpath 包括groovy.jar 和asm.jar 。

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

Groovy 是由James Strachan 和Bob McWhirter 这两位天才发明的，(JSR
241 2004 年3月)。

Groovy完全以Java API 为基础，使用了Java 开发人员最
熟悉的功能和库。

Groovy 的语法近似Java ，并吸收了Ruby 的一些特点，因此Groovy 在某
些场合可以扮演一种“咖啡伴侣”的角色。

那么Groovy 和Java 相比，有什么变化呢？Groovy 通过
以下方式提供了一种敏捷的开发方式：不用编译。

允许动态类型。

合成结构容易。

其脚本可以在普通Java 应用程序中使用。

提供一个shell 解析器。

这些特性使Groovy 成为一种特别容易学习和使用的语言. 我们先借用IBM
Groovy 教程中的例子，下面的代码利用了Freemarker 模板引擎来创建一个
Template 对象，然后将内容打印到标准输出。

例(1) 是Java 代码，例(2) 是
Groovy 代码。

可以看到二者非常的类似。

//简单的TemplateReader Java 类import java.io.File; import
java.io.IOException; import freemarker.template.Configuration; import freemarker.template.Template; public class
TemplateReader { public static void main(String[] args){ try{ Configuration cfg = Configuration.getDefaultConfiguration();
cfg.setDirectoryForTemplateLoading(new File("C:\\dev\\projects\\http-
tester\\src\\conf")); Template temp = cfg.getTemplate("vendor-request.tmpl"); System.out.println(temp.toString()); } catch(IOException
e){ e.printStackTrace(); } } } 和例2 中的Groovy 作为对比. //用Groovy 编写的更简单的TemplateReader // 语法目前基于Groovy 1.0-JSR3 import freemarker.template.Configuration as tconf import java.io.File cfg =
tconf.getDefaultConfiguration() cfg.setDirectoryForTemplateLoading( new
File("C:\\dev\\projects\\http-tester\\src\\conf")) temp = cfg.getTemplate("vendor-request.tmpl") println temp.toString()
Groovy 显然精简得多：Groovy 代码只需要更少的import 语句。

此外，freemarker.template.Configuration 还使用了别名tconf 。

Groovy 允许直接使用类型为Template 的变量tmpl 而不用声明其类型。

Groovy 不需要class 声明或者main 方法。

Groovy 不关心异常，可以不用导入Java 需要的IOException 。

******************************************************
1. 闭包先解释一下闭包的概念：闭包是很多动态语言提供的一个很方便的功能，它有点像Java 中的内部类，不同的是闭包中只有一个方法，但这个方法
可以有任意个参数。

下面看一个闭包的最简单的例子：
def closure={ param -> println "hello ${param}" } closure.call("world!")
def 是一个关键字，相当于JavaScript 中的Var ，用来定义一个对象。

closure 为闭包的名字。

在大括号里面，参数和处理参数的语句用-> 隔开。

param 是这个闭包的参数，参数的数目是任意的，不同的参数之间用"," 隔开。

下面处理这些参数的语句就可以直接调用这些参数了。

所有的闭包都是继承自ng.Closure 类，闭包也是一个普通的类，只是在Groovy 中，这个语法比较特别。

所以闭包也可以当作一个返回值。

或者当作一个参数传入一个
方法。

闭包的返回值：调用闭包的call 方法，会有一个返回值，可以调用return 来指定，如果不指定的话，则返回闭包中最后一条有返回值的语句。

闭包可以调用的对象：在方法里面，可以调用方法内的局部变量作为类变量，可以调用类变量
关于0 个参数以及对象it ：参数可以是任意个，没有参数就不需要"->"了。

没有参数的话，但是传入了一个参数，这个参数可以通过一个无类型的对象
"it"来访问。

比如上面的例子
我们可以这么写：
def closure2={ println "hello ${it}" } closure2.call("world!") 关于闭包的调用：定义以后就可以调用这个闭包，有两种方式，closure.call("world!")
closure("world!") 这两种是没有任何区别的，第二个是第一个的简写
2. 集合的本地化语法这个比闭包更容易理解，Groovy 对collections, lists,
maps, arrays 的声明和使用提供了语言级的支持，可以直接声明一个list 和map ，无需调用new 方法创建一个List 或者map 对象。

看一个来自Groovy 官方网站的例子：def list = [5, 6, 7, 8] assert list.get(2) == 7 assert list[2] == 7 assert list instanceof java.util.List
def emptyList = [] assert emptyList.size() == 0 emptyList.add(5) assert emptyList.size() == 1 与Java 的区别如下:1. 通过[value...] 的方式来声明2. 通过list[index] 的方式来访问和赋值 3. 通过[]来声明一个空的map 看一个Map 的例子：def map = [name:"Gromit", likes:"cheese", id:1234] assert map.get("name") == "Gromit" assert map.get("id") == 1234 assert map["name"] == "Gromit" assert map['id'] == 1234 assert map instanceof java.util.Map
def emptyMap = [:] assert emptyMap.size() == 0 emptyMap.put("foo", 5) assert emptyMap.size() == 1 assert emptyMap.get("foo") == 5
与Java 的区别如下：1. 通过[name:value...] 的方式来声明 2. 通过
map[name] 的方式来访问和赋值3. 通过 的方式来访问和赋值4.通过[:]来声明一个空的map Range 的使用：Range 是Groovy 新添的一个集合类，继承自java.util.List ，所以可以像使用List 一样使用。

下面是关于Range 的一个例子：def range = 5..8 assert range.size() == 4 assert
range.get(2) == 7 assert range[2] == 7 assert range instanceof java.util.List assert range.contains(5) assert range.contains(8) range = 5..
几个说明1.Range 的类型可以是int 、char 2. 通过min..max 来声明3. 可以像其他集合一样使用
'*.' 操作符号的使用：可以用来使集合中的所有元素都调用同一个方法，返回一个同等size 的List List list = ["Rod", "Phil", "James", "Chris"] println list*.size() String 的特殊使用：String 在Groovy 中可以像char 数组一样的使用，下面是一个例子：def text = "nice cheese gromit!" def x = text[2]
assert x == "c" assert x.class == String def sub = text[5..10] assert sub ==
'cheese' 说明：1. 通过text[index] 的方式返回在index 处的字符，不过返回的是string 类型的，非char 类型2. 通过text[min..max] 方式来返回子字符串，包含max 处的字符，String 的subString 不包含。

3. 从这个例子中可以看到，可以使用'string' 来表示String ，不一定是"string"。