目录
groovy的变量
变量的定义
强类型定义
弱类型定义
String、GString 字符串
字符串常用方法
逻辑控制
switch/case
for
闭包
闭包的三个变量
闭包的委托策略
groovy的变量
groovy的变量类型有 基本类型和对象类，与java中的一样。变量定义的时候无论定义基本数据类型还是对象类型，在编译后都会被转化成对象类型，例如 int 编译后会变成 Integer。
变量的定义
强类型定义
语法
明确的类型 变量名 = 变量值
示例
int x = 10 // 定义一个 int 类型的变量
弱类型定义
弱类型定义使用关键字 def，根据变量值推断出变量的明确类型（def和 js、go的var一样）
语法
def 变量名 = 变量值
示例
def x = 10 // 根据变量值10，推断出变量x是int类型
def y = 3.14 // 根据变量的值3.14，推断出变量y是float类型
String、GString 字符串
groovy中定义字符串类型，可以使用java的String，也可以使用groovy提供的GString字符串类型，在java中定义字符串的值要使用 " 双引号，在groovy中定义字符串可以使用 ' 单引号，字符串原样输出使用三对单引号，也可以使用双引号。
单引号与双引号定义的区别在于，单引号定义的内容不能动态改变(意思就是不能包含变量)，双引号定义的可以使用变量动态改变。对于动态改变的变量的类型是GString，没有动态改变的变量是String类型。
示例
// 单引号的方式
def s = 'hello'
def s = '''hello'''
// 双引号的方式
def name = "张三" // String 类型
def sayHello = "hello，${name}" // GString 类型，${} 里面可以是任意的表达式
字符串常用方法
// 左右填充指定的字符，默认填充空字符串
def str = "-groovy-"
println str.center(12, "a") // 打印 aa-groovy-aa
// 左填充指定的字符，默认填充空字符串，padRight是右填充
def str = "-groovy-"
println str.padLeft(12, "a") // 打印 aaaa-groovy-
// 字符串比较，可以通过 大于号小于号等于号 比较字符串的ASCII码
def str1 = "a"
def str2 = "b"
println str1 > str2
// 字符串可以通过下标，获取字符串中的字符
def str = "abc"
println str[0] // 获取下标0的字符，打印a
println str[0..1] // 获取下标 0到1的字符串，打印 ab
// 字符串减法，可以直接去除字符串中指定的字符串
def str1 = "hello groovy"
def str2 = "hello"
println str1.minus(str2) // 打印 groovyprintln str1-str2 // 打印 groovy
def str = "hello groovy"
println str.reverse() // 倒序，打印 yvoorg olleh
println str.capitalize() // 首字母大写，打印 Hello groovy
println str.isNumber() // 判断字符串是否是数字类型的
println str.toInteger() // 转换成其他类型
逻辑控制
条件逻辑：if/else、switch/case
循环逻辑：while、for
其中 if/else 和 while 与 java中使用没区别，这里不再详细说明
switch/case
groovy中的swithc可以传入任意类型的数据进行判断
示例
def x = 1.23
switch (x) {
case 'a' :
println "a"
break
case [1,2,3,4,'a','b']: // groovy 中的 list，x是否在list中存在
println "list"
break
case 1..10: // groovy 中的 范围 数据类型
println "range"
break
case BigDecimal: // 比较数据类型
println "big decimal"
break
default: println "默认"
}for
def sum = 0
// 对 范围类型 进行循环
for (i in 0..9) {
sum +=i
}
// 对 list 进行循环
for (i in [1,2,3,4,5,6,7,8,9]) {
sum +=i
}
// 对 map 进行循环
for (i in ['zs':1, 'ls':2, 'ww':3]) {
sum +=i.value
}闭包
闭包就是一段使用花括号{}括起来的代码块，闭包默认存在一个隐式形参it。
语法
def 闭包变量名 = { 形参1, 形参n -> 闭包体 }
// 定义一个空参数闭包代码块
def closure = {println "hello groovy!"}
closure.call() // 执行闭包
closure() // 执行闭包// 定义一个传参闭包
def closure = {String name -> println "hello ${name}!"}
closure.call("groovy") // 执行闭包
// 定义一个 有返回值的闭包
def closure = {String name -> return "hello ${name}!"}
def result = closure.call("groovy") // 执行闭包
println result
闭包的三个变量
this：只有一个闭包，并且没有嵌套闭包的情况下，this、owner、delegate都是指向当前这个闭包。this不能修改。
owner：在闭包嵌套闭包中，owner、delegate指向离它们最近的闭包。this指向最外层的闭包。owner不能修改。
delegate：默认情况下owner和delegate都是一的，不一样的情况是在执行属于它们的闭包之前人为的修改了delegate的情况下，owner和delegate的指向会不同。delegate可以修改。
闭包的委托策略
class Student {
String name
def pretty = {
"我的名字是 ${name}"
}
String toString() {
pretty.call()
}
}
class Teacher{
String name
}
def stu = new Student(name: "张三")
def tea = new Teacher(name: "李四")
stu.pretty.delegate = tea // 修改 delegate 指向
// 修改闭包委托策略
// DELEGATE_FIRST：从当前类向上查找，找到了返回，没找到继续向上查找
// DELEGATE_ONLY：只查找当前类，没找到报错
stu.pretty.resolveStrategy = Closure.DELEGATE_FIRST // 由于把指向改成了tea,所以会找到tea的name
println stu.toString() // 打印 我的名字是 李四
