Gradle自动化项目构建技术-2.Groovy核心语法讲解

栏目: Groovy · 发布时间: 6年前

内容简介：groovy变量类型都是对象类型的，基本类型都会被编译器转换成对象类型运行结果：

groovy变量类型都是对象类型的，基本类型都会被编译器转换成对象类型

int x = 10
println x.class

double y = 3.14
println y.class

运行结果：

class java.lang.Integer
class java.lang.Double

弱类型def定义方式，可以动态转换为其他类型

def x1 = 10
println x1.class

def y1 = 3.14
println y1.class

def z1 = "hello"
println z1.class

x1 = "shijiacheng"
println x1.class

运行结果：

class java.lang.Integer
class java.math.BigDecimal
class java.lang.String
class java.lang.String

什么时候使用强类型，什么时候弱类型

如果我们自己使用的时候，可以使用弱类型
如果我们定义的类要被其他类使用的话，建议使用强类型，这样就会固定参数的类型，防止类型转换的时候出错。

Groovy字符串详解

单引号定义字符串

def name = 'a single string'
println name.class

// 转义字符
def name2 = 'a single \'a\' string'
println name2.class

运行结果：

class java.lang.String
class java.lang.String

三引号定义字符串

def name3 = '''three sigle string'''
println name3
println name3.class

// 三引号可以自定带格式的字符串
def name4 = '''line1
line2
line3'''
println name4

运行结果：

three sigle string
class java.lang.String
line1
line2
line3

双引号定义字符串

// 双引号定义普通字符串和单引号一样，都是java.lang.String类
def name5 = "hello world"
println name5
println name5.class

// 双引号还可以定义字符串表达式，这个时候返回的就不是java.lang.String类了
def name6 = "2 and 3 equals = ${2 + 3}"
println name6
println name6.class

运行结果：

hello world
class java.lang.String
2 and 3 equals = 5
class org.codehaus.groovy.runtime.GStringImpl

java.lang.String和GStringImpl相互转换是编译器帮我们做好的，我们可以任意转换这两种类型

String echo(String message){
    return message
}
def result = echo(name6)
println result
println result.class

运行结果：

2 and 3 equals = 5
class java.lang.String

####

字符串方法

字符串填充

def str = "hello groovy"
//中间填充
println str.center(15,'&')
// 左边填充
println str.padLeft(15,'a')

运行结果：

&hello groovy&&
aaahello groovy

字符串比较

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

运行结果：

true

索引和字符串截取

// 字符串截取
println str[0]
// 截取某一段字符串
println str[0..1]

运行结果：

h
he

字符串减法

//字符串减法
println str - str2

运行结果：

groovy

其他方法

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

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

// 判断字符串是不是Int类型
println str.isNumber()

// 字符串类型转换
println "123".toInteger()

运行结果：

yvoorg olleh
Hello groovy
false
123

逻辑控制

switch-case语句

def x = 1.23
def result = ''
switch (x){
    case 'foo':
        result = 'foo'
        break
    case [1.23,4,5,6,'inlist']://列表
        result = 'list'
        break
    case 12..30://范围
        result = 'range'
        break
    case Integer:
        result = 'integer'
        break
    case BigDecimal:
        result = 'big decimal'
        break
    default:result = 'default'
}
println(result)

循环语句

对范围的for循环

//对范围的for循环
def sum = 0
for(i in 0..9){
    sum += i
}
println sum

对list的循环

// 对list的循环
sum = 0
for (i in [1,2,3,4,5,6,7,8,9]){
    sum += i
}
println sum

对map的循环

// 对map的循环
sum = 0
for (i in ['lili':1,'lucy':2,'liming':3]){
    sum += i.value
}
println sum

2.2 闭包

闭包：就是代码块

闭包的调用，闭包有两种调用方式

// 有参数的闭包
def clouser5 = {String name -> return "Hello ${name}!"}
def result = clouser5('groovy')
println result

运行结果

Hello groovy!
Hello groovy!

有参数的闭包

// 有参数的闭包
def clouser2 = {String name -> println "Hello ${name}!"}
clouser2.call('groovy')
clouser2('groovy')

有多个参数的闭包

// 有多个参数的闭包
def clouser3 = {String name,int age ->
    println "Hello ${name},My age is ${age}"}
clouser3.call('groovy',4)
clouser3('groovy',4)

闭包的默认参数

// 闭包的默认参数
def clouser4 = { println "Hello ${it}！"}
clouser4.call('groovy')
clouser4('groovy')

闭包的返回值

// 闭包返回值
def clouser5 = {String name -> return "Hello ${name}!"}
def result = clouser5('groovy')
println result

闭包都有返回值

//闭包体没有写return的话其实也是有返回值的
def clouser6 = {String name -> println "Hello ${name}!"}
def result2 = clouser6('groovy')
println result2

运行结果：

Hello groovy!
null

闭包的用法

upto方法

// 计算指定number的阶乘
int fab(int number){
    int result = 1
    1.upto(number,{num -> result *= num})
    return result
}

int x = fab(5)
println x

查看upto方法的源码

public static void upto(Number self, Number to, @ClosureParams(FirstParam.class) Closure closure) {
    int self1 = self.intValue();
    int to1 = to.intValue();
    if (self1 > to1) {
        throw new GroovyRuntimeException("The argument (" + to + ") to upto() cannot be less than the value (" + self + ") it's called on.");
    } else {
        for(int i = self1; i <= to1; ++i) {
            closure.call(i);
        }

    }
}

downto方法

int fab2(int number){
    int result = 1
    number.downto(1){
        num -> result*=num
    }
    result result
}
int y = fab2(5)
println y

time方法

// 计算累加值
int cal(int number){
    int result = 0
    number.times {
        num -> result += num
    }
    return result
}

int z = cal(101)
println z

闭包与字符串结合使用

each遍历

String str = 'the 2 and 3 is 5'
//each遍历
str.each {
    String temp -> print temp.multiply(2)
}

运行结果：

tthhee  22  aanndd  33  iiss  552

find找到符合条件的第一个

// find找到符合条件的第一个
println str.find{
    String s -> s.isNumber()
}

运行结果：

findAll找到所有符合条件的

// findall 找到所有符合条件
def list = str.findAll{
    String s -> s.isNumber()
}
println list.toList()

运行结果：

[2, 3, 5]

any返回str中是否有任意一项符合条件

// any 返回str中是否有符合条件的任何一项
def result = str.any {
    String s -> s.isNumber()
}
println result

运行结果：

true

every 返回str中的每一项是否都符合条件

// every 返回str的每一项是否都符合条件
def result2 = str.every {
    String s -> s.isNumber()
}
println result2

运行结果：

false

将string转换为list

// 将string转为list
def list2 = str.collect {
    it.toUpperCase()
}
println list2.toListString()

运行结果：

[T, H, E,  , 2,  , A, N, D,  , 3,  , I, S,  , 5]

闭包进阶讲解

闭包中的三个重要变量

/**
 * 闭包的三个重要变量 this，owner，delegate
 */
def scriptCloser = {
    //代表闭包定义处的类
    println "scriptCloser this:"+this
    // 代表闭包定义处的类或者对象
    println "scriptCloser owner:"+owner
    // 代表任意对象，默认闭包定义处的类
    println "scriptCloser delegate:"+delegate
}

scriptCloser.call()

运行结果：

scriptCloser this:variable.closerstudy@649bec2e
scriptCloser owner:variable.closerstudy@649bec2e
scriptCloser delegate:variable.closerstudy@649bec2e

定义了一个内部类

//定义了一个内部类
class Person{
    def static classCloser = {
        println "classCloser this:"+this
        println "classCloser owner:"+owner
        println "classCloser delegate:"+delegate
    }

    def static say(){
        def classCloser = {
            println "methodClassCloser this:"+this
            println "methodClassCloser owner:"+owner
            println "methodClassCloser delegate:"+delegate
        }
        classCloser.call()
    }
}

Person.classCloser.call()
Person.say()

运行结果：

classCloser this:class variable.Person
classCloser owner:class variable.Person
classCloser delegate:class variable.Person
methodClassCloser this:class variable.Person
methodClassCloser owner:class variable.Person
methodClassCloser delegate:class variable.Person

去掉内部类中的静态方法

//定义了一个内部类
class Person{
    def classCloser = {
        println "classCloser this:"+this
        println "classCloser owner:"+owner
        println "classCloser delegate:"+delegate
    }

    def say(){
        def classCloser = {
            println "methodClassCloser this:"+this
            println "methodClassCloser owner:"+owner
            println "methodClassCloser delegate:"+delegate
        }
        classCloser.call()
    }
}
Person p = new Person()
p.classCloser.call()
p.say()

运行结果：

classCloser this:variable.Person@932bc4a
classCloser owner:variable.Person@932bc4a
classCloser delegate:variable.Person@932bc4a
methodClassCloser this:variable.Person@932bc4a
methodClassCloser owner:variable.Person@932bc4a
methodClassCloser delegate:variable.Person@932bc4a

闭包中定义一个闭包

// 闭包中定义一个闭包
def nestCloser = {
    def innerCloser = {
        println "innerClassCloser this:"+this
        println "innerClassCloser owner:"+owner
        println "innerClassCloser delegate:"+delegate
    }
    innerCloser.call()
}
nestCloser.call()

运行结果：

innerClassCloser this:variable.closerstudy@1cbb87f3
innerClassCloser owner:variable.closerstudy$_run_closure2@3e84448c
innerClassCloser delegate:variable.closerstudy$_run_closure2@3e84448c

修改默认的delegate

// 闭包中定义一个闭包
def nestCloser = {
    def innerCloser = {
        println "innerClassCloser this:"+this
        println "innerClassCloser owner:"+owner
        println "innerClassCloser delegate:"+delegate
    }
    innerCloser.delegate = p//修改默认的delegate
    innerCloser.call()
}
nestCloser.call()

运行结果：

innerClassCloser this:variable.closerstudy@22e357dc
innerClassCloser owner:variable.closerstudy$_run_closure2@63a12c68
innerClassCloser delegate:variable.Person@446293d

闭包的委托策略

// 闭包的委托策略

class Student{
    String name
    def pretty = {
        "My name is ${name}"
    }
    String toString(){
        pretty.call()
    }
}

class Teacher{
    String name
}

def stu = new Student(name:  Sarash )
def tea = new Teacher(name:  Shijiacheng )
println stu.toString()

stu.pretty.delegate = tea
stu.pretty.resolveStrategy = Closure.DELEGATE_ONLY
println stu.toString()

运行结果：

My name is Sarash
My name is Shijiacheng

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。

码农书籍

计算机程序设计艺术(第3卷)-排序和查找(英文影印版)

（美）Donald E.Knuth / 清华大学出版社 / 2002-9 / 85.00元

《计算机程序设计艺术排序和查找(第3卷)(第2版)》内容简介：这是对第3卷的头一次修订，不仅是对经典计算机排序和查找技术的最全面介绍，而且还对第1卷中的数据结构处理技术作了进一步的扩充，通盘考虑了将大小型数据库和内外存储器。它遴选了一些经过反复检验的计算机方法，并对其效率做了定量分析。第3卷的突出特点是对“最优排序”一节作了修订，对排列论原理与通用散列法作了全新讨论。一起来看看《计算机程序设计艺术(第3卷)-排序和查找(英文影印版)》这本书的介绍吧!

码农工具