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 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"]
運行Groovy腳本
你可以象使用Perl一樣編寫Groovy腳本，不需要class，不需要Main入口點，也不需要聲明變量；此外，你還可以用def語句來定義自己的函數，并在腳本中使用它。
像許多腳本語言一樣，Groovy 是 在運行時解釋的，無編譯的代碼在構建-運行周期中可以提供很多好處。運行時編譯使 Groovy 成為快速原型設計、構建不同的實用程序和測試框架的理想平臺。通過以下代碼可以很簡單的運行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是這個閉包的參數，參數的數目是任意的，不同的參數之間用","隔開。
下面處理這些參數的語句就可以直接調用這些參數了。
所有的閉包都是繼承自groovy.lang.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.通過map.name的方式來訪問和賦值
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..<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.可以像其他集合一樣使用
'*.'操作符號的使用：
可以用來使集合中的所有元素都調用同一個方法，返回一個同等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"