Gradle筆記1之Groovy基礎語法

阿新 • • 發佈：2019-01-13

Gradle01

gradle概述

groovy和gradle

groovy是一種基於JVM的敏捷開發語言,它結合了Python,Ruby和Smalltalk的許多特性,同時它的程式碼能夠和Java程式碼很好的結合,並且由於它可以執行在JVM上,所以Groovy可以直接使用其他的Java的jar包

Groovy語言=Java語言的擴充套件+眾多指令碼語言的語法。執行在JVM虛擬機器上
Gradle專案構框架使用groovy語言實現。基於Gradle框架為我們實現了一些專案構件框架

開發環境搭建

groovy是需要執行在java虛擬機器上的,所以需要安裝java環境

java環境

然後解壓下載好的壓縮包,到硬碟中的任意位置

然後配置環境變數,在終端中輸入

subl ~/.zshrc

開啟環境變數的配置,並新增java的配置

注: 我安裝了 sublim text3,所以使用subl命令,如果沒有,請使用vim命令,並且我的終端替換成了zsh,否則環境變數檔案是.bash_profile

# JAVA
export JAVA_HOME=/home/chen/Programs/jdk1.8.0_171  
export JRE_HOME=${JAVA_HOME}/jre  
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME} 
/lib  
export PATH=${JAVA_HOME}/bin:$PATH

重啟終端,在終端中輸入

java -version

看到顯示java的相關資訊了,則表示java環境變數配置成功

Groovy環境

配置Groovy環境的時候主要分成2步:
1. 下載Groovy
2. 解壓並配置環境變數

下載

開啟groovy的下載頁面,我們會發現有很多版本,以目前來說(2018.5.24)它提供了:
- Groovy2.6: Bleeding Edge Vesion
- Groovy2.5: upcoming version
- Groovy2.4: latest stable version

Bleeding Edge Vesion: 這個詞不是很好翻譯,它指的是那種最新的技術,但是需要承擔一定的風險,並且使用者為了追求這種技術的新,也樂於承擔這種風險的版本,而鋼鐵俠不是也有一套血邊裝甲嘛,好像用的也是bleeding edge這個詞,不知道是否也有這種意思

圖文無關

那麼我們選擇下載2.4這個版本,它是最新的穩定版

選擇下載這個SDK bundle,或者這個頁面最上方大大下載按鈕,對應的也是最新穩定版的下載連結:

在下載的時候要注意,groovy的版本和jdk的版本是需要對應的

這個indy和non-indy的意思是需不需要支援Java的InvokeDynamic指令,這是java7中新增的一條位元組碼指令,如果我們要使用的groovy使用這條指令進行編譯的話那麼至少需要1.7以上的java版本,而如果不使用該條指令的話,2.4其實也支援到1.6的jvm的,其實在我們寫groovy程式碼時影響不會很大,而且預設使用的也是groovy non-indy的版本,主要影響的是編譯的過程,這裡建議使用java8以上版本,畢竟java8也出了好長時間了,而且是最新的長期支援版本

解壓並配置環境變數

下載好了之後,就可以解壓到想要的地方了

解壓好了之後,和Java一樣我們需要配置環境變數:

subl ~/.zshrc

# groovy
export GROOVY_HOME=/home/chen/Programs/groovy-2.4.15
export PATH=${GROOVY_HOME}/bin:$PATH

其實就是把bin資料夾中配置進path中,配置完成後重啟終端,然後輸入:

groovy -v

看到

就代表我們已經成功配置了groovy的環境變數

建立專案

我使用的idea進行建立groovy專案,idea的免費版也是支援groovy專案建立的,所以還沒有使用idea的小夥伴可以嘗試一波

在建立專案的時候,我們注意要選擇groovy就可以了,圖中2的部分如果idea沒能正確識別你的groovy和java的安裝路徑的話,需要手動選一下,之後就一路next,正常的建立專案就可以了

基礎語法

HelloWorld

建立好專案之後,我們就可以來寫groovy程式碼了,之前說過groovy是完全相容Java的,而相容到什麼程度呢,首先我們先按Java程式碼的語法來寫一個Groovy的HelloWorld

建立一個Groovy的類

我們叫它HelloGroovy

class HelloGroovy {

    public static void main(String[] args) {
        System.out.println("Hello Groovy");
    }
}

執行一下:

可以看到我們可以正常輸出了,觀察程式碼發現,這不就完全是Java程式碼嘛,是的在Groovy中,你甚至可以寫Java程式碼,那麼groovy又在java程式碼的基礎上可以簡化成什麼樣子呢?

我們知道,java要求我們:
- 所有的程式碼必須寫在一個類中
- 程式需要有一個主方法來執行
- 每一行語句都以分號結束

但是我們的groovy就要靈活很多了,這些Java中的強制性要求,在groovy中都不存在,修改groovy程式碼如下:

System.out.println("Hello Groovy")

是的,就這一句,groovy是個指令碼語言,它不需要類和方法,程式可以直接由上向下一行一行的執行,並且每一行的後面也不需要分號,我們還可以簡化這輸出語句:

println "Hello Groovy"
println("Hello")

直接寫println即可,並且在groovy中允許在 頂級表示式中省略引數列表的小括號,就是你直接呼叫方法的引數,可以省略,要是方法的引數還是一個方法,就不能省略小括號,例如:

println add(3, 4)
println(add(3, 4))

def add(a, b) {
    return a + b
}

這個add的小括號就不能省略,這個後面到方法的時候再說,總之可以發現使用groovy來寫java程式碼,要比純Java程式碼簡潔很多,恩,語法其實有點類似與Python呢,而Groovy的程式碼,也需要編譯,編譯成的檔案也是.class檔案,這就是為什麼Groovy程式碼能夠在JVM上執行,我們直接用idea開啟HelloGroovy.class檔案,idea會自動把編譯後的位元組碼給我們反編譯回來

import groovy.lang.Binding;
import groovy.lang.Script;
import org.codehaus.groovy.runtime.InvokerHelper;
import org.codehaus.groovy.runtime.callsite.CallSite;

public class HelloGroovy extends Script {
    public HelloGroovy() {
        CallSite[] var1 = $getCallSiteArray();
        super();
    }

    public HelloGroovy(Binding context) {
        CallSite[] var2 = $getCallSiteArray();
        super(context);
    }

    public static void main(String... args) {
        CallSite[] var1 = $getCallSiteArray();
        var1[0].call(InvokerHelper.class, HelloGroovy.class, args);
    }

    public Object run() {
        CallSite[] var1 = $getCallSiteArray();
        return var1[1].call(var1[2].callGetProperty(System.class), "Hello Groovy");
    }
}

可以看到所有我們省略的東西,Groovy在編譯成位元組碼的時候,編譯器都給我們自動加回來了~

變數

資料型別

在groovy中可以使用所有Java的資料型別,我們知道在Java中資料型別分為基本資料型別,和引用型別,而在groovy中則沒有基本資料型別了,在groovy中,所有的基本資料型別都會在編譯的時候轉換成其包裝型別:

int x = 10
println x
println x.class

可以看到我們定義一個int型別的變數,在輸出這個變數的型別的時候,發現它的型別是Integer,即它自動被轉換成了引用型別

定義變數

我們的Java是一門強型別語言,所有的變數的在定義的時候就需要宣告好它的資料型別,例如:

public void fun(){
    // JAVA程式碼
    String name = "張三";
    int age = 18;
}

但是Groovy並不是,它有型別推斷機制,就比如我們上面Java程式碼,到了groovy中,除了可以寫成和Java一模一樣的以外,我們還可以這樣寫:

def name = "張三"
def age = 18

println name
println age
println name.class
println age.class

執行結果

可以看到,無論是String型別,還是int型別,我們都使用的是def來進行定義變數的,而在輸出他們的資料型別的時候,Groovy也知道name就是String型別,age就是Integer型別,這就是型別推斷,因為我們在定義變數的時候,直接為資料型別進行賦值了,那麼編譯器就會根據等號右面的值的資料型別,來決定等號左邊變數的資料型別

型別推論、型別推斷、或隱含型別，是指程式語言在編譯期中能夠自動推匯出值的資料型別的能力，它是一些強靜態型別語言的特性。一般而言，函數語言程式設計語言也具有此特性。自動推斷型別的能力讓很多程式設計任務變得容易，讓程式設計師可以忽略型別標註的同時仍然允許型別檢查

其實Java中的型別推斷機制也是逐步被加強的,例如在Java6中你需要這樣定義一個String泛型的集合:

// java6
List<String> strings = new ArrayList<String>();

而到了Java7中我們可以這樣寫:

// java7
List<String> strings = new ArrayList<>();

可以看到編譯器已經越來越智慧了,不需要我們什麼都寫出來了,而java8中的lambda表示式也是這種型別推測機制更加強大的體現

那麼何時定義變數的時候使用強型別定義,何時定義變數的時候使用def呢,總結下來有2點:
1. 如果變數只用於自己這個類而不會使用於其他模組,則使用def
2. 如果用於其他類的話那麼則使用強型別定義

其實無論是強型別定義還是弱型別定義,都是為了我們寫程式更加的方便,易懂,那麼如果我們這個模組要給外部使用的時候,如果我們也使用def的話,就會造成呼叫方的迷惑,不知道傳給我們什麼型別的引數好了

動態型別

Java是一門靜態型別的語言,即當資料的型別一旦確定下來之後,就不能夠在進行更改了,否則編譯都過不去:

public class Main {
    public static void main(String[] args) {
        String s = "張三";
        s = 18;
    }
}

那麼換到我們的groovy中呢,我們在定義變數的時候可以不指定型別,而去使用def,那麼我們可以寫出如下程式碼:

def a = "張三"
println a.class
println a
a = 18
println a.class
println a
a = 3.14
println a.class
println a

可以看到在groovy中我們就定義了一個a變數,而這個a變數可以根據執行時值的不同,而動態的改變它的資料型別,我們的Groovy是動態型別的語言,在寫起來要比Java靈活很多,那麼如果我們使用傳統的強型別定義方式去定義一個變數,變數的型別是不是就不能動態的改變了呢,看程式碼

String a = "張三"
println a.class
println a
a = 18
println a.class
println a

可以看到,強型別定義的方式,我們的資料型別就被固定上了,不能再去改變了,並且如果兩個資料型別沒辦法相容的話,程式還會報錯

int a = 3
a = '張三'

String型別

String型別是Java中非常常用的一種資料型別,甚至可以說是最常用的了,Groovy對Java中的String型別做了一些擴充套件,並把這些擴充套件封裝進了GString(groovy.long.GString)中,就是說在Groovy中的字串,對應兩個類:String和GString,String類和Java中的String沒有任何區別,主要看的是Groovy中特殊的GString

定義String

在Java中定義String是使用雙引號:

String a = "Hello World";

但是在Groovy中就不只只有這一種方法了,在Groovy中可以使用單引號,雙引號和三引號(三個單引號:”’)來定義一個String

def a = 'Hello'
def b = "Hello"
def c = '''Hello'''

println a.class
println b.class
println c.class

可以看到這三種方式都可以定義字串,那麼他們的區別是什麼呢?

單引號

在groovy中使用單引號定義的字串就是Java中最最普通的字串,不能插值

雙引號

在Groovy中如果雙引號定義的字串中沒有插值表示式,那麼雙引號字串就是普通的String類,如果有差值表示式的存在,則是GString的例項,插值表示式在下面會詳細說明

三引號

三引號是多行字串,使用起來和Python是一樣的,可以直接在裡面寫換行,而不需要使用類似於\n這種的符號來表示換行

def s = '''鋤禾日當午
汗滴禾下土
誰知盤中餐
粒粒皆辛苦
'''

println s

需要注意的是,這個字串的每一次換行,其實都是給你自動的新增一個\n的

def s = '''鋤禾日當午
汗滴禾下土
誰知盤中餐
粒粒皆辛苦
'''

println s.contains('\n')
println s.size()

可以看到字串中是包含\n這個字元的,並且字串的長度是24,20個字加上4個\n,那麼如果我不想換行呢,可以使用反斜槓來取消換行:

def s = '''\
鋤禾日當午,\
汗滴禾下土
誰知盤中餐,\
粒粒皆辛苦\
'''

println s

插值表示式

當使用雙引號進行表示字串時,我們可以使用字串插值,就是用固定格式的字串來進行佔位,實際生成的時候,佔位表示式會被動態的替換成響應的字串

在groovy中使用${表示式}的形式來進行佔位:

def youName = 'cfy'
def sayHello = "Hello: ${youName}"
println sayHello

插值表示式不光可以填寫變數的值,還可以計算表示式的值,例如:

def sum = "sum=${5 + 3}"
println sum

字串的使用

我們知道在groovy中如果使用差值表達,那麼它的資料型別就會變成GString,而我們在使用的時候,其實是不需要關心其資料型別的,String和GString之間是可以相互融合的:

def sum = "2 + 3 = ${2 + 3}"
def result = echo sum // 在使用時可以相互融合
println(result)
println(result.class)

String echo(String msg){
    return msg
}

我們定義了一個方法,接受的引數是String型別的,而sum則是GString型別的,但是發現我們的方法是可以正常呼叫的

String類的方法

在Groovy中,String類的方法可以有大支分為兩類,一類是java.lang.String中的方法,另一類是GString的方法,我們主要看一下GString中的一些常用方法

def str = 'groovy'
// 把str使用-填充至18個字元,str在中間
println str.center(18,'-')
// 在原始字串左邊填充~至指定個個數
println str.padLeft(8, '~')
// 倒敘
println str.reverse()
// 首字母大寫
println str.capitalize()
// 判斷str是否是數字
println str.isNumber()
str = '89757'
println str.isNumber()
// 將字串轉換成整數型別
def a = str.toInteger()
println(a + ':' + a.class)

字串運算

在groovy中擴充套件了字串的比較:

def str = 'groovy'
def str2 = 'Hello'
println(str > str2) // true

兩個字串比大小,就是逐個比較每一個字元的ascii的大小,在groovy,字串還可以進行計算,+就是字串的拼接,-則是在原始字串中刪除指定字串,只會刪除第一個;*就是原始字串輸出幾次

str = 'hello'
str2 = str - 'l'
str3 = str * 3

println str2
println str3

子串

在groovy中取子串比較方便,可以使用..操作符來表示範圍

def str = 'groovy'
println str[0] // 取一個字元
println str[0..1] // 取範圍
println str[-2..-1] // 從倒數第二個字元取到倒數第一個字元
println str[-1..0] // 從倒數第一個字元取到第0個字元,相當於倒敘輸出