一、groovy 的環境安裝

centos下的安裝

$ curl -s get.sdkman.io | bash
$ source "$HOME/.sdkman/bin/sdkman-init.sh"
$ sdk install groovy
$ groovy -version

windows下的安裝

官網下載安裝包后解壓，配置環境
?新建GROOVY_HOME，值為解壓后文件的路徑。

修改PATH，在最后追加%GROOVY_HOME%\bin

二 groovy的基礎語法

groovy的變量

 創建.Groovy Script文件

package variable
//groovy 中變量最后都會被包裝成對象類型
int x = 10
println x.class  //Integer
double  y = 1.14
println y.class  // Double

//groovy 定義變量的類型,使用def快速定義弱類型,推斷數據類型
def x_1 =2
println x_1.class
def y_1 = 3.15
println y_1.class
def name = 'david'
println name.class

三、groovy中的字符串用法

def str = 'a \'a\' string '
println str
println str.class

//三個引號定義的字符串可以指定格式
def thupleStr = '''\
three 
signle 
string'''
println thupleStr
println  thupleStr.class

//雙引號字符串格式,可一再字符串中引用其他字符串，引用其他變量后類型是groovy.runtime.GStringImpl
def name =  "david"
def doubleName = "name: ${thupleStr}"
println doubleName
println doubleName.class

//雙引號中的擴展接受任意的表達式
def sum = "the sum of 2 and 3 equals ${2 + 3}"
println sum

//測試GString 和String 的轉換.編譯器轉換
def result = echo(sum)
println result
println result.class
String echo(String message){
    return message
}

/*******字符串String 常用方法 *********************/


def str1 = "justTest"
//println st1.center(9,'a')//字符串兩邊填充字符，默認填充空格。先右后左

//println str1.padLeft(10,'a')//字符串右側填充

//字符串比較
def str2 = "hello"
println str1>str2

println str2[0]  //獲取下標的值
println str2[0..3]  //獲取下標范圍的值

println str2.minus("ello")   //等同于 石str1 - str2

println str2.reverse() //字符串反轉

println str2.capitalize()  //首字母大寫

四、groovy中的邏輯控制

 package variable
//邏輯控制

// switch語句
 def x = 1.23
 def result
 switch (x){
    case 'foo':
        result="founf foo"
        break
     case 'bar':
         result = 'bar'
         break
     case [1.23,5,6,'inList']: //列表中的結果匹配
         result = 'list'
         break
     case 12..30:
         result = 'range'
         break
     case Integer:
         result = 'integer'
         break
     case BigDecimal:
         result = 'bigDecimal'
         break
     default:result = 'default'
 }

 println result

// for循環  計算0-9的和
def sum = 0
 for(i in 0..9){
     sum+=i
 }
 println 'sum:'+sum

 //對于List中元素循環
 def sum1 = 0
 for(i in [1,2,3,4,5,6,7,8,9]){
     sum1 += i
 }
 println "sum1:"+sum1

// 對MAP進行循環
 def sum2 =0
 for(i in ['xiaoMing':1,'xiaoQiang':2,'xiaoHua':3]){
     sum2 += i.value
 }
 println 'sum2:'+sum2

五、閉包

閉包的定義 

閉包是代碼塊。定義如下

//*******閉包的定義和參數********
def closure = {println  "close package"}//閉包的定義方式
closure.call()//調用閉包方法的兩種方式
//closure()

def close = {String name -> println "hello ${name}"}//有參數的閉包定義
close("david")

//多個參數
def close1 = {String name,Integer age-> println "hello :${name}&${age}"}
close1("pangpang",12)

//閉包方法的隱式參數it
def close2 = { println "hello ${it}"}
close2("david")

//*********閉包的返回值**********
def close3 = { println  "test return ${it}"}
def result = close3("test")
println result //閉包方法必定有返回值，默認返回null

閉包的用法

//閉包求階乘
int fab(number){
    int result = 1
    1.upto(number,{num->result *=num})//upto 實現循環階乘
    return result
}
println "向上階乘："+fab(5)

int fab2(int number2){
    int result = 1
    number2.downto(1,{num->result *=num})
    return  result
}
println "向下階乘："+fab2(7)

//累計求和方法,這里的次數由0開始，所以不能用于階乘的計算
int cal(int number){
    int sum = 0
    number.times{ num->sum+=num }
    return sum
}

println cal(101) // 計算0-100的結果


//*********字符串在閉包的使用
String str ="string test 1"
str.each {
//    String result -> print result.multiply(2)  //每個字符串輸出兩次
}

//查找滿主條件的第一個元素
str.find{
    String s->s.isNumber()  //必須是一個返回布爾類型的閉包
}

//查找滿主條件的所有元素
def list = str.findAll{
    String s -> !s.isNumber()
}
println "列表："+list.toListString()

//判斷字符串是否滿足某個條件
def res = str.any {
    String s-> s.isNumber()
}
println "res:"+res

//是否每一項滿足某個條件
println "every:"+str.every {String s-> s.isNumber()}

//對字符串中每一項處理
def list2 = str.collect {
    it.toUpperCase()
}
println "list2:"+list2.toListString()

 閉包的三個重要變量

this、owner、delegate三個關鍵字
this代表定義閉包的類。
owner代表閉包定義處的類或者對象，閉包內部定義閉包中的owner是外層的閉包
deleGate 代表任意的對象，默認值就是owner
如果在類或者方法中定義閉包，此時this,owner,deleGate是一樣的，指向閉包定義處的實例或者類本身
如果在閉包中定義閉包，this指向的仍然是閉包處的實例或者類本身，而owner和deleGate指向的最近的閉包對象。

//定義一個內部類 , 三個變量指向最近的封閉類
class Person{
    def classClosure = {
        println "classClouser this"+this
        println "classClouser this"+owner
        println "classClouser this"+delegate
    }

    def say(){
        def methodClosure = {
            println "methodClouser this"+this
            println "methodClouser this"+owner
            println "methodClouser this"+delegate
        }
        methodClosure.call()
    }
}

Person person = new Person()
person.classClosure.call()
person.say()

//在閉包中中定義閉包
def nestClouser = {
    def innerClouser = {
        println "innerClouser this"+this
        println "innerClouser this"+owner
        println "innerClouser this"+delegate
    }
    innerClouser.delegate = person // 修改默認的deleGate.此時deleGate指向person對象

    innerClouser.call()
}
//this 指向實例本身或者定義處的類，owner和deleGate表示的是距離最近的閉包

 閉包的委托策略

//委托構造
class Student{
    String name
    def pretty = {
        println "my name is ${name}"
    }

    String toString(){
        pretty.call()
    }
}

class Teacher{
    String name
}
Student student = new Student(name: "jane")
Teacher teacher = new Teacher(name: "lay")
student.toString();
student.pretty.delegate = teacher // 將閉包中的delegate指向teacher
student.pretty.resolveStrategy = Closure.DELEGATE_FIRST  //修改委托策略為 deleGate 默認是owner
student.toString()  //此時會在委托的類中尋找name屬性，找不到會回來本身類的內部尋找