Groovy 概述

Groovy是一種基于JVM（Java虛擬機）的敏捷開發語言，它結合了Python、Ruby和Smalltalk的許多強大的特性，Groovy 代碼能夠與 Java 代碼很好地結合，也能用于擴展現有代碼。由于其運行在 JVM 上的特性，Groovy 可以使用其他 Java 語言編寫的庫。

Groovy 1.0于2007年1月2日發布，其中Groovy 2.4是當前的主要版本。 Groovy通過Apache License v 2.0發布。

簡單地說，Groovy 是下一代的java語言，跟java一樣,它也運行在 JVM 中。作為跑在JVM中的另一種語言，groovy語法與 Java 語言的語法很相似。同時，Groovy 拋棄了java煩瑣的文法。同樣的語句，使用groovy能在最大限度上減少你的擊鍵次數——這確實是“懶惰程序員們”的福音。

Groovy 的特點

1. 同時支持靜態和動態類型。
2. 支持運算符重載。
3. 本地語法列表和關聯數組。
4. 對正則表達式的本地支持。
5. 各種標記語言，如XML和HTML原生支持。
6. Groovy對于Java開發人員來說很簡單，因為Java和Groovy的語法非常相似。
7. 您可以使用現有的Java庫。
8. Groovy擴展了java.lang.Object。

Groovy 環境搭建

下載和安裝 -進入該鏈接Groovy安裝軟件獲得Windows安裝程序部分。需要注意的是它依賴的JDK版本最好是1.8版本,否則會報警告.

啟動Groovy安裝程序，然后依次執行即可。值得注意的是,該軟件會幫我們自動配置PATH和GROOVY_HOME.如下圖所示,不要取消勾選.系統安全軟件也會攔截,記得允許喲!!


一旦上述步驟之后，你就可以開始使用Groovy shell，有助于測試我們的Groovy，而不需要為Groovy提供一個完整的集成開發環境。可以通過在命令提示符下命令groovysh來完成。
如果你想包含groovy二進制文件作為maven或gradle構建的一部分，你可以添加以下行
Gradle

'org.codehaus.groovy:groovy:2.4.5'

Maven

<groupId>org.codehaus.groovy</groupId> 
<artifactId>groovy</artifactId>  
<version>2.4.5</version>

Groovy 基本語法

沒有類型的JAV

作為動態語言，groovy中所有的變量都是對象(類似于.net framework，所有對象繼承自java.lang.Object)，在聲明一個變量時，groovy不要求強制類型聲明，僅僅要求變量名前使用關鍵字def。

不需要的public

你可以把main方法前面的public去掉，實際上，groovy中默認的修飾符就是public，所以public修飾符你根本就不需要寫，這點跟java不一樣。

不需要的語句結束符

Groovy中沒有語句結束符，當然為了與java保持一致性，你也可以使用;號作為語句結束符。在前面的每一句代碼后面加上;號結束，程序同樣正常運行(為了接受java程序員的頑固習慣)。

字符串連接符

跟java一樣，如果你需要把一個字符串寫在多行里，可以使用+號連接字符串。代碼可以這樣寫：

def var="hello "+
       "world"+
       ",groovy!"
//當然更groovy的寫法是：
def var="""hello
		   world
		   groovy!"""
//三個雙引號或單引號之間不在需要+號進行連接（不過字符串中的格式符都會被保留，包括回車和tab）

一切皆對象

聽起來象是“眾生平等”的味道，事實上groovy對于對象是什么類型并不關心，一個變量的類型在運行中隨時可以改變，一切根據需要而定。如果你賦給它boolean ，那么不管它原來是什么類型，它接受boolean值之后就會自動把類型轉變為boolean值。看下面的代碼：

def var="hello "+
       "world"+
       ",groovy!"
       println var;
       println var.class;
       var=1001
       println var.class
// 輸出結果：
hello world,groovy!
class java.lang.String
class java.lang.Integer

var這個變量在程序運行中，類型在改變。一開始給它賦值String，它的類型就是String，后面給它賦值Integer，它又轉變為Integer。

循環

// 刪除整個源文件內容，用以下代碼替代：
def var="hello "+
       "world"+
       ",groovy!"
def repeat(val){
	for(i = 0; i < 5; i++){
		println val
	}
}
repeat(var)
// 輸出：
hello world,groovy!
hello world,groovy!
hello world,groovy!
hello world,groovy!
hello world,groovy!
// 注意循環變量i前面沒有def。當然也沒有java中常見的int，但如果你非要加上int也不會有錯，因為從Groovy1.1beta2之后開始（不包括1.1beta2），groovy開始支持java經典的for循環寫法。
// 此外，上面的for語句還可以寫成：
for(i in 0..5)
// 這樣的結果是一樣的。 

String 和 Gstring

類似于ES的模板字符串,變量用${} EL表達式來引用,還可以做相應的算術運算.

def name="Tom"   //可選的類型定義，系統會根據值進行自動識別類型，類似于js的var
println 'my name is tom' //單引號只能輸出字符串
println "Myname is ${"John"+name}"  //雙引號可以插入變量
println "Myname is ${"Tom"==name}"  //雙引號可以進行簡單的邏輯判斷
println ''' 
		Myname 
		is 
		tom 
'''   //三個單引號可以保留格式，完成見到那拼接

//輸出：
Myname is JohnTom
Myname is true

范圍

在前面的for循環介紹中我們已經使用過的for(i in 0…5)這樣的用法，其中的0…5就是一個范圍。
范圍 是一系列的值。例如 “0…4” 表明包含 整數 0、1、2、3、4。Groovy 還支持排除范圍，“0…<4” 表示 0、1、2、3。還可以創建字符范圍：“a…e” 相當于 a、b、c、d、e。“a…<e” 包括小于 e 的所有值。
范圍主要在for循環中使用。

默認參數值

可以為方法指定默認參數值。我們修改repeat方法的定義：

def repeat(val,repeat=3){
   for(i in 0..<repeat){
      println "This is ${i}:${val}"
   }
}

可以看到，repeat方法增加了一個參數repeat（并且給了一個默認值3），用于指定循環次數。
當我們不指定第2個參數調用repeat方法時，repeat參數取默認值3。

集合

Groovy支持最常見的兩個java集合：java.util.Collection和java.util.Map。 前面所說的范圍實際也是集合的一種（java.util.List）。

Collection 集合

groovy:000> c=[1,2,3,4,5,6,7]
===> [1, 2, 3, 4, 5, 6, 7]
groovy:000> c.add(1)  //添加元素
===> true
groovy:000> c
===> [1, 2, 3, 4, 5, 6, 7, 1]
groovy:000> c<<b   //添加其它類型的元素
Unknown property: b
groovy:000> c<<6   //添加元素
===> [1, 2, 3, 4, 5, 6, 7, 1, 6]
groovy:000> c+0   //添加元素
===> [1, 2, 3, 4, 5, 6, 7, 1, 6, 0]
groovy:000> c=c-6  //刪除所有相同的元素
===> [1, 2, 3, 4, 5, 7, 1]
groovy:000> c=c-c[0..2]  //刪除指定范圍的元素
===> [4, 5, 7]
groovy:000>

Map集合

Map是“鍵-值”對的集合，在groovy中，鍵不一定是String，可以是任何對象(實際上Groovy中的Map就是java.util.LinkedHashMap)。

//定義一個Map
def map=['name':'john','age':14,'sex':'boy']
map=map+['weight':25]       //添加john的體重
map.put('length',1.27)      //添加john的身高
map.father='Keller'         //添加john的父親
//可以用兩種方式檢索值：
println map['father']       //通過key作為下標索引
println map.length          //通過key作為成員名索引

//定義一個buildYear
def buildYear = ['ant':2000,'maven':2004]
buildYear.gradle = 2008

println buildYear.gradle
println buildYear['gradle']
println buildYear.getClass() //class java.util.LinkedHashMap

閉包

閉包是Groovy中非常重要的一個數據類型或者說一種概念。閉包是一種數據類型，它代表了一段可執行的代碼,一般被當作參數來使用。

// （1）有參數：
def 閉包名={
	parameters->code
}
//（2）無參數（不需要->符號）
def 閉包名={code}
//如果閉包沒有定義參數的話，則隱含有一個參數，這個參數名字叫it，和this的作用類似。it代表閉包的參數
def 閉包名={
	it->code
}
//方法調用：
（1）閉包名.call（參數）
（2）閉包名（參數）

閉包中最常見的應用是對集合進行迭代，下面定義了3個閉包對map進行了迭代：

def map=['name':'john','age':14,'sex':'boy']
map.each({key,value->    //key,value兩個參數用于接受每個元素的鍵/值
    println "$key:$value"
})
map.each{println it}     //it是一個關鍵字，代表map集合的每個元素
map.each({ 
	println it.getKey()+"-->"+it.getValue()
})

//定義一個包含參數的閉包
def c1 = { //閉包是一個代碼塊
	v->println v
}
//定義一個不包含參數的閉包
def c2 = {
  println 'hello'
}

//定義兩個個方法使用閉包作為參數傳遞，并調用
def method1(Closure closure){ //記住這里不導入包
	closure('param')
}

def method2(Closure closure){
	closure()
}

//執行方法
method1(c1)  //param
method2(c2)  //hello

類

Groovy類和java類一樣，你完全可以用標準java bean的語法定義一個groovy 類。
但作為另一種語言，我們可以使用更groovy的方式定義和使用類，這樣的好處是，你可以少寫一半以上的javabean代碼：

• 不需要public修飾符
  如前面所言，groovy的默認訪問修飾符就是public，如果你的groovy類成員需要public修飾，則你根本不用寫它。
• 不需要類型說明
  同樣前面也說過，groovy也不關心變量和方法參數的具體類型。
• 不需要getter/setter方法
  不要奇怪，在很多ide（如eclipse）早就可以為序員自動產生getter/setter方法了。在groovy中，則徹底不需要getter/setter方法——所有類成員（如果是默認的public）根本不用通過getter/setter方法引用它們（當然，如果你一定要通過get/set方法訪問成員屬性，groovy也提供了它們）。
• 不需要構造函數
  不在需要程序員聲明任何構造函數，因為groovy自動提供了足夠你使用的構造函數。不用擔心構造函數不夠多，因為實際上只需要兩個構造函數（1個不帶參數的默認構造函數，1個只帶一個map參數的構造函數—由于是map類型，通過這個參數你可以在構造對象時任意初始化它的成員變量）。
• 不需要return
  Groovy中，方法不需要return來返回值嗎？這個似乎很難理解。看后面的代碼吧。
  因此，groovy風格的類是這樣的：
• 不需要()號
  Groovy中方法調用可以省略()號（構造函數除外），也就是說下面兩句是等同的：

person1.setName 'kk' 
person1.setName('kk')

//下面看一個完整類定義的例子：
class Person {
 def name
 def age
 String toString(){//注意方法的類型String，因為我們要覆蓋的方法為String類型
     "$name,$age"
 }
//如果你使用javabean風格來做同樣的事，起碼代碼量要增加1倍以上。
//我們可以使用默認構造方法實例化Person類：
def person1=new Person()
person1.name='kk'
person1.age=20
println person1

//也可以用groovy的風格做同樣的事：
def person2=new Person(['name':'gg','age':22]) //[]號可以省略
println person2

這樣需要注意我們覆蓋了Object的toString方法，因為我們想通過println person1這樣的方法簡單地打印對象的屬性值。
然而toString 方法中并沒有return 一個String，但不用擔心，Groovy 默認返回方法的最后一行的值。

斷言(assert)

	def version = 1
	println(version) 
	println version  //括號可選
	assert version == 2  //和junit中的測試一制，給一個期待值和真實值比較

構建腳本(build.gradle 重要)

//構建腳本中默認都是有一個Project實例的  
plugins {//聲明一個應用插件
    id 'java'   
}

group 'cn.itcast.gradle'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8   //源碼編譯器版本

repositories {  //指定倉庫地址，是一個方法，使用閉包作為參數，調用了一個方法
    mavenCentral()
}

dependencies {  //依賴版本信息 --> 坐標地址
    testCompile group: 'junit', name: 'junit', version: '4.12'
    //compile  runtime testCompile testRuntime
}

def createDir = {  //創建一個執行方法
    path->
        File dir = new File(path)
        if(!dir.exists()){
            dir.mkdirs()
        }
}

//////////////自定義任務動作交給構建工具去完成/////////////////////////////
task makeJavaDir(){  //創建一個任務
    def paths = ['src/main/java','src/main/resources','src/test/java','src/test/resources']
    doFirst { //開始處添加一個動作
        paths.forEach(createDir)
    }
}

task markeWebJavaDir(){
    dependsOn 'makeJavaDir' //添加依賴動作
    def paths = ['src/main/webapp','src/test/webapp'];
    doLast {  //結尾處添加一個動作
        paths.forEach(createDir)
    }
}