groovy语法

又逢乱世

已于 2023-06-15 17:43:49 修改

阅读量1.2k

点赞数

分类专栏： Gradle 文章标签： gradle

于 2023-04-15 23:49:54 首次发布

本文链接：https://blog.csdn.net/a1053765496/article/details/130176797

版权

Gradle 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

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) // 打印 groovy

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

函数

有参函数

def say(name){
  println name
}

指定函数默认值

def say(word = "Hello ", name) {
  println word + name
}

指定返回值

int getNum(a, b){
     a * b
}

groovy总是会自动返回方法最后一个表达式的值，无需手动调用 return 语句。

闭包

闭包就是一段使用花括号{}括起来的代码块，闭包默认存在一个隐式形参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()  // 打印 我的名字是 李四

更多请参考

https://www.jianshu.com/p/42a796a422c1