Groovy 是基于JVM的一种动态语言，语法和java相似。Groovy完全兼容Java，Groovy添加了很多动态类型和灵活的特性，支持闭包，支持DSL

Groovy 字符串

在Groovy中，分号不是必须的。单引号和双引号都可以定一个字符串常量。单引号标记的是纯粹的字符串常量，而不是对字符串里的表达式做运算。但是双引号可以。

task printStringClass << {
        def str1 = '单引号'
        def str2 = "双引号"
        println "单引号定义的字符串类型"+str1.getClass().name
        println "双引号定义的字符串类型"+str2.getClass().name
}
# 执行
./gradlew printStringClass
:printStringClass
单引号定义的字符串类型java.lang.String
双引号定义的字符串类型java.lang.String

BUILD SUCCESSFUL

• 单引号和双引号对字符串中的表达式做运算的比较

task printStringVar {
        def name = '张三'
        println "双引号的变量 ${name}"
        println '单引号变量 ${name}'
}
# 执行
./gradlew printStringVar
双引号的变量 张三
单引号变量 ${name}
可以看出单引号并不能支持字符串表达式的运算

Groovy 集合

Groovy完全兼容了Java的集合，并且做了拓展

List

• 创建一个集合

task printList << {
        def numberList = [1,2,3,4,5,6]
        // 输出变量类型
        println numberList.getClass().name
}
# 执行
./gradlew printList
:printList
java.util.ArrayList

我们可以看到输出的变量类型是ArrayList类型

• 访问集合中的元素
  访问集合中的元素和Java不同，Java使用get()方法，而Groovy直接通过索引访问，和数组一样，而且Groovy还提供了负下标和范围索引，负下标索引从右边开始，-1就表示从右侧数第一个 1..3表示从第一个到第三个

task printList << {
    def numbersList = [1,2,3,4,5,6]
    // 输出变量类型
    println numbersList.getClass().name
    // 访问集合元素
    println numbersList[1]
    println numbersList[2]
    // 负索引
    println numbersList[-2]
    // 范围索引
    println numbersList[2..4]
    
}
# 执行  ./graldew printList
2
3
5
[3, 4, 5]
BUILD SUCCESSFUL

• 迭代元素
  Groovy使用 each方法访问List中的每一个元素

task printList << {
    def numbersList = [1,2,3,4,5,6]
    // 输出变量类型
    println numbersList.getClass().name
    // 访问集合元素
    println numbersList[1]
    println numbersList[2]
    // 负索引
    println numbersList[-2]
    // 范围索引
    println numbersList[2..4]
    
    numbersList.each{
    println it
    }
    
}

Map

Map的用法和List很想，Map的元素是一个K:V键值对

• 定义map集合

task printMap << {
    def map1 = ['name':'wx','age':22,'salary':16000]
    println map1.getClass().name
}
# 执行 ./gradlew printMap
java.util.LinkedHashMap

• 访问map集合元素
  访问map集合可以采用map[key]或者map.key都可以

    println map1['name']
    println map1.age]
>>> 
wx
22
BUILD SUCCESSFUL

• 迭代访问map集合
  迭代访问map集合，少不了each,和java一样，被迭代的元素是Map.Entry的实例

    map1.each {
        print "Key is ${it.key},vale is ${it.value}"
    }
>>>
Key is name,vale is wx Key is age,vale is 22 Key is salary,vale is 16000

上面栗子的遍历访问map中的it就代表了 当前正在迭代的元素

方法

Groovy的方法和Java的方法不同。

• Groovy方法中的括号是可以省略的
  Groovy中可以省略() 变成invokeMethod parm1、parm2

task invokeMethod <<< {
  method(1,2)
  method 1,2
}
def method(int a,int b){
  println a+b
}
# 执行 task任务 ./gradlew invokeMethod
>>> 3 3

• return可以不写
  在Groovy中，我们定义有返回值的方法时。return语句并不是必需的。当没有return语句的时候，Groovy会把方法执行过程中的最活一句代码作为返回值

task printMethodReturn {
    def add1 = method2 1,2
    def add2 = method2 5,3
    println "add1:${add1}"+"add2:${add2}"
}
def method2(int a, int b){
    if(a>b){
        a
    }else{
        b
    }
}
# 执行 ./gradle printMethonReturn
>>> add1:2add2:5

从上面的栗子可以看出当a作为最后一行被执行的代码时，a就是该方法的返回值，反之就是b

• 代码块是可以作为参数传递的
  Groovy是允许代码块作为参数传递的,我们以遍历集合的each方法来说

//最普通的写法是这样的
numList.each({println it})
//格式化后
numList.each({
              println it
  })
// Groovy规定，如果方法的最后一个参数是闭包，可以放到方法的外面
numList.each(){
  println it
}
// 省略括号
numList.each{
  println it
}

JavaBean

Groovy中的JavaBean 有了很大的改善,在Groovy中我们可以非常容易的访问和修改JavaBean的属性值，而不用借助getter/setter方法

// javaBean
class Person{
    private String name
}
task helloJavaBean << {
    Person p  = new Person()
    println "p的名字是 ${p.name}"
    // 赋值
    p.name = "张三"
    println "p的名字是 ${p.name}"
}
# 执行 ./gradlew helloJavaBean
>>> 
p的名字是 null
p的名字是 张三

闭包

闭包的定义

闭包其实就是一段代码块，我们先自己实现一个类似闭包的功能

// 闭包
task helloClosure << {
    customEach{
        println it
    }
}
def customEach(closure){
    for(int i in 1..10){
        closure(i)      
    }
}

闭包后跟一对括号就代表执行这个闭包的方法

向闭包传递参数

task helloClosure <<{
    eachMap {k,v -> println "${k} is ${v}"}
}
def eachMap(a){
  def map1 = ['a':1,'b':'aaa']
  map1.each{
      a(it.key,it.value)
  }
}
# 执行 ./gradlew helloClosure
>>> 
wx is best
age is 123

闭包委托

Groovy闭包支持闭包方法的委托，Groovy的闭包有thisObject、owner、delegate三个属性当在闭包内调用方法时，由它们来确定使用哪个对象来处理。当在闭包内调用方法时，由它们来确定使用哪个对象来处理。默认情况下delegate和owner是相等的，但是delegate是可以被修改的
thisObject的优先级最高，优先使用thisObject来处理闭包中的调用的方法，这个thisObject其实就是这个脚本中的上下文
delegate和owner是相等的，它们的优先级是:owner要比delegate高，所以闭包内的方法的处理顺序是：thisObject>owner>delegate

task helloDelegate << {
    new Delegate().test{
    println "thisObject:${thisObject.getClass()}"
    println "owner:${owner.getClass()}"
    println "delegate:${delegate.getClass()}"
}   

}

def method1(){
     println "context this:${this.getClass()} in root"
     println "method1 in root"
}
class Delegate{
    def method1(){
    println "Delegate this:${this.getClass()} in Delegate"
    println "method1 in Delegate"
    }
    def test(Closure<Delegate> closure){
        closure(this)
    }
}

DSL

DSL (Domain Specific Language)的中文意思是领域特定语言，专门关注某一领域的语言，它在于专，而不在于全，所以才称作领域特定语言。
Gradle就是一门DSL，基于Grovvy，专门解决自动化构建的DSL。

OK，关于Groovy的基础 《Android Gradle》的作者李帅大神已经介绍的详细了，这些基础对于以后使用Gradle有着很大的帮助。接下来会学习一些正经的干货了，下面会学习Gradle 构建脚本的基础