Groovy的基礎(chǔ)語法
Groovy 的語法融合了 Ruby、Python 和 Smalltalk 的一些最有用的功能，同時保留了基于 Java 語言的核心語法。對于Java 開發(fā)人員，Groovy 提供了更簡單的替代語言，且?guī)缀醪恍枰獙W(xué)習(xí)時間。
語句
Groovy的語句和Java類似，但是有一些特殊的地方。例如語句的分號是可選的。如果每行一個語句，就可以省略分號；如果一行上有多個語句，則需要用分號來分隔。
x = [1, 2, 3] println x y = 5; x = y + 7 println x assert x == 12
另外return關(guān)鍵字在方法的最后是可選的；同樣，返回類型也是可選（缺省是Object）。
動態(tài)類型
像其他Script一樣，Groovy 不需要顯式聲明類型。在 Groovy 中，一個對象的類型是在運(yùn)行時動態(tài)發(fā)現(xiàn)的，這極大地減少了要編寫的代碼數(shù)量。在Groovy中，類型對于值(varibles)、屬性(properties)、方法(method)和閉包(closure)參數(shù)、返回值都是可有可無的，只有在給定值的時候，才會決定它的類型，(當(dāng)然聲明了類型的除外）。例如：
//Groovy 動態(tài)類型 myStr = "Hello World"
由于使用了動態(tài)類型，不需要繼承就可以得到多態(tài)的全部功能：
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 屬性。函數(shù) doSomething，它以一個 thing 為參數(shù)，并試圖打印這個對象的 name 屬性，但doSomething 函數(shù)沒有定義其輸入?yún)?shù)的類型，所以只要對象包含一個 name 屬性，那么它就可以工作。可見， Song 和 Book 的實例都可以作為 doSomething 的輸入?yún)?shù)。
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)
在例子的最后，我們還創(chuàng)建了doSomething的一個函數(shù)指針 doSth，最后的執(zhí)行結(jié)果與調(diào)用doSoemthing是一樣的。
值得注意的是：與Groovy Beta不同，在使用新的JSR Groovy類時，類里面的所有的變量都必須加上 def 關(guān)鍵字或者 private、protected 或 public 這樣的修飾符。當(dāng)然，也可以用 @Property 關(guān)鍵字聲明成員變量。在Script中則不必。
字符串
Groovy中的字符串允許使用雙引號和單引號。
當(dāng)使用雙引號時，可以在字符串內(nèi)嵌入一些運(yùn)算式，Groovy允許您使用 與 bash 類似的 ${expression} 語法進(jìn)行替換。可以在字符串中包含任意的Groovy表達(dá)式。
name="James" println "My name is ${name},'00${6+1}'" //prints My name is James,'007'
Groovy還支持"uXXXX" 引用（其中X是16進(jìn)制數(shù)），用來表示特殊字符，例如 "u0040" 與"@"字符相同。
大塊文本
如果有一大塊文本（例如 HTML 和 XML）不想編碼，你可以使用Here-docs. here-docs 是創(chuàng)建格式化字符串的一種便利機(jī)制。它需要類似 Python 的三重引號(""")開頭，并以三重引號結(jié)尾。
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 返回字符串中子字符串出現(xiàn)的次數(shù)，'groooovy'.count('oo')將返回3.
- tokenize 根據(jù)分隔符將字符串分解成子串，'apple^banana^grap'.tokenize('^')返回['apple','banana','grape']。
- 減操作 'groovy'-'oo'，結(jié)果是'grvy'。
- 乘操作 'oo'*3，結(jié)果是'oooooo'。
Groovy主要結(jié)構(gòu)
接下來將展示Groovy的一些結(jié)構(gòu)，包邏輯分支，類、閉包等等。
邏輯分支
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值為正則表達(dá)式，匹配switch值的字符串匹配該正則表達(dá)式
- 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值匹配時，會調(diào)用isCase(switchValue)方法，Groovy提供了各種類型，如類，正則表達(dá)式、集合等等的重載。可以創(chuàng)建自定義的匹配類，增加isCase(switchValue)方法來提供自定義的匹配類型。
循環(huán)
while和do 循環(huán)
Groovy支持Java相同的while循環(huán)，但目前暫不支持do循環(huán)
x = 0 y = 5 while ( y-- > 0 ){ x++ } assert x == 5
for循環(huán)
Groovy的for循環(huán)更簡單，而且能夠和各種類型的數(shù)組、集合、Map、范圍等一起工作，我們稍候會詳細(xì)介紹這些內(nèi)容。
// iterate over a range x = 0 for ( i in 0..9 ) { x += i }
assert x == 45
// iterate over a list
x = 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 map
map = [‘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"]
運(yùn)行Groovy腳本
你可以象使用Perl一樣編寫Groovy腳本，不需要class，不需要Main入口點，也不需要聲明變量；此外，你還可以用def語句來定義自己的函數(shù)，并在腳本中使用它。
像許多腳本語言一樣，Groovy 是 在運(yùn)行時解釋的，無編譯的代碼在構(gòu)建-運(yùn)行周期中可以提供很多好處。運(yùn)行時編譯使 Groovy 成為快速原型設(shè)計、構(gòu)建不同的實用程序和測試框架的理想平臺。通過以下代碼可以很簡單的運(yùn)行Groovy.
除了利用解釋器來運(yùn)行Groovy腳本外，Groovy 提供了兩種不同的解釋器Shell，使所有有效的 Groovy 表達(dá)式可以交互地執(zhí)行：
- 運(yùn)行g(shù)roovysh啟動命令Shell，可以輸入Groovy語句直接執(zhí)行
- 運(yùn)行g(shù)roovyConsole啟動Swing方式的Groovy控制臺，這是一個簡單的Groovy編輯器
Groovy 腳本實際上是字節(jié)碼級別的 Java 類。因此，還可以用 groovyc 編譯 Groovy 腳本。可以通過命令行或者 Ant 使用 groovyc 以生成腳本的類文件。這些類可以用普通 java 命令運(yùn)行，只要 classpath 包括 groovy.jar和asm.jar。（wang_wang）
Groovy 前言
前言
Groovy 是基于 JRE 的腳本語言( Script )，和Perl，Python等等腳本語言一樣，它能以快速簡潔的方式來完成一些工作：如訪問數(shù)據(jù)庫，編寫單元測試用例(Unit Test Case)，快速實現(xiàn)產(chǎn)品原型等等。
Groovy 是由James Strachan 和 Bob McWhirter 這兩位天才發(fā)明的，（JSR 241 2004 年 3 月）。Groovy 完全以Java API為基礎(chǔ)，使用了Java開發(fā)人員最熟悉的功能和庫。Groovy 的語法近似Java，并吸收了 Ruby 的一些特點，因此 Groovy 在某些場合可以扮演一種 “咖啡伴侶”的角色。
那么Groovy 和 Java 相比，有什么變化呢？ Groovy 通過以下方式提供了一種敏捷的開發(fā)方式：
- 不用編譯。
- 允許動態(tài)類型。
- 合成結(jié)構(gòu)容易。 其腳本可以在普通 Java 應(yīng)用程序中使用。
- 提供一個 shell 解析器。
這些特性使Groovy 成為一種特別容易學(xué)習(xí)和使用的語言. 我們先借用IBM Groovy教程中的例子，下面的代碼利用了Freemarker模板引擎來創(chuàng)建一個Template對象，然后將內(nèi)容打印到標(biāo)準(zhǔn)輸出。例(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 不關(guān)心異常，可以不用導(dǎo)入Java需要的IOException。
******************************************************
1.閉包
先解釋一下閉包的概念：
閉包是很多動態(tài)語言提供的一個很方便的功能，它有點像Java中的內(nèi)部類，
不同的是閉包中只有一個方法，但這個方法可以有任意個參數(shù)。
下面看一個閉包的最簡單的例子：
def closure={ param -> println "hello ${param}" }
closure.call("world!")
def是一個關(guān)鍵字，相當(dāng)于JavaScript中的Var，用來定義一個對象。
closure為閉包的名字。在大括號里面，參數(shù)和處理參數(shù)的語句用->隔開。
param是這個閉包的參數(shù)，參數(shù)的數(shù)目是任意的，不同的參數(shù)之間用","隔開。
下面處理這些參數(shù)的語句就可以直接調(diào)用這些參數(shù)了。
所有的閉包都是繼承自groovy.lang.Closure類，閉包也是一個普通的類，
只是在Groovy中，這個語法比較特別。所以閉包也可以當(dāng)作一個返回值。
或者當(dāng)作一個參數(shù)傳入一個方法。
閉包的返回值：
調(diào)用閉包的call方法，會有一個返回值，可以調(diào)用return來指定，如果不指定的話，
則返回閉包中最后一條有返回值的語句。
閉包可以調(diào)用的對象：
在方法里面，可以調(diào)用方法內(nèi)的局部變量
作為類變量，可以調(diào)用類變量
關(guān)于0個參數(shù)以及對象it：
參數(shù)可以是任意個，沒有參數(shù)就不需要"->"了。沒有參數(shù)的話，但是傳入了一個參數(shù)，
這個參數(shù)可以通過一個無類型的對象"it"來訪問。比如上面的例子我們可以這么寫：
def closure2={ println "hello ${it}" }
closure2.call("world!")
關(guān)于閉包的調(diào)用：
定義以后就可以調(diào)用這個閉包，有兩種方式，
closure.call("world!")
closure("world!")
這兩種是沒有任何區(qū)別的，第二個是第一個的簡寫
2.集合的本地化語法
這個比閉包更容易理解，Groovy對collections, lists, maps, arrays的聲明和使用
提供了語言級的支持，可以直接聲明一個list和map，無需調(diào)用new方法創(chuàng)建一個List或者
map對象。
看一個來自Groovy官方網(wǎng)站的例子：
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的區(qū)別如下:
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的區(qū)別如下：
1.通過[name:value...]的方式來聲明
2.通過map[name]的方式來訪問和賦值
3.通過map.name的方式來訪問和賦值
4.通過[:]來聲明一個空的map
Range的使用：
Range是Groovy新添的一個集合類，繼承自java.util.List，所以可以像使用List一樣使用。
下面是關(guān)于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..<8
assert range.size() == 3
assert range.get(2) == 7
assert range[2] == 7
assert range instanceof java.util.List
assert range.contains(5)
assert ! range.contains(8)
幾個說明
1.Range的類型可以是int、char
2.通過min..max來聲明
3.可以像其他集合一樣使用
'*.'操作符號的使用：
可以用來使集合中的所有元素都調(diào)用同一個方法，返回一個同等size的List
List list = ["Rod", "Phil", "James", "Chris"]
println list*.size()
String的特殊使用：
String在Groovy中可以像char數(shù)組一樣的使用，下面是一個例子：
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"