Groovy 語(yǔ)言基礎(chǔ)

前面一節(jié)我們?yōu)榇蠹医榻B了什么是 Gradle？Gradle 是一個(gè)構(gòu)建工具，它的構(gòu)建腳本是基于 Groovy 或是 Kotlin 語(yǔ)言編寫的。

今天我們就來(lái)看下 Groovy 的基礎(chǔ)語(yǔ)法。Groovy 結(jié)合了 Java、Python、Ruby 等當(dāng)下幾大流行語(yǔ)言的優(yōu)點(diǎn)。它可以說(shuō)是從 Java 中衍生出來(lái)的，為什么這么說(shuō)呢？因?yàn)樗恼Z(yǔ)法和 Java 非常的相似，它的文件也是可以編譯為 .class 文件，而且可以使用 Java 的類庫(kù)。

1. Groovy 基礎(chǔ)語(yǔ)法

1.1 基礎(chǔ)語(yǔ)法

1. 定義變量 def
在 Groovy 中，我們除了指定類型定義變量外，還可以使用def關(guān)鍵字來(lái)定義變量，變量是由數(shù)字、字母、下劃線組成。但是它不能以數(shù)字開頭。我們看下下面一段代碼：

//定義一個(gè)整型變量
def i = 5;
println(i.class)
//定義一個(gè)字符串
def _name = "Groovy語(yǔ)言基礎(chǔ)"
println(_name.class)
//無(wú)效變量(變量不能以數(shù)字開頭)
//def 5imooc = 0;

以上輸出結(jié)果為：

class java.lang.Integer
class java.lang.String

通過(guò)上面的代碼可以發(fā)現(xiàn)，其實(shí)它和 Java 是差不多的，不過(guò) Java 中我們定義變量必須指明它的類型。而 Groovy 中我們可以使用def，系統(tǒng)會(huì)自動(dòng)幫我們轉(zhuǎn)換。

2. 引入包 import
這點(diǎn)跟我們?cè)?Java 中的是一樣的，用的是import。下面我們看個(gè)簡(jiǎn)單例子[引入MarkupBuilder類，創(chuàng)建 xml]：

import groovy.xml.MarkupBuilder 
def newXml = new MarkupBuilder() 

這里我們引入了 MarkupBuilder 類。

我們?cè)賮?lái)看一個(gè)例子：

def _name = "Groovy語(yǔ)言基礎(chǔ)"
println(_name.class)

細(xì)心的同學(xué)會(huì)發(fā)現(xiàn)，我們這里定義 String 時(shí)，并沒(méi)有引入 String 對(duì)應(yīng)的包。但是我們寫 Java 時(shí)需要引入 java.lang.String。這就是我們下面說(shuō)的一個(gè)小知識(shí)點(diǎn)。

Tips：在開發(fā) Groovy 時(shí)，以下一些庫(kù)，我們不需要顯式的去引入它們，系統(tǒng)已經(jīng)包含了這些庫(kù)。

import java.lang.*
import java.util.*
import java.io.*
import java.net.*

import groovy.lang.*
import groovy.util.*

import java.math.BigInteger
import java.math.BigDecimal

3. 注釋和分號(hào)
在 Groovy 語(yǔ)言中它的注釋及分號(hào)和 Java 語(yǔ)言完全一樣。以分號(hào)為語(yǔ)句間的分隔?？梢杂卸嘈凶⑨尯蛦涡凶⑨?。

//這是單行注釋
/** 這是
 *  多行
 *  注釋**/
 def i = 0;  
 println('Hello Mooc');  

4. 關(guān)鍵字
在 Java 和 C 語(yǔ)言中我們都知道，定義變量的時(shí)候不能是關(guān)鍵字，那么我們來(lái)看下 Groovy 有哪些關(guān)鍵字呢？

2. 字符串 String 與 GString

2.1 字符串 String

在 Groovy 中，字符串較 Java 中比較特殊，在 Java 中我們用單引號(hào)（’’）來(lái)表示 char，用雙引號(hào)（""）表示字符串。但是在 Groovy 中字符串不僅可以用雙引號(hào) （""），而且單引號(hào) （’’），三引號(hào) （"’’"）也可以。我們看下下面這個(gè)例子：

class Example { 
   static void main(String[] args) { 
      String a = '單引號(hào)'; 
      String b = "雙引號(hào)"; 
      String c = '''這是三引號(hào) 
    Gradle專題
    Groovy語(yǔ)言基礎(chǔ)''';
      println(a); 
      println(b); 
      println(c); 
   } 
}

最終輸出結(jié)果為：

單引號(hào)
雙引號(hào)
這是三引號(hào) 
    Gradle專題
    Groovy語(yǔ)言基礎(chǔ)

我們發(fā)現(xiàn)三引號(hào)（’’’ ‘’’）其實(shí)還可以換行，多行字符串也可以用三引號(hào)（’’’ ‘’’）來(lái)引用。不像 Java 一樣我們?nèi)绻址畵Q行還需要用“ + 和 \n”連接起來(lái)。

2.2 插值字符串 GString

在 Groovy 中有 2 種字符串，一種是我們上面寫的 String[java.lang.String]這類字符串跟 Java 一樣不能插值，還有一種是 Groovy 的插值字符串 GString，這類字符串可以實(shí)現(xiàn)插值。

所謂插值，就是用 ${變量名}讀取該變量的值，而拼接起來(lái)的字符串。

如下：

class Example { 
   static void main(String[] args) { 
      def a = 'Gradle專題'; 
      def b = "${a} Groovy語(yǔ)言基礎(chǔ)"; //插值字符串 GStringImpl
      println(a.class); 
      println(b.class); 
      println(b); 
   } 
}

它的運(yùn)行結(jié)果為：

class java.lang.String
class org.codehaus.groovy.runtime.GStringImpl
Gradle專題 Groovy語(yǔ)言基礎(chǔ)

從運(yùn)行結(jié)果可以看出，字符串 a 是一個(gè) Java 字符串，字符串 b 它是一個(gè)插值字符串 GStringImpl，它繼承自 GString。上面代碼中${a}就是讀取到 a 的值為 Gradle 專題。

3. 方法

Groovy 的方法定義跟 Java 比較類似，它的返回類型可以用返回值的類型或是def定義，也可以使用 public，static,private等修飾。如下我們定義一個(gè)add(int a)方法：

class Example { 
   static void main(String[] args) { 
     def i = 3;
     println("befor add(i): "+ i);
     i=add(i);
     println("after add(i): "+i);
   } 
   static def add(int a) {
     ++a;
     return a;
   };
}

執(zhí)行結(jié)果如下：

befor add(): 3
after add(): 4

這點(diǎn)跟 Java 是非常相似的。但是大家注意一點(diǎn)：那就是方法不要定義在 main 方法里面，之前遇到有同學(xué)問(wèn)我這么一個(gè)錯(cuò)誤：

Method definition not expected here. Please define the method at an appropriate place or perhaps try using a block/Closure instead. at line: 7 column: 4. File: ConsoleScript42 at line: 7, column: 4

這個(gè)錯(cuò)的原因就是，他把自己的方法定義在 main 方法里面了。這里特別提一下讓大家謹(jǐn)記。

4. 邏輯控制

我們知道邏輯控制一般有 3 種：

• 順序執(zhí)行： 就是按順序一步步執(zhí)行。
• 條件判斷： 這個(gè)就是我們 Java 中的if/else和switch/case。
• 循環(huán)語(yǔ)句： 跟 Java 中一樣還是while和for.

Tips： 雖然 Groovy 的邏輯控制和 Java 中是一樣的，但是 Groovy 又?jǐn)U展了一些新功能。其中條件語(yǔ)句的if/else和循環(huán)語(yǔ)句的while與 Java 中是一樣的，但是條件語(yǔ)句的switch/case和循環(huán)語(yǔ)句中的for， Groovy 在 Java 的基礎(chǔ)上做了擴(kuò)展。

4.1 switch/case 語(yǔ)句

下面我們先看下switch/case:

class Example { 
   static void main(String[] args) { 
    def x = 0.98
    //def x = 3
    def result
    switch (x){
    case [4,5,6,'Gradle']:   //列表
        result = 'list'
        break
    case 3..11:
        result = 'range'     //范圍
        break
    case Integer:
        result = 'Integer'   //類型
        break
    case BigDecimal:
        result = 'BigDecimal'//類型
        break
    default:
        result = 'default'
        break
    }
    println(result)
   };
}

執(zhí)行結(jié)果如下：

//x = 0.98時(shí)輸出結(jié)果為
BigDecimal
//x = 3時(shí)輸出結(jié)果為
range

通過(guò)上面的代碼我們其實(shí)可以看出，相較于 Java 的switch/case，Groovy 它的判斷類型可以是任何類型。

4.2 for 循環(huán)

Groovy 除了支持 Java 的for(int i = 0;i < length;i++)和for(int i :array)形式的循環(huán)語(yǔ)句，還支持以下形式的循環(huán)語(yǔ)句：

class Example { 
   static void main(String[] args) { 
//1 對(duì)范圍的for循環(huán)
def sum = 0
for (i in 0..100){
    sum += i
}
println("0到100的和為："+sum)
//2 對(duì)List的循環(huán)
def sumList = 0;
for (i in [1,2,3,4,5,6,7,8,9,10]){
    sumList += i
}
println("0到10的和為："+sumList)
//3 對(duì)Map的循環(huán)
def sumMap = 0
for (i in ['張三':21,'李四':25,'王五':36]){
    sumMap += i.value
    println i.key
}
println("他們的年齡和為："+sumMap)
   };
}

它的運(yùn)行結(jié)果為：

0到100的和為：5050
0到10的和為：55
張三
李四
王五
他們的年齡和為：82

for 循環(huán)是我們每一門編程語(yǔ)言中都有的循環(huán)語(yǔ)句的關(guān)鍵字，我們從上面的代碼示例和輸出中，可以看到 for 循環(huán)其實(shí)非常簡(jiǎn)單。它比我么在 Java 或是 C/C++ 中的 for 語(yǔ)句好使用太多了，尤其是對(duì) MAP 和 List 的遍歷。

5. 閉包(Closure)

在 Groovy 中閉包是非常靈活且強(qiáng)大的。

首先我們了解下什么是閉包？

閉包就是一段用 {} 包起來(lái)的代碼塊，使用方法和方法類型，可以命名，可以傳參，可以被調(diào)用。下面我們來(lái)定義一個(gè)簡(jiǎn)單閉包，并且調(diào)用它。

class Example { 
   static void main(String[] args) { 
//1 定義一個(gè)閉包
def closer = {
    println "Gradle專題之Groovy語(yǔ)法"
}

//2 閉包的兩種調(diào)用方式
closer.call()
closer()
   };
}

它的運(yùn)行結(jié)果為：

Gradle 專題之 Groovy 語(yǔ)法
Gradle 專題之 Groovy 語(yǔ)法

我們看到上面有 2 種閉包的調(diào)用方式，但是平時(shí)編寫代碼的時(shí)候，我們建議大家使用第一種方式去調(diào)用，以免和方法的調(diào)用混淆。

上面定義的是無(wú)參的閉包，下面我們定義一個(gè)傳參的閉包：

class Example { 
   static void main(String[] args) { 
//1 定義一個(gè)傳參的閉包
def closer = {
   String name -> println "${name}專題之Groovy語(yǔ)法"
}

closer.call('Gradle')
   };
}

它的運(yùn)行結(jié)果為：

Gradle專題之Groovy語(yǔ)法

閉包的傳參的定義其實(shí)我們上面看到換算比較簡(jiǎn)單，我們調(diào)用的時(shí)候?qū)⒅党鋈?，最終就會(huì)在閉包的代碼中使用到傳入的值。

6. I/O操作

前面我們學(xué)習(xí)了閉包，下面我們來(lái)看下 Groovy 的 I/O 操作?？偟膩?lái)說(shuō) Groovy 的 I/O 操作比 Java 簡(jiǎn)單多了。

6.1 Groovy的文件讀取

我們?cè)?D 盤下創(chuàng)建一個(gè) groovy.txt 的文檔，在里面輸入：Gradle 專題之 Groovy 語(yǔ)言。以讀取這個(gè)文件的內(nèi)容為例我們來(lái)看下 Groovy 的代碼：

class Example { 
   static void main(String[] args) { 
        def filePath = "D:/groovy.txt"
        def file = new File(filePath) ;
        file.eachLine {
            println it
        }
   };
}

----------或是我們也可以像下面這么簡(jiǎn)潔---------
class Example { 
   static void main(String[] args) { 
        def filePath = "D:/groovy.txt"
        def file = new File(filePath) ;
        println file.text
    };
}

通過(guò)上面的代碼示例我們可以看到 Groovy 中文件的讀取非常簡(jiǎn)單快捷，比我們?cè)?Java 和 C 語(yǔ)言中方便太多了。只需要文件的路徑地址，通過(guò) new File(filePath) 就可以實(shí)現(xiàn)讀取文件。

6.2 Groovy 的文件寫入

文件寫入跟讀取一樣簡(jiǎn)潔，如下：

class Example { 
   static void main(String[] args) { 
        def filePath = "D:/groovy.txt"
        def file = new File(filePath) ;
        file.withPrintWriter {
            it.println("Gradle專題")
            it.println("Groovy語(yǔ)言")
            it.println("文件寫入")
        }
   };
}

這里我們看到文件的寫入跟讀取一樣非常的方便快捷，其實(shí) Groovy 在 java.io.File 的基礎(chǔ)上做了一些擴(kuò)展.

7. 數(shù)據(jù)結(jié)構(gòu)

Groovy 的數(shù)據(jù)結(jié)構(gòu)我們常用的主要有：列表，范圍，映射。這個(gè)跟我們 Java 的數(shù)據(jù)結(jié)構(gòu)比較類似，下面做簡(jiǎn)單介紹。

7.1 列表（List）

列表的定義跟 Java 差不多，但是較 Java 中比較簡(jiǎn)單。我們從代碼中來(lái)比較：

class Example { 
   static void main(String[] args) { 
// Java的定義方式
    def list = new ArrayList() //定義一個(gè)空的列表
//groovy中定義
    def list2 = []          //定義一個(gè)空的列表
    def list3 = [1,2,3,4]   //定義一個(gè)非空的列表

    println list2.class
    println list3.class
   };
}
--------------輸出----------------
class java.util.ArrayList
class java.util.ArrayList

----------------------------------

我們從上面看到，這樣定義完是跟 Java 一樣的都是ArrayList。
下面我們?cè)倏聪略?Groovy 中定義數(shù)組：

//在groovy中使用as關(guān)鍵字定義數(shù)組
def array = [1,2,3,4] as int[]
//或者使用強(qiáng)類型的定義方式
int[] array2 = [1,2,3]

Tips: 在 Groovy 中定義數(shù)組的方式有兩周，一種是跟 Java 一樣直接指定 int，一種是用as關(guān)鍵字，但是我們使用時(shí)要注意和 List 的區(qū)別。

7.2 范圍（Range）

范圍的使用非常簡(jiǎn)單，我們直接看下面的代碼及注釋：

class Example { 
   static void main(String[] args) { 
   //范圍的定義
    def range = 1..15

    //范圍的使用
     //第一個(gè)元素的值
    println ("第一個(gè)元素的值:"+range[0])
    //是否包含8
    println ("是否包含8 "+range.contains(8))
    //范圍的起始值   
    println ("范圍的起始值:"+range.from)
    //范圍的結(jié)束值
    println ("范圍的結(jié)束值:"+range.to )
      };
}

--------------輸出----------------
第一個(gè)元素的值:1
是否包含8 true
范圍的起始值:1
范圍的結(jié)束值:15

----------------------------------

7.3 映射（MAP）

在 Groovy 中定義映射 (MAP) 和 List 類似使用[]并且要指明它的鍵 （key）和值 （value），默認(rèn)的實(shí)現(xiàn)類為java.util.LinkedHashMap.

class Example { 
   static void main(String[] args) { 
   //1 映射的定義
    def swordsman = [one:'張三豐',two:'金毛獅王謝遜',three:'張無(wú)忌']

    //2 映射的使用
    println swordsman['one']
    println swordsman.get('two')
    println swordsman.three

    //3 添加元素
    swordsman.four = '成坤'
    println swordsman

    //4 groovy中，可以添加一個(gè)復(fù)雜的元素，比如添加一個(gè)map
    swordsman.five = [a:1,b:2]
    println swordsman
   };
}

------------------輸出----------------------
張三豐
金毛獅王謝遜
張無(wú)忌
[one:張三豐, two:金毛獅王謝遜, three:張無(wú)忌, four:成坤]
[one:張三豐, two:金毛獅王謝遜, three:張無(wú)忌, four:成坤, five:[a:1, b:2]]
--------------------------------------------

我們從上面的代碼中看到，Groovy 定義 MAP 時(shí)必須要指定它的鍵和值，包括新增元素時(shí)也要明確鍵和值，但是它的值可以是任意類型，可以是數(shù)字、字符串、列表，也可以是 MAP。

8. 小結(jié)

這篇文章我們主要學(xué)習(xí)了 Groovy 語(yǔ)言的語(yǔ)法基礎(chǔ)，從基礎(chǔ)的語(yǔ)法到字符串，方法，閉包再到數(shù)據(jù)結(jié)構(gòu)。我們總結(jié)一下和一些注意點(diǎn)：

• Groovy 的語(yǔ)法和 Java 非常相似；
• Groovy 中定義變量可以使用def系統(tǒng)會(huì)自動(dòng)幫我們轉(zhuǎn)換為具體類型；
• 定義基本數(shù)據(jù)類型時(shí)不需要導(dǎo)包，Groovy 系統(tǒng)包含那些包；
• Groovy 的字符串可以用，單引號(hào)，雙引號(hào)，三引號(hào)。換可以支持字符串的插值；
• Groovy 的方法跟 Java 一樣不能定義在方法內(nèi)部；
• Groovy 的switch/case支持任意類型的判斷；
• Groovy 的for支持列表，范圍和映射的遍歷；
• Groovy 的閉包靈活且強(qiáng)大建議使用第一種方式調(diào)用；
• Groovy 的數(shù)組使用as關(guān)鍵字定義；
• Groovy 的映射必須指明鍵和值。