《Gradle权威指南》--Groovy基础

No1：

Groovy中分号不是必须的

No2：

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

task printStringClass<<{
    def str1='单引号'
    def str2="双引号"
    
    println "单引号定义的字符串类型："+str1.getClass().name
    println "双引号定义的字符串类型："+str2.getClass().name
}

task printStringVar<<{
    def name = "张三"
    println '单引号的变量计算：${name}'
    println "双引号的变量计算：${name}"
}

结果

No3：

List

task printList<<{
    def numList=[1,2,3,4,5,6]
    println numList.getClass().name
    
    println numList[1]//访问第二个元素
    println numList[-1]//访问最后一个元素
    println numList[-2]//访问倒数第二个元素
    println numList[1..3]//访问第二个到第四个元素
    
    numList.each{
        println it
    }
}

结果

No4：

Map

task printlnMap<<{
    def map1=['width':1024,'height':768]
    println map1.getClass().name
    
    println map1['width']
    println map1.height
    
    map1.each{
        println "key:${it.key},Value:${it.value}"
    }
}

结果

No5：

方法括号可省略

task invokeMethod<<{
    method1(1,2)
    method1 1,2
}

def method1(int a,int b){
    println a+b
}

结果

No6：

return可以不写，默认执行最后一句

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
    }
}

结果

No7：

代码块

代码块形成过程
//第一步
numList.each({
    println it
})
//第二步
numList.each(){
    println it
}
//第三步
numList.each{
    println it
}

No8：

JavaBean

task helloJavaBean<<{
    Person p = new Person()
    println "名字是：${p.name}"
    p.name = "张三"
    println "名字是：${p.name}"
    println "年龄是：${p.age}"
}

class Person{
    private String name
    public int getAge(){
        12
    }
}

结果

注意：能取到age的值是因为定义了getAge()方法，但不能修改age的值，因为没有定义setter方法

No9：

闭包

task helloClosure<<{
    //使用我们自定义的闭包
    customEach{
        println it
    }
}

def customEach(closure){
    //模拟一个有10个元素的集合，开始迭代
    for(int i in 1..10){
        closure(i)
    }
}

结果

当闭包有一个参数时，默认就是it

多个参数如下

task helloClosure<<{
    //多个参数
    eachMap{k,v->
        println "${k} is ${v}"
    }
}

def eachMap(closure){
    def map1 = ["name":"张三","age":18]
    map1.each{
        closure(it.key,it.value)
    }
}

结果

No10：

Groovy闭包有thisObject、owner、delegate三个属性

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

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)
    }
}

结果

注：delegate和owner是相等的。优先级：thisObject>owner>delegate？

task configClosure<<{
    person{
        personName="张三"
        personAge=20
        dumpPerson()
    }
}

class Person{
    String personName
    int personAge
    def dumpPerson(){
        println "name is ${personName},age is ${personAge}"
    }
}

def person(Closure<Person> closure){
    Person p = new Person();
    closure.delegate = p
    //委托模式优先
    closure.setResolveStrategy(Closure.DELEGATE_FIRST);
    closure(p)
}

结果