一、什么是 Groovy

1. 官网：

http://www.groovy-lang.org/

2. 概念：

是基于 JVM 虚拟机的一种动态语言，语法上和 Java 非常相似，完全兼容 Java，可以说是一门非常灵活的动态脚本语言

3. 应用：

Gradle 的 build 脚本文件都是一个 Groovy 脚本文件，是使用 Groovy 进行编写的

二、基础语法

由于我们是在学习 Gradle 尤其是 Android Gradle，所以一开始对于 Groovy 不需要掌握得非常深刻，我们这里就对一些语法概念稍作学习，目的是可以读懂 Gradle 相关脚本文件的一些代码和编写简单的脚本文件，等 Gradle 学习深入后再去了解 Groovy 的高级特性。

1. 如何定义一行代码的结束

Groovy 中，每一行的结束不是一定要用分号的，直接换行即可，当然也可以保持 Java 习惯，写上分号

2. 定义标识符

def 是 Groovy 用来定义标识符的关键字

// 定义一个字符串变量 nicholas 它的值为 hzf
def nicholas = "hzf";
// 定义一个方法 buildString，接收两个字符串参数，返回它们拼接的结果
def buildString(String a, String b){
	println "$a-$b"
}

3. 方法

A.）括号可省略： 调用方法的时候，可以省略括号，如 #2

task methodTest {
    buildString("Nicholas","hzf") // #1
    buildString "Nicholas","hzf" // #2
}

def buildString(String a, String b){
	println "$a-$b"
}

括号可省略
B.）return 可不写： 方法中没有写 return 语句，则方法执行过程中的最后一句代码的值作为返回值

task methodTest {
    def result = chooseSmallNum 1,10
    println result
}

def chooseSmallNum(int a, int b){
	if (a <= b) {
		a
	}else {
		b
	}
}

return 可不写
C.）代码块可作为参数传递
代码块： 代码块就是闭包，通俗来说就是一段被大括号包裹起来的代码
演化：
#1 是初始写法，比较繁琐
#2 Groovy 规定如果方法的最后一个参数是闭包，可以放到方法后面
#3 刚才说到方法调用时，括号可以省略，所以综上三种写法都是可以的，最为常见的是 #3 这种写法，了解完转化写法后就会觉得直观又简洁

task methodTest3 {
    doSomething("Nicholas0","hzf",{a,b -> println "$a-$b"}) // #1
    doSomething("Nicholas1","hzf"){ a,b -> // #2
    	println "$a-$b"
    }
    doSomething "Nicholas2","hzf",{ a,b -> // #3
    	println "$a-$b"
    }
}

def doSomething(String a, String b, Closure method){ // Closure 定义闭包
	method.call(a,b) // call 调用闭包
}

代码块可作为参数传递

4. JavaBean

在 Groovy 中，并不是一定要定义成员变量才可以作为一个类的属性进行访问，只要写了 getter/setter 方法，也一样可以作为属性进行访问。如果只写了 getter 方法，那不可以修改该属性的值，如例子中的 age 属性；反之，如果只写了 setter 方法，那就无法访问到这个属性

task javaBeanTest {
    Person p = new Person()
    // Groovy 中的 private 定义的属性竟然可以直接访问！！！
    p.name = "Nicholas"
    println p.info
}

class Person {
	private String name;
	public int getAge(){24}
	public setInfo(String info){}
	public String getInfo(){
		"$name-$age"
	}
}

JavaBean

5. 字符串

Groovy 中提供了三种表示 String 的方法：单引号（’），双引号（"）或三引号（’’’）括起来。其中，单引号括起来的字符串没有运算能力，如 #1 所示 $strB 原模原样的打印出来了；由三引号括起来的字符串可以跨越多行

task stringTest {
	def strA = '单引号'
    def strB = "双引号"
    def strC = '''
---三引号---
'''
    println strA
    println strB
    println strC
    println '单引号==$strB' // #1
    println "双引号==$strB"
    println '''三引号==$strC'''
}

字符串

6. 集合

对于 List 来说，Groovy 提供下标索引的方式进行访问，值得注意的是，除了普通的下标索引，还有负下标索引和范围索引的方式

task listTest{
	def nameList = ["Nicholas","hzf","Groovy","Java","Kotlin","Android","Gradle"]
	println nameList[0] // 正数第一个
	println nameList[1] // 正数第二个
	println nameList[-2] // 倒数第二个
	println nameList[-1] // 倒数第一个
	println nameList[0..2] // 正数第一个到第三个
	println nameList[-1..1] // 倒数第一个到正数第二个，倒着打印
}

集合测试

7. 闭包

A.）概念： 由大括号括起来的一段代码
下面例子中的 {println it} 与 {k,v -> println "$k-$v"} 都是闭包

task closureTest{
	// listEach 的参数是闭包
	// 即 {println it}
	listEach {
		println it // 闭包只有一个参数的时候，默认就是 it
	}
	// mapEach 的参数是闭包
	// 即 {k,v -> println "$k-$v"}
	mapEach { k,v ->
		println "$k-$v" // 闭包不只一个参数的时候，需要把参数一一列出
	}
}
// 方法 listEach 只有一个参数，用于接收一个闭包参数
def listEach(closure){
	def nameList = ["Nicholas","hzf","Groovy","Java","Kotlin","Android","Gradle"]
	nameList.each {
		closure(it)
	}
}
// 方法 mapEach 只有一个参数，用于接收一个闭包参数
def mapEach(closure){
	def map = ["Nicholas":"hzf","Gradle":"Groovy","Android":"Kotlin"]
	map.each {
		closure(it.key,it.value)
	}
}

闭包测试
B.）闭包委托

闭包的三个属性：thisObject,owner,delegete 在闭包内调用方法时，由这三个参数决定使用哪个对象来调用这个被调用的方法：比如说，闭包内执行了方法 A()，那这个 A() 是脚本中的方法 A，还是某个类中的方法 A
thisObject 构建脚本的上下文，和脚本中的 this 相等
默认情况下 delegete 与 owner 是相等的，但是 delegete 可以被修改，修改后就和 owner 不相等了
闭包方法内处理的顺序：thisObject > owner > delegete
在 Gradle 中，一般指定 delegate 为当前的 it

task closureTest2{
	createBook {
		bookName = "Android Gradle 权威指南"
		author = "飞雪无情"
		pageNum = 236
		dumpBook()
	}
}

class Book{
	String bookName
	String author
	int pageNum

	def dumpBook(){
		println "in dumpBook bookName==$bookName, pageNum==$pageNum, author$author"
	}
}

def createBook(Closure<Book> closure){
	Book book = new Book()
	closure.delegate = book
	closure.setResolveStrategy(Closure.DELEGATE_FIRST)
	closure(book)
}

def dumpBook(){
	println "out dumpBook"
}