groovy 学习

一、groovy 的环境安装

centos下的安装

$ curl -s get.sdkman.io | bash
$ source "$HOME/.sdkman/bin/sdkman-init.sh"
$ sdk install groovy
$ groovy -version

windows下的安装

官网下载安装包后解压，配置环境
•新建GROOVY_HOME，值为解压后文件的路径。

修改PATH，在最后追加%GROOVY_HOME%\bin

二 groovy的基础语法

groovy的变量

 创建.Groovy Script文件

package variable
//groovy 中变量最后都会被包装成对象类型
int x = 10
println x.class  //Integer
double  y = 1.14
println y.class  // Double

//groovy 定义变量的类型,使用def快速定义弱类型,推断数据类型
def x_1 =2
println x_1.class
def y_1 = 3.15
println y_1.class
def name = 'david'
println name.class

三、groovy中的字符串用法

def str = 'a \'a\' string '
println str
println str.class

//三个引号定义的字符串可以指定格式
def thupleStr = '''\
three 
signle 
string'''
println thupleStr
println  thupleStr.class

//双引号字符串格式,可一再字符串中引用其他字符串，引用其他变量后类型是groovy.runtime.GStringImpl
def name =  "david"
def doubleName = "name: ${thupleStr}"
println doubleName
println doubleName.class

//双引号中的扩展接受任意的表达式
def sum = "the sum of 2 and 3 equals ${2 + 3}"
println sum

//测试GString 和String 的转换.编译器转换
def result = echo(sum)
println result
println result.class
String echo(String message){
    return message
}

/*******字符串String 常用方法 *********************/


def str1 = "justTest"
//println st1.center(9,'a')//字符串两边填充字符，默认填充空格。先右后左

//println str1.padLeft(10,'a')//字符串右侧填充

//字符串比较
def str2 = "hello"
println str1>str2

println str2[0]  //获取下标的值
println str2[0..3]  //获取下标范围的值

println str2.minus("ello")   //等同于 石str1 - str2

println str2.reverse() //字符串反转

println str2.capitalize()  //首字母大写

四、groovy中的逻辑控制

 package variable
//逻辑控制

// switch语句
 def x = 1.23
 def result
 switch (x){
    case 'foo':
        result="founf foo"
        break
     case 'bar':
         result = 'bar'
         break
     case [1.23,5,6,'inList']: //列表中的结果匹配
         result = 'list'
         break
     case 12..30:
         result = 'range'
         break
     case Integer:
         result = 'integer'
         break
     case BigDecimal:
         result = 'bigDecimal'
         break
     default:result = 'default'
 }

 println result

// for循环  计算0-9的和
def sum = 0
 for(i in 0..9){
     sum+=i
 }
 println 'sum:'+sum

 //对于List中元素循环
 def sum1 = 0
 for(i in [1,2,3,4,5,6,7,8,9]){
     sum1 += i
 }
 println "sum1:"+sum1

// 对MAP进行循环
 def sum2 =0
 for(i in ['xiaoMing':1,'xiaoQiang':2,'xiaoHua':3]){
     sum2 += i.value
 }
 println 'sum2:'+sum2

五、闭包

闭包的定义 

闭包是代码块。定义如下

//*******闭包的定义和参数********
def closure = {println  "close package"}//闭包的定义方式
closure.call()//调用闭包方法的两种方式
//closure()

def close = {String name -> println "hello ${name}"}//有参数的闭包定义
close("david")

//多个参数
def close1 = {String name,Integer age-> println "hello :${name}&${age}"}
close1("pangpang",12)

//闭包方法的隐式参数it
def close2 = { println "hello ${it}"}
close2("david")

//*********闭包的返回值**********
def close3 = { println  "test return ${it}"}
def result = close3("test")
println result //闭包方法必定有返回值，默认返回null

闭包的用法

//闭包求阶乘
int fab(number){
    int result = 1
    1.upto(number,{num->result *=num})//upto 实现循环阶乘
    return result
}
println "向上阶乘："+fab(5)

int fab2(int number2){
    int result = 1
    number2.downto(1,{num->result *=num})
    return  result
}
println "向下阶乘："+fab2(7)

//累计求和方法,这里的次数由0开始，所以不能用于阶乘的计算
int cal(int number){
    int sum = 0
    number.times{ num->sum+=num }
    return sum
}

println cal(101) // 计算0-100的结果


//*********字符串在闭包的使用
String str ="string test 1"
str.each {
//    String result -> print result.multiply(2)  //每个字符串输出两次
}

//查找满主条件的第一个元素
str.find{
    String s->s.isNumber()  //必须是一个返回布尔类型的闭包
}

//查找满主条件的所有元素
def list = str.findAll{
    String s -> !s.isNumber()
}
println "列表："+list.toListString()

//判断字符串是否满足某个条件
def res = str.any {
    String s-> s.isNumber()
}
println "res:"+res

//是否每一项满足某个条件
println "every:"+str.every {String s-> s.isNumber()}

//对字符串中每一项处理
def list2 = str.collect {
    it.toUpperCase()
}
println "list2:"+list2.toListString()

 闭包的三个重要变量

this、owner、delegate三个关键字
this代表定义闭包的类。
owner代表闭包定义处的类或者对象，闭包内部定义闭包中的owner是外层的闭包
deleGate 代表任意的对象，默认值就是owner
如果在类或者方法中定义闭包，此时this,owner,deleGate是一样的，指向闭包定义处的实例或者类本身
如果在闭包中定义闭包，this指向的仍然是闭包处的实例或者类本身，而owner和deleGate指向的最近的闭包对象。

//定义一个内部类 , 三个变量指向最近的封闭类
class Person{
    def classClosure = {
        println "classClouser this"+this
        println "classClouser this"+owner
        println "classClouser this"+delegate
    }

    def say(){
        def methodClosure = {
            println "methodClouser this"+this
            println "methodClouser this"+owner
            println "methodClouser this"+delegate
        }
        methodClosure.call()
    }
}

Person person = new Person()
person.classClosure.call()
person.say()

//在闭包中中定义闭包
def nestClouser = {
    def innerClouser = {
        println "innerClouser this"+this
        println "innerClouser this"+owner
        println "innerClouser this"+delegate
    }
    innerClouser.delegate = person // 修改默认的deleGate.此时deleGate指向person对象

    innerClouser.call()
}
//this 指向实例本身或者定义处的类，owner和deleGate表示的是距离最近的闭包

 闭包的委托策略

//委托构造
class Student{
    String name
    def pretty = {
        println "my name is ${name}"
    }

    String toString(){
        pretty.call()
    }
}

class Teacher{
    String name
}
Student student = new Student(name: "jane")
Teacher teacher = new Teacher(name: "lay")
student.toString();
student.pretty.delegate = teacher // 将闭包中的delegate指向teacher
student.pretty.resolveStrategy = Closure.DELEGATE_FIRST  //修改委托策略为 deleGate 默认是owner
student.toString()  //此时会在委托的类中寻找name属性，找不到会回来本身类的内部寻找