當(dāng)一個(gè)Java開(kāi)發(fā)人員加入到Groovy的開(kāi)發(fā)之旅的時(shí)候，他/她經(jīng)常帶著Java思想去思考，并逐步地學(xué)習(xí)Groovy，每次學(xué)習(xí)一個(gè)特性，這會(huì)讓他慢慢變得更有創(chuàng)造性和寫(xiě)出更符合語(yǔ)言習(xí)慣的Groovy代碼。這篇文章的目的是引導(dǎo)這些開(kāi)發(fā)人員去學(xué)習(xí)基本的Groovy編程風(fēng)格，學(xué)習(xí)新的操作技巧，新的語(yǔ)言特性，例如閉包等等。這篇文章并不會(huì)詳細(xì)鋪開(kāi)描述，而是給讀者一個(gè)入門(mén)的指引，并讓讀者在以后的深入學(xué)習(xí)打好基礎(chǔ)。如果你喜歡這篇文章，可以貢獻(xiàn)你的一份力量去豐富它。

無(wú)分號(hào)

C / C++ / C# / Java開(kāi)發(fā)者，經(jīng)常到處使用分號(hào)。盡管Groovy支持99%的java語(yǔ)法，有時(shí)你只需簡(jiǎn)單的把java代碼粘貼到Groovy程序里，但是卻帶著一大堆分號(hào)。在Groovy里，分號(hào)是可選的，你可以省略他們，更常用的用法是刪除它們。

返回關(guān)鍵字 (Return) 變得可選

在Groovy的世界里面，方法的程序塊結(jié)尾可以不寫(xiě)'return'關(guān)鍵字而照樣返回值。尤其是對(duì)于語(yǔ)句不多的方法和閉包。這樣的寫(xiě)法更優(yōu)美更簡(jiǎn)潔：
 

String toString() {return"a server"}
String toString() {"a server"}

但有些情況卻不那么優(yōu)美，例如你使用了變量，并在兩行里面出現(xiàn)兩次：
 

def props() {
  def m1 = [a:1, b:2]
  m2 = m1.findAll { k, v -> v %2==0}
  m2.c =3
  m2
}

我自己個(gè)人習(xí)慣，有時(shí)候喜歡用return關(guān)鍵字，有時(shí)候又不喜歡，這跟個(gè)人口味有關(guān)系吧。但是，更多時(shí)候，例如在閉包里面，我更喜歡不寫(xiě)return關(guān)鍵字。所以即使return關(guān)鍵字是可選的，也不會(huì)強(qiáng)制你不能使用它，如果你認(rèn)為它會(huì)打破代碼的可讀性。

謹(jǐn)慎為上，然而當(dāng)你使用def關(guān)鍵字定義，而并非用代替具體某一個(gè)類型去定義的方法，有時(shí)候你會(huì)驚奇的發(fā)現(xiàn)最后一條表達(dá)式會(huì)作為返回結(jié)果而返回。所以更多時(shí)候更推薦使用具體的類型（例如void或類型）作為返回類型。在我們上面的例子中，如果我們忘記了把m2放在最后一行并作為返回值，那么最后的一個(gè)表達(dá)式將是m2.c = 3，這樣會(huì)導(dǎo)致數(shù)值3作為返回值返回，而不是我們期待的結(jié)果。

形如if/else語(yǔ)句，try/cath語(yǔ)句同樣可以返回值，因?yàn)樗鼈兝锩娑加?最后一個(gè)表達(dá)式"會(huì)被返回。
 

def foo(n) {
  if(n ==1) {
    "Roshan"
  }else{
    "Dawrani"
  }
}
 
assertfoo(1) =="Roshan"
assertfoo(2) =="Dawrani"

Def 和 類型

當(dāng)我們討論def和類型，我經(jīng)常會(huì)發(fā)現(xiàn)一些開(kāi)發(fā)人員既用'def'又用類型。但是'def'在這里是多余的。所以，大家要做一個(gè)選擇，要不用'def'， 要不就用類型。

所以不要寫(xiě)出如下的代碼：
 

def String name = "Guillaume"

可以寫(xiě)成
 

String name ="Guillaume"

當(dāng)我們?cè)贕roovy里面使用def，真正的類型是Object（所以你可以向用def定義的變量，賦值任何的對(duì)象，并且，當(dāng)一個(gè)方法是用def作為返回值的時(shí)候，可以以任何對(duì)象類型作而返回）。

當(dāng)一個(gè)方法未聲明變量類型，你可以使用def，但是這不是必須的，所以可以省略他，所以可以代替下面的語(yǔ)句：
 

void doSomething(def param1, def param2) { }

推薦：
 

void doSomething(param1, param2) { }

但是，就如我們?cè)谖恼履┪蔡岬降?，我們更推薦為方法的參數(shù)指定類型。這樣可以幫助提高代碼的可讀性，也可以幫助IDE工具使代碼完整，或者利用Groovy的靜態(tài)類型檢查或靜態(tài)編譯功能。

另外一個(gè)def多余的地方是定義構(gòu)造函數(shù)，應(yīng)避免使用：
 

class MyClass {
  def MyClass() {}
}

應(yīng)去掉 構(gòu)造函數(shù)前的'def':
 

classMyClass {
  MyClass() {}
}

默認(rèn)的Public

默認(rèn)情況，Groovy會(huì)認(rèn)為類和方法是定義為'public'的。所以你不需要顯式的聲明public。當(dāng)需要聲明為非public的時(shí)候，你需要顯式的指定修飾符。

所以避免如下寫(xiě)法：
 

public class Server {
  public String toString() {return "a server"}
}

推薦使用如下簡(jiǎn)潔的寫(xiě)法
 

class Server {
  String toString() {"a server"}
}

你可能會(huì)關(guān)心包范圍內(nèi)的可訪問(wèn)性問(wèn)題。事實(shí)上，Groovy允許省略public， 是因?yàn)檫@個(gè)包范圍里面默認(rèn)情況下是不支持public，但是事實(shí)上有另外一個(gè)Groovy注釋語(yǔ)法去實(shí)現(xiàn)可訪問(wèn)性：
 

class Server {
  @Package ScopeCluster cluster
}

省略圓括號(hào)

Groovy允許你在頂級(jí)表達(dá)式中省略圓括號(hào)，例如println語(yǔ)句：
 

println"Hello"
method a, b

對(duì)比：
 

println("Hello")
method(a, b)

當(dāng)方法的最后一個(gè)參數(shù)是閉包的時(shí)候，例如使用Groovy的'each'迭代機(jī)制，你可以把閉包放在括號(hào)之外，甚至省略括號(hào)：
 

list.each( { println it } )
list.each(){ println it }
list.each { println it }

通常我們推薦使用上面第三種寫(xiě)法，它顯得更自然，因?yàn)闆](méi)有圓括號(hào)是多么的多余！

但是Groovy在某些情況并不允許你去掉圓括號(hào)。就像我之前說(shuō)的，頂級(jí)表達(dá)式可以省略，但是嵌套的方法或者賦值表達(dá)式的右邊，你卻不能省略：
 

def foo(n) { n }

println foo1// 錯(cuò)誤寫(xiě)法
def m = foo1

類，一級(jí)公民

在Groovy里面，.class后綴是不需要的，有點(diǎn)像Java的instanceof。

例如：
 

connection.doPost(BASE_URI +"/modify.hqu", params, ResourcesResponse.class)

下面我們使用GString，并使用第一類公民：
 

connection.doPost("${BASE_URI}/modify.hqu", params, ResourcesResponse)

Getters和Setters

在Groovy的世界里，getters和setters就是我們常說(shuō)的"屬性"，Groovy提供一個(gè)注釋語(yǔ)法捷徑給我們?nèi)ピL問(wèn)或給屬性賦值。摒棄java方式的getters/setters，你可以使用注釋語(yǔ)法：
 

resourceGroup.getResourcePrototype().getName() == SERVER_TYPE_NAME
resourceGroup.resourcePrototype.name == SERVER_TYPE_NAME
 
resourcePrototype.setName("something")
resourcePrototype.name = "something"

當(dāng)你用Groovy寫(xiě)beans的時(shí)候，我們通常叫做POGOs(普通Groovy對(duì)象)，你不需要自己創(chuàng)建屬性，和getters/setters方法，而是留給Groovy編譯器來(lái)完成。

所以，不再需要這樣去寫(xiě)：
 

class Person {
  private String name
  String getName() {returnname }
  void setName(String name) {this.name = name }
}

而是：
 

class Person {
  String name
}

就如你看到的，一個(gè)簡(jiǎn)潔的"屬性"并不帶任何的訪問(wèn)修飾符，會(huì)讓Groovy編譯器為你自動(dòng)生成一個(gè)私有的屬性和getter和setter方法。

當(dāng)你在Java中使用這樣一個(gè)POGOs對(duì)象，getter和setter方法其實(shí)是存在的，當(dāng)然跟正常的寫(xiě)法無(wú)異。

雖然編譯器可以創(chuàng)建getter/setter方法，但是當(dāng)你需要在這方法里面增加一些特殊的邏輯或者跟默認(rèn)的getter/setter方法不一樣，你可以自己去定義它，編譯器自動(dòng)會(huì)選擇你的邏輯代替默認(rèn)邏輯。

用命名參數(shù)和默認(rèn)構(gòu)造器初始化beans

有這樣一個(gè)bean：
 

class Server {
  String name
  Cluster cluster
}

為避免像下面這樣的麻煩：
 

def server =newServer()
server.name ="Obelix"
server.cluster = aCluster

你可以使用命名參數(shù)和默認(rèn)構(gòu)造器（首先會(huì)調(diào)用構(gòu)造器，然后依次調(diào)用setter方法）：
 

def server =newServer(name:"Obelix", cluster: aCluster)

在同一個(gè)bean里面使用with()語(yǔ)法處理重復(fù)操作

默認(rèn)構(gòu)造器中，命名參數(shù)在創(chuàng)建新的實(shí)例時(shí)是一件十分有趣的事情。但是當(dāng)你需要更新一個(gè)實(shí)例時(shí)，你是否需要重復(fù)地在變量前重復(fù)敲打'server'這個(gè)前綴呢？答案是否定的，因?yàn)槎嗵澚藈ith()語(yǔ)句，Groovy會(huì)自動(dòng)為你填上：
 

server.name = application.name
server.status = status
server.sessionCount =3
server.start()
server.stop()

對(duì)比：
 

server.with {
  name = application.name
  status = status
  sessionCount =3
  start()
  stop()
}

equals 和 ==

Java世界里，==就相當(dāng)于Groovy里面的is()方法，另外Groovy的==就是聰明的equal()方法！

當(dāng)你需要比較對(duì)象的引用的時(shí)候，你應(yīng)該使用Groovy的==，因?yàn)樗麜?huì)幫你避開(kāi)NullPointerException，而你就不需要關(guān)心操作符的左側(cè)或右側(cè)是否為null。

不應(yīng)該這樣寫(xiě):
 

status !=null&& status.equals(ControlConstants.STATUS_COMPLETED)

而是:
 

status == ControlConstants.STATUS_COMPLETED

GStrings ()

我們經(jīng)常再JAVA里面使用string和變量連接，并使用大量的雙引號(hào)，加號(hào)，還有\(zhòng)n字符去創(chuàng)建新的一行。而使用插值字符串（在Groovy里面叫做GStrings），可以簡(jiǎn)化我們的代碼寫(xiě)法：
 

throw new Exception("Unable to convert resource: "+ resource)

對(duì)比：
 
throw new Exception("Unable to convert resource: ${resource}")
在花括號(hào)里面，你可以放任何的表達(dá)式，而不單單是變量。對(duì)于簡(jiǎn)單的變量，或者變量屬性，你甚至可以丟掉花括號(hào)：
 
throw new Exception("Unable to convert resource: $resource")
你甚至可以通過(guò)閉包注釋（${-> resource}）對(duì)表達(dá)式進(jìn)行延遲計(jì)算。當(dāng)GString變量強(qiáng)制轉(zhuǎn)換為String變量的時(shí)候，它會(huì)自動(dòng)計(jì)算閉包的值，并通過(guò)調(diào)用toString()方法作為返回值。例如：
 

int i =3
 
def s1 ="i's value is: ${i}"
def s2 ="i's value is: ${-> i}"
 
i++
 
asserts1 =="i's value is: 3"http:// 預(yù)先計(jì)算，在創(chuàng)建的時(shí)候賦值
asserts2 =="i's value is: 4"http:// 延遲計(jì)算，使用最新的變量值

在Java里面，字符串連接是十分的累贅：
 

throw new PluginException("Failed to execute command list-applications:"+
  " The group with name "+
  parameterMap.groupname[0] +
  " is not compatible group of type "+
  SERVER_TYPE_NAME)

你可以使用 \ 連續(xù)字符 (這不等同于多行文本)

 
throw new PluginException("Failed to execute command list-applications: \
The group with name ${parameterMap.groupname[0]} \
is not compatible group of type ${SERVER_TYPE_NAME}")

或者使用三個(gè)雙引號(hào)實(shí)現(xiàn)多行文本：
 

throw new PluginException("""Failed to execute command list-applications:
  The group with name ${parameterMap.groupname[0]}
  is not compatible group of type ${SERVER_TYPE_NAME)}""")

另外，你也可以使用.stripIndent()函數(shù)實(shí)現(xiàn)刪除多行文本里面的左側(cè)多余空格。

同時(shí)請(qǐng)注意Groovy里面單引號(hào)和雙引號(hào)的區(qū)別：?jiǎn)我?hào)通常用來(lái)創(chuàng)建Java字符串，不帶任何的插值變量，而雙引號(hào)可以創(chuàng)建Java字符串，也可以用來(lái)創(chuàng)建帶插值變量的GStrings。

對(duì)于多行字符串，你可以使用三個(gè)引號(hào)：例如在GStrings變量使用三個(gè)雙引號(hào)，在簡(jiǎn)單的String變量中使用三個(gè)單引號(hào)。

如果你需要寫(xiě)正則表達(dá)式，你必須使用斜杠字符標(biāo)記：
 

assert"foooo/baaaaar"==~ /fo+\/ba+r/

斜杠標(biāo)記的好處是，你不需要寫(xiě)兩個(gè)反斜杠去做轉(zhuǎn)義，讓正則表達(dá)式更簡(jiǎn)潔。

最后但并非不重要，請(qǐng)使用單引號(hào)去定義字符常量，使用雙引號(hào)定義需要使用插值函數(shù)的字符串。

原生的數(shù)據(jù)結(jié)構(gòu)語(yǔ)法

Groovy對(duì)數(shù)據(jù)結(jié)構(gòu)提供原生語(yǔ)法，例如列表，映射，正則表達(dá)式或者一個(gè)范圍內(nèi)的數(shù)值。請(qǐng)?jiān)谀愕腉roovy程序中好好使用它們。

以下是一些例子是使用那些原生數(shù)據(jù)結(jié)構(gòu)的：
 

def list = [1,4,6,9]
 
// 默認(rèn)情況下，鍵是字符的，所以沒(méi)必要用引號(hào)括著它們
// 你可以使用with()包含著鍵，例如使用[(狀態(tài)變量):狀態(tài)名]，利用變量或?qū)ο笞鳛殒I
def map = [CA:'California', MI:'Michigan']
 
def range =10..20
def pattern = ~/fo*/
 
// 等同于 add()
list <<5
 
// 調(diào)用 contains()
assert4in list
assert5in list
assert15in range
 
// 下標(biāo)符號(hào)
assertlist[1] ==4
 
// 增加鍵值對(duì)
map << [WA:'Washington']
// 下標(biāo)符號(hào)
assertmap['CA'] =='California'
// 屬性
assertmap.WA =='Washington'
 
// 使用正則表達(dá)式匹配字符串
assert'foo'=~ pattern

Grovvy 開(kāi)發(fā)工具

我們來(lái)繼續(xù)說(shuō)說(shuō)數(shù)據(jù)結(jié)構(gòu)，當(dāng)你需要迭代集合，Groovy提供非常豐富的方法，裝飾java的核心數(shù)據(jù)結(jié)構(gòu)，例如each{}, find{}, findAll{}, every{}, collect{}, inject{}.這些方法給編程語(yǔ)言增加了些樂(lè)趣，同時(shí)幫助我們更輕松的設(shè)計(jì)復(fù)雜的算法。通過(guò)裝飾器，大量的新方法已應(yīng)用于java的各種類型，這得得益于語(yǔ)言得的的動(dòng)態(tài)特性。你可以查找更多的使用在字符串，文件，流，集合或者其他的方法：

http://groovy.codehaus.org/groovy-jdk/

switch的力量

Groovy的switch比C語(yǔ)言家族的更強(qiáng)大，因?yàn)樗鼈兺ǔＶ唤邮栈緮?shù)據(jù)類型和。而Groovy的switch可以接受豐富的數(shù)據(jù)類型： 
 

def x =1.23
def result =""
switch(x) {
  case"foo": result ="found foo"
  // lets fall through
  case"bar": result +="bar"
  case[4,5,6,'in List']:
    result ="list"
    break
  case 12..30:
    result ="range"
    break
  case Integer:
    result ="integer"
    break
  case Number:
    result ="number"
    break
  default: result ="default"
}
assert result =="number"

通常情況，使用isCase()方法可以判斷一個(gè)數(shù)值是否為大小寫(xiě)。

別名導(dǎo)入 Import aliasing

Java,中當(dāng)要使用來(lái)自兩個(gè)不同包的同名class時(shí)，如

java.util.List 和 java.awt.List, 你能導(dǎo)入其中的一個(gè)類，而另一個(gè)你就不得不給其有效的重命名了.

還有時(shí)候我們?cè)诖a中經(jīng)常使用一個(gè)名字非常長(zhǎng)的類，使得整個(gè)代碼變得臃腫不堪.

為了改善這些狀況， Groovy 提供了別名導(dǎo)入的特性:
 

importjava.util.List as juList
importjava.awt.List as aList

 
importjava.awt.WindowConstants as WC   //import的時(shí)候 用 as 設(shè)置一個(gè)別名
當(dāng)然也可以靜態(tài)的導(dǎo)入某個(gè)方法:
 

import static pkg.SomeClass.foo
foo()

Groovy 的真值體系

在groovy中所有對(duì)象都可以被強(qiáng)制轉(zhuǎn)為為一個(gè)boolean值，即： null, void 或空值 都 會(huì)視為 false, 其他的都視為 true.

所以不要再寫(xiě) 這種代碼了：if (name != null && name.length > 0) {} 改為： if (name) {}

對(duì)于集合和其他數(shù)據(jù)類型同樣適用.

因此，你可以在 諸如while(), if(), 三目運(yùn)算符，Elvis 運(yùn)算符(下面會(huì)講)等等的判斷條件中使用這種簡(jiǎn)單的方式.
更強(qiáng)悍的是可以給你的 類 添加 asBoolean() 方法，從而定制你這個(gè)類的真值的。

安全的操作對(duì)象圖(嵌套的對(duì)象) Safe graph navigation

Groovy支持使用 . 操作符來(lái)安全的操作一個(gè)對(duì)象圖.
Java中如果你對(duì)一個(gè)對(duì)象圖中的某個(gè)節(jié)點(diǎn)感興趣，想檢查其是否為null的時(shí)候，經(jīng)常會(huì)寫(xiě)出復(fù)雜的if嵌代碼，如下：
 

if(order !=null) { //1
  if(order.getCustomer() !=null) { //2
    if(order.getCustomer().getAddress() !=null) { //3
      System.out.println(order.getCustomer().getAddress());
    }
  }
}

而使用Groovy的安全操作符 ?. 可以講上述代碼簡(jiǎn)化為：
 

println order?.customer?.address

太精妙了。

操作連上 每個(gè)?.操作符前面的元素都會(huì)做Null檢查，如果為null則拋出 NullPointerException 并且返回 一個(gè) null值

斷言 Assert

要檢查參數(shù)、返回值等，你可以使用 assert 語(yǔ)句。

和 Java 的 assert 對(duì)比，Groovy 的 assert 無(wú)需單獨(dú)激活。
 

def check(String name) {
  // name non-null and non-empty according to Groovy Truth
  assertname
  // safe navigation + Groovy Truth to check
  assertname?.size() >3
}

你將注意到 Groovy 的 Power Assert 語(yǔ)句提供更好的輸出，包括每個(gè)子表達(dá)式斷言時(shí)不同值的圖形化視圖。

Elvis (埃爾維斯)  ?:  操作符給變量賦默認(rèn)值

?: 是一個(gè)非常方便的給變量 賦 默認(rèn)值的操作符，他是三目運(yùn)算符（xx? a:b）的簡(jiǎn)寫(xiě).
我們經(jīng)常寫(xiě)如下三目運(yùn)算代碼:
 

def result = name !=null? name :"Unknown"http://如果name為null時(shí)給'Unknown'的默認(rèn)值，否則用原name的值

感謝Groovy的真值體系，null的檢查可簡(jiǎn)單直接的通過(guò) ‘name'來(lái)判斷，null 會(huì)被轉(zhuǎn)成 false.
再深入一點(diǎn)，既然總得返回'name'，那在三目操作運(yùn)算符中重復(fù)輸入name兩次就顯得累贅了，可以將問(wèn)號(hào)和冒號(hào)之間輸入的重復(fù)變量移除，于是就成了Elvis操作符，如下：
 

def result = name ?:"Unknown"  //如果判斷name為 false 則取 "Unknown"，否則 取name之值<span></span>

捕捉任何異常

如果你真的不在乎在一個(gè)try代碼塊中拋出的異常，groovy中可以簡(jiǎn)單的catch所有這些異常，并忽略其異常類型. 所以以后像這種捕捉異常的代碼:
 

try{
  // ...
}catch(Throwable t) {
  // something bad happens
}

可以寫(xiě)成捕捉任意異常 ('any' or 'all', 或者其他你認(rèn)為是"任意"的單詞):
 

try{
  // ...
}catch(any) {
  // something bad happens
}

可選類型 建議

最后我將討論一下何時(shí)和怎樣使用 '可選類型' 這個(gè)特性.
Groovy讓你自己來(lái)決定是 顯示使用強(qiáng)類型 還是 使用def 關(guān)鍵字 來(lái)申明你要的東西，那么怎么決定呢？

我有個(gè)相當(dāng)簡(jiǎn)單的經(jīng)驗(yàn)法則:

當(dāng)你寫(xiě)的代碼將會(huì)被作為公共API給別人使用時(shí)，你應(yīng)當(dāng)總是使用強(qiáng)類型的申明。

這將使得: 接口約定更加明確，避免可能的錯(cuò)誤類型參數(shù)的傳遞，有利于提供更易讀的文檔，在編輯如：僅你能使用的私有方法時(shí)，強(qiáng)制類型 會(huì)有利于IDE的代碼自動(dòng)完成功能，或使IDE更容易推斷對(duì)象的類型，然后你就能更加自如的決定是否使用明確的類型了