Groovy-語法基礎

時間  2019-11-17
標籤 groovy 語法 基礎 欄目 Groovy 简体版
原文   原文鏈接

先來一張思惟導圖

Groovy 簡介

Groovy 是一種基於 JVM 的動態語言，他的語法和 Java 類似，最終也是要編譯 .class 在JVM上運行。html

Groovy 徹底兼容 Java 而且在此基礎上添加了不少動態類型和靈活的特性，好比支持閉包，支持DSL，是一門很是靈活的動態腳本語言。java

這篇文章是爲了能看懂在 Gradle腳本中的代碼，知道怎麼寫。因此不會深刻Groovy。express

每一個 build 腳本配置文件都是一個 Groovy腳本文件。在裏面能夠寫任何符合 Groovy 語法的代碼。 例如定義類，方法，變量等。又由於Groovy 是徹底兼容Java的，故也能夠寫任何Java代碼，是徹底兼容的。api

DSL

DSL（Domain Specific Language) 中文意思是 領域特定語言，專門關注某一領域，在於專而不是全。因此纔是領域特定的。數組

Gradle 的腳本就是基於 Groovy 的DSL，專門解決自動化構建的DSL。 咱們只須要按照相應的語法，配置相應的 Gradle 腳本就能夠達到自動化構建的目的，這也是 DSL 的初衷。安全

註釋

單行註釋

//這裏是註釋
def name = "佛系編碼"
複製代碼

多行註釋

/* 這裏是多行註釋
   啦啦啦啦 */
複製代碼

doc 註釋

/**
 * 這裏是 doc 註釋
 * 啦啦啦啦
 */
複製代碼

數據類型

Java中的基本數據類型，對象它都支持；另外還有 閉包 增強的 List，Map的集合 增強的File，Stream等IO類型bash

類型能夠顯式聲明，也能夠用 def 來聲明，用 def 聲明的類型Groovy將會進行類型推斷。閉包

基本數據類型都是和Java 中的一致，就不拿出來講了。下面說一下，對象，字符串，閉包等;單元測試

另外：Groovy 中的分號是能夠省略的；測試

字符串

使用單引號和雙引號均可以定義一個字符串常量。

差異是 單引號只是單純的字符串，不能使用表達式，運算，求值，正則等。

task character(){
  doLast{
      def name = '張三'
      def address ="北京市"
      def age = 19
      println "單引號雙引號都是字符串 name is ${name}; age is $age ; address is ${address}"
      println '單引號裏沒法運算表達式例如 name is ${name}'
  }
}
複製代碼

執行 character

gradle character
複製代碼

獲得結果以下

單引號雙引號都是字符串 name is 張三; age is 19 ; address is 北京市
單引號裏沒法運算表達式例如 name is ${name}
複製代碼

雙引號的字符串能夠直接進行表達式計算，規則是一個美圓符號緊跟一個花括號: {expression} ，若是隻有一個變量能夠省略花括號。例如上面的age

集合

集合默認是 java.util.ArrayList 類型的

def nums = [1,2,4,5,6]
println "nums is ${nums.getClass().getName()} size = ${nums.size()}"
複製代碼

輸出結果爲

nums is java.util.ArrayList size = 5
複製代碼

也能夠顯式指定集合類型 使用 as 關鍵字；

def nums1 = [0,"23",4,5,62,false] as LinkedList
println "nums1 is ${nums1.getClass().getName()};size = ${nums1.size()}"
複製代碼

輸出爲

nums1 is java.util.LinkedList;size = 6
複製代碼

或者在前面顯式指定類型

LinkedList otherLinked = [3, 4, 5]
複製代碼

訪問元素

元素的訪問是經過下標訪問的

println "第三個元素是 ${nums1[2]},倒數第一個是 ${nums1[-1]};第一個和倒數第一個：${nums1[0,-1]}"
println "第二個到第四個：${nums1[1..3]}"
複製代碼

輸出爲：

第三個元素是 4,倒數第一個是 false;第一個和倒數第一個：[0, false]
第二個到第四個：[23, 4, 5]
複製代碼

遍歷元素

使用 each 方法遍歷集合 參數默認是 it

//遍歷
nums1.each {
  print "$it, "
}
複製代碼

輸出爲：

0, 23, 4, 5, 62, false,
複製代碼

帶有下標的遍歷：使用 eachWithIndex 方法

numList.eachWithIndex { int value ,int index->
    println "list[$index] = $value"
    }
複製代碼

數組

數組的定義要明確的指定數組類型

String [] strings = ["I","'","m","is","a","dog","."]
   println "\n 數組 :${strings.getClass().getName()}"
   strings.each{
       print "$it "
   }

   def multi = [5,7,5,8,54,87] as int[]

   println "\n使用 as 顯式指定類型: ${multi.getClass().getName()}"
   multi.each{
       print "$it "
   }
複製代碼

輸出是

數組 :[Ljava.lang.String;
I ' m is a dog . 使用 as 顯式指定類型: [I 5 7 5 8 54 87 複製代碼

添加元素

使用 List.add() 添加元素

numList.add(-11)
複製代碼

使用 可使用 << 操做符添加一個

numList << 13
複製代碼

修改元素

numList[0] = 0
複製代碼

不用擔憂下標越界；Groovy就自動增長到所需的下標,中間的會設置爲 null

def numList = [0,1,2,3,4,5] as LinkedList

        numList.each{
            print "$it "
        }

        println "\n 在 10位置添加一個 11"

        numList[10] =11

        println "添加後的："

        numList.each{
            print "$it "
        }
複製代碼

輸出爲：

> Task :collect1
0 1 2 3 4 5 
 在 10位置添加一個 11
添加後的：
0 1 2 3 4 5 null null null null 11 
BUILD SUCCESSFUL in 0s
複製代碼

刪除元素

使用 List.remove() 移除元素 參數能夠是 下標，能夠是值

numList.remove 0
numList.remove((Object)10)
複製代碼

使用 List.removeLast() 移除最後一個元素

numList.removeLast()
複製代碼

查找元素

使用 List.find() 查找第一個符合條件的元素

print "\n list.find() 查找第一個符合條件的元素 numList.find { it%2==0}"
print numList.find { it%2==0}
複製代碼

使用 List.findAll() 查找全部符合條件的元素

print "\n list.findAll() 查找全部符合條件的元素 numList.findAll {it % 2 ==0 }"
print numList.findAll { it % 2 ==0}
複製代碼

使用 List.any() 查找元素，只要有一個元素符合就返回 true

print "\n list.any() 只要有一個元素符合條件就返回 true numList.any { it % 2 ==1} "
print numList.any { it % 2 ==1}
複製代碼

使用 List.every() 查找元素，必須全部元素都符合條件纔會返回 true

print "\n list.every() 必須全部元素都符合條件纔會返回 true numList.every {it % 2 == 0} "
print numList.every { it % 2 == 0}
複製代碼

統計元素

統計符合條件的元素個數：使用 List.count()

print numList.count { it % 2 ==0 }
複製代碼

統計最大值：List.max()，最小值：List.min()

print "\n 最大值是 ${numList.max()} ,最小值是 ${numList.min()}， 最小的絕對值是 "
print numList.min { Math.abs it}
複製代碼

Map

Map 的定義是鍵值對的方式，使用逗號隔開

def colors = [red:'#FF0000',green:'#00FF00',blue:'#0000FF']
複製代碼

訪問 Map 中的元素有三種方式：

  • map.key
  • map[key]
  • map.get(key)

例如：

task map{
    doLast{
        def colors = [red:'#FF0000',green:'#00FF00',blue:'#0000FF']
        println " map calss is ${colors.getClass().getName()}"
        println "經過 map.key 的方式訪問 colors.red = ${colors.red}"
        println "經過 map[key] 的方式訪問 colors['red'] = ${colors['red']}"
        println "經過 map.get(key) 的方式訪問 colors.get(red) = ${colors.get('red')}"
    }
}
複製代碼

輸出爲 ：

> Task :map
 map calss is java.util.LinkedHashMap
經過 map.key 的方式訪問 colors.red = #FF0000
經過 map[key] 的方式訪問 colors['red'] = #FF0000
經過 map.get(key) 的方式訪問 colors.get(red) = #FF0000


BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
複製代碼

添加元素

//添加元素
colors['pink'] = '#FF00FF'
colors.yellow = '#FFFF00'
複製代碼

修改元素

//修改元素
colors.red = 'red'
colors['blue'] = 'blue'
println "修改後的元素是 colors.red = ${colors.red},colors.blue = ${colors.blue}"
複製代碼

刪除元素

//刪除元素
colors.remove('red')
複製代碼

遍歷元素

和上面的同樣 使用 each 方法

//遍歷 
colors.each{
    println "${it.key} :${it.value}"
}
複製代碼

查找元素

查找的方法 和 上面的都同樣，只是 參數換成了 Map.Entry 或者 key,value ; 這裏只用 find 作一個示例：

find 方法

def green = colors.find { key ,value ->
  if(key.equals('green')) {
      return colors[key]
  }
  return null
}

println "查找結果是 ${green}"


def blue = colors.find { Map.Entry entry ->
    if(entry.key.equals('blue')){
        return entry.value
    }
    return null
}
println "查找的結果是 ${blue}"
複製代碼

方法

方法也是使用 def 定義的

/*
 * 返回大的那個
 */
def max(int a ,int b){
    if(a>b){
      return   a
    }else{
      return   b
    }
}
複製代碼

return 是能夠省略的

Groovy 會把執行過程當中的最後一句代碼做爲返回值

/*
 * 返回大的那個
 */
def max(int a ,int b){
    if(a>b){
         a
    }else{
       b
    }
}
複製代碼

括號是能夠省略的；

在調用方法時括號是能夠省略的；使用 空格間隔開參數便可

def printMaximum(int a,int b){
    if(a>b){
        println "The maximum value of $a and $b is $a"
    }else{
        println "The maximum value of $a and $b is $b"
    }
}

task method {
    doLast{
        println "max is ${max(0,1)}"
        printMaximum 10,20
    }
}
複製代碼

輸出是

> Task :method
max is 1
The maximum value of 10 and 20 is 20

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
複製代碼

代碼塊是能夠做爲參數傳遞的

代碼塊就是一段被花括號包圍的代碼，其實就是閉包；

例如 each 方法

最原始的應該是這樣的

colors.each({println it})
複製代碼

格式化後

colors.each({
    println it
})
複製代碼

Groovy 規定最後一個參數是閉包,能夠將閉包放在方法外面

colors.each(){
    println it
}
複製代碼

調用時方法的括號是能夠省略的 就成了這樣

colors.each {
    println it
}
複製代碼

閉包

閉包是 Groovy 的一個重要特性，能夠說是 DSL 的基礎。

閉包其實就是一段匿名代碼塊。

閉包在 Groovy 中是 groovy.lang.Closure 類的實例，這使得閉包能夠賦值給變量或字段。

定義一個閉包

def hello = { println "Hello 佛系編碼" }
複製代碼

調用這個閉包

hello.call()
複製代碼

另外一種調用方式 直接在後面跟上 ()

hello()
複製代碼

下面模擬一個 each 的執行，定一個方法迭代集合中的元素

/*
  * closure 就是 閉包參數
  */
def customEach(closure){
    //迭代元素
    for(int i in 1..10){
    //在閉包後跟上 () 就是調用了 括號裏的參數就是閉包要接收的參數
        closure(i)
    }
}
複製代碼

調用這個方法，傳入一個閉包打印元素; 若是閉包只有一個參數，那麼默認就是 it

// 若是隻有一個參數 默認就是 it
customEach {
     println it
}
複製代碼

若是閉包要接收多個參數，那就必須把參數顯式的列出來，使用 -> 將參數和主體分開

再次模擬一個 map 的 迭代:

def eachMap(closure){
    def map1 = [name:'佛系編碼',age:666]
    map1.each {
        closure(it.key,it.value)
    }
}
·····

//若是有多個參數，就必需要把參數列出來，使用 -> 將 參數和主體分開
eachMap { key,value ->
    println "$key:$value"
}
複製代碼

閉包委託

Groovy 閉包的強大之處在於它支持閉包方法的委託。

Groovy 的閉包有三個重要屬性

  • thisObject 閉包定義所在的類
  • owner 表示閉包定義所在的對象或閉包（閉包內仍是能夠定義閉包的），這個是最近原則，下面會作說明
  • delegate 默認和 owner 一致，能夠手動修改。

若是將閉包定義在一個類中，默認三個屬性都是相等的；

舉個例子： 在 Person 類中 定義了 一個 act 閉包

class Person{
    private String name

    public int getAge(){
       12
    }

    Closure act ={
         println "thisObject:${thisObject.getClass()}"
        println "owner:${owner.getClass()}"
        println "delegate:${delegate.getClass()}"
    }
}
複製代碼

調用這個閉包，將會有下面的輸出

> Task :test
thisObject:class Person
owner:class Person
delegate:class Person

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
複製代碼

若是將 閉包定義在一個 閉包裏，那麼 thisOjbect 就和 其餘兩個不同，由於 thisObject 是表示的定義閉包所在的類，而 owner 表示 類或閉包

此次在 一個閉包裏再定一個閉包看一下

class Person{
    private String name

    public int getAge(){
       12
    }

    Closure act ={
        println "thisObject:$thisObject"
        println "owner:$owner"
        println "delegate:$delegate"
    }

    Closure eat = {
        def test = {
            println "thisObject:${thisObject.getClass()}"
            println "owner:${owner.getClass()}"
            println "delegate:${delegate.getClass()}"
        }
        test()
    }
}
複製代碼

執行這個 eat 閉包，將會獲得如下結果

> Task :test
thisObject:class Person
owner:class Person$_closure2
delegate:class Person$_closure2

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
複製代碼

能夠看到 thisObject 和 owner 已經不同了，由於 thisObject 表示的是 所在的類，而 owner 表示的定義所在的類或閉包（最近原則）

三個屬性已經很明白了吧，

委託策略

不管何時在閉包中訪問某屬性或調用某方法時，若沒有明確的設置對象，那麼就會調用一個委託策略。經過這個委託策略來決定若是訪問屬性或調用方法。

有如下幾個策略，能夠經過 閉包的屬性更改：resolveStrategy

下面經過一個嵌套類演示一下 策略更改的實際應用。

定義兩個類 Person 和 內部類 Foot ，而且二者都有 name 屬性。Person 多一個 age 屬性。

class Person{
    private String name

    public int getAge(){
       12
    }

    class Foot {
      String name
      Closure walk = { it ->
          println "name is $name,age is $age ,delegate is ${delegate.getClass()}"
          //設置 delegate 屬性
          delegate = it;
          resolveStrategy = Closure.DELEGATE_FIRST
          println "修改策略爲 Closure.DELEGATE_FIRST delegate 優先"
          println "name is $name, age is $age ,delegate is ${delegate.getClass()}"

      }
    }

    void walk(){
        Foot foot = new Foot(name:'腳');
        foot.walk(this)
    }
}
複製代碼

調用 Person 的 walk 方法

Person person = new Person()
person.name ="佛系編碼"
person.walk()
複製代碼

將會獲得下面的輸出

> Task :test
name is 腳,age is 12 ,delegate is class Person$Foot
修改策略爲 Closure.DELEGATE_FIRST delegate 優先
name is 佛系編碼, age is 12 ,delegate is class Person

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
複製代碼

我來解釋一下這個輸出

第一個name 是 腳 ；這是由於默認策略是 Closure.OWNER_FIRST 是在 owner 尋找屬性的；owner 固然是 Foot了。

第二個 name 是 佛系編碼;這是由於 策略改成了 Clousre.DELEGATE_FIRST 是優先在 delegate 上尋找的，而又把 delegate 屬性修改成了傳進去的 Person 實例，他的值在上面已經明確聲明爲了 佛系編碼 。

而 age 只有在 Person 中聲明瞭 getAge() 方法，明確返回了 12.因此即便更改了策略，換了delegate 的值，仍然是 12.

注：三個屬性中 只有 delegate 屬性能夠修改。

在 Gradle 中常見的閉包使用

定義一個 User 類

class User{

    String name
    int age
    
    def dumpUser(){

        println "name is $name,age is $age ."
    }

}
複製代碼

在構建配置腳本中定義一個方法，傳入一個閉包參數用來配置 User 類

將閉包委託策略更改，並設置 delegate 屬性

def user(Closure<User> closure){
    User user = new User()
    closure.delegate = user
    closure.resolveStrategy = Closure.DELEGATE_FIRST
    closure()
}
複製代碼

在使用的時候就是這樣的了，Gradle 中就有不少這種的 DSL 配置，例如咱們建立的 task

task configClosure(){
    doLast{
      user {
        name = '佛系編碼'
        age = 0
        dumpUser()
      }
    }
}
複製代碼

輸出爲

> Task :configClosure
name is 佛系編碼,age is 0 .

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
複製代碼

這裏是閉包 API 傳送門

類

這裏只介紹和 Java 中不一樣的地方.

先看段代碼：

task obj{
    doLast{
        Person p = new Person()
        println "沒賦值前的 ：${p.name}"
        p.name = '佛系編碼'
        println "賦值後的 ：${p.name}"

        println "age is ${p.age}"
    }
}

class Person{
    private String name

    public int getAge(){
       12
    }
}
複製代碼

執行 obj 任務的輸出

Task :obj
沒賦值前的 ：null
賦值後的 ：佛系編碼
age is 12

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
複製代碼

在 Person 類中並無定義 name 屬性的 get/set 方法；卻能夠設置和修改它的值；

這是由於 Groovy 幫咱們搞定了 get/set 方法。

age 屬性也沒有在 Person 類中定義，只是定義了一個 getAge() 方法卻可使用 age 屬性。

可是,由於沒有定義 set 方法，因此 age 屬性只能訪問。

運算符

這裏只列出來和 Java 不一樣且經常使用的運算符

可空運算符

對象非空時使用對象自己，對象爲空時使用給定值；經常使用於給定某個可空變量的默認值。

task operator {
    doLast{
        Person person = new Person();
        //person.name 爲 null 因此會使用 佛系編碼
        def name = person.name ? person.name:'佛系編碼'
        // getAge 返回 12 不爲空 因此使用自己
        def age = person.age ?:10
        println "name is $name , age is $age"
    }
}
複製代碼

輸出

> Task :operator
name is 佛系編碼 , age is 12

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
複製代碼

安全導航運算符

當調用一個對象上的屬性或方法時，若是對象是空的，就會拋出空異常，這個使用 ?. 運算符，當對象爲空時，表達式的值也是空，就不會拋出異常。

task operator {
    doLast{
        User user
        println "user.name is ${user?.name}"
    }
}
複製代碼

輸出是

> Task :operator
user.name is null

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
複製代碼

斷言

斷言是用於驗證假設條件是否爲真，在Groovy的斷言中，若是假設的條件不爲真，那麼就會拋出java.lang.AssertionError異常。

Groovy斷言和Java斷言徹底不一樣。Groovy斷言是一項語言功能，一直處於開啓狀態，和JVM的斷言功能-ea徹底無關。因此它是咱們進行單元測試的首選方式。

例如

assert 1==2 :"1不等於2"
複製代碼

會拋出如下異常

FAILURE: Build failed with an exception.

······

* What went wrong:
Execution failed for task ':operator'.
> 1不等於2. Expression: (1 == 2)
複製代碼

固然不給出消息也是能夠的

assert 1==2
複製代碼

那麼異常就是這樣的。

Execution failed for task ':operator'.
> assert 1==2
          |
          false
複製代碼

在使用斷言時最好是給出一條消息，此消息能夠幫助其餘人理解和維護你的代碼，理清你的意圖。

Groovy API 查詢方式

對於閉包的參數，只能在 API 查詢了，沒有什麼好的辦法。

這裏把 Groovy 文檔地址列出來，方便你們查詢相關 API

運行須知

要使用 gradle 或者 ./gradle 或者 gradlew 命令，必須是要安裝Gradle 並設置過環境變量的，固然在Gradle所在的目錄也是能夠的。

build.gradle 是Gradle 的默認構建腳本文件，在執行 Gradle 命令的時候會默認找在當前目錄下的 build.gradle 文件。

也能夠經過 -b 參數指定加載執行的文件。

例如 要執行 groovu-basic.build 裏的 operator 任務

gradle -b groovy-basic.gradle operator
複製代碼

若是要執行上面的測試代碼，步驟是

  1. 新建一個 build.grale 文件 或者是經過 gradle 新建一個項目 看這篇
  2. 定義一個任務，添加動做
task test{
    doLast{
        //這裏是代碼
    }
}
複製代碼
  1. 粘貼代碼
  2. 運行任務
gradle test
複製代碼

附上個人 Gradle 版本

Gradle 版本

歡迎關注

歡迎關注
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程