javagroovy表达式_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 = " + thing.name }
这⾥定义了两个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 的三重引号(""")开头，并以三重引号结尾。
name = "James" text = ""“ hello there ${name} how are you today? ”"" assert text != null println(text)
在Groovy-JSR中，不再⽀持下⾯这种多⾏字符串，个⼈觉得似乎与Here-docs功能重叠：
foo = “hello there how are things?” println(foo)
对字符串的操作
contains 字符串中是否包含⼦字符串，'groovy'.contains('oo')将返回true;
count 返回字符串中⼦字符串出现的次数，'groooovy'.count('oo')将返回3.
tokenize 根据分隔符将字符串分解成⼦串，'apple^banana^grap'.tokenize('^')返回['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 = 0 for ( 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.
vy
除了利⽤解释器来运⾏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; plate.Configuration; plate.Template; public class TemplateReader { public static void main(String[] args){ try{
Configuration cfg = DefaultConfiguration(); cfg.setDirectoryForTemplateLoading(new
File("C:\\dev\\projects\\http-tester\\src\\conf")); Template temp = Template("pl");
System.out.String()); } catch(IOException e){ e.printStackTrace(); } } }和例2 中的 Groovy 作为对⽐.
//⽤ Groovy 编写的更简单的 TemplateReader //语法⽬前基于Groovy 1.0-JSR3 plate.Configuration as tconf import java.io.File cfg = DefaultConfiguration() cfg.setDirectoryForTemplateLoading( new
File("C:\\dev\\projects\\http-tester\\src\\conf")) temp = Template("pl") String()
Groovy显然精简得多：
Groovy 代码只需要更少的import 语句。此外，plate.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是这个闭包的参数，参数的数⽬是任意的，不同的参数之间⽤","隔开。 下⾯处理这些参数的语句就可以直接调⽤这些参数了。
所有的闭包都是继承⾃groovy.lang.Closure类，闭包也是⼀个普通的类， 只是在Groovy中，这个语法⽐较特别。所以闭包也可以当作⼀个返回值。 或者当作⼀个参数传⼊⼀个⽅法。
闭包的返回值： 调⽤闭包的call⽅法，会有⼀个返回值，可以调⽤return来指定，如果不指定的话， 则返回闭包中最后⼀条有返回值的语句。
闭包可以调⽤的对象： 在⽅法⾥⾯，可以调⽤⽅法内的局部变量 作为类变量，可以调⽤类变量
关于0个参数以及对象it： 参数可以是任意个，没有参数就不需要"->"了。没有参数的话，但是传⼊了⼀个参数， 这个参数可以通过⼀个⽆类型的对象"it"来访问。⽐如上⾯的例⼦我们可以这么写：
时间正则表达式javadef 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] (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.通过[]的⽅式来声明2.通过list[index]的⽅式来访问和赋值3.通过[]来声明⼀个空的map
看⼀个Map的例⼦：def map = [name:"Gromit", likes:"cheese", id:1234] ("name") == "Gromit" assert
<("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
<("foo") == 5
与Java的区别如下：1.通过[]的⽅式来声明2.通过map[name]的⽅式来访问和赋值3.通过map.name的⽅式来访问和赋值4.通过[:]来声明⼀个空的map
Range的使⽤：Range是Groovy新添的⼀个集合类，继承⾃java.util.List，所以可以像使⽤List⼀样使⽤。 下⾯是关于Range的⼀个例⼦：def range = 5..8 assert range.size() == 4 (2) == 7 assert range[2] == 7 assert range instanceof
java.util.List ains(5) ains(8)
range = 5..<8 assert range.size() == 3 (2) == 7 assert range[2] == 7 assert range instanceof java.util.List ains(5) assert ! ains(8)
⼏个说明1.Range的类型可以是int、char 2.通过ax来声明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.通过ax]⽅式来返回⼦字符串，包含max处的字符，String的subString不包含。3.从这个例⼦中可以看到，可以使⽤'string'来表⽰String，不⼀定是"string"

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。