groovy语法

目录

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

闭包

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

你可能感兴趣的:(Gradle,gradle)