2、基础语法、String类介绍、逻辑控制、闭包、闭包委托

语法分类：

image.png

严格意义上说groovy中基本数据类型也是对象类型

int的实际类型就是Integer

//严格来说groovy中没有基本数据类型
int a=10
println(a.class)

//groovy中变量的定义有强类型定义、弱类型定义
int b=10
println(b.class)

def c=20
println(c.class)


c="弱类型定义重新赋值"
println(c.class)

//什么时候使用弱类型定义，什么时候使用强类型定义呢？一般你定义的变量需要外部来传值时建议定义成强类型
//要不然别人不知道传递什么类型的值给你

groovy数据类型测试

String

String类中方法的分类

//字符串的定义可以有三种形式：单引号、双引号、三个单引号

//默认情况下这三种定义的字符串都是java.lang.String下的，为什么说是默认情况下呢
//因为双引号有特殊情况
def str='aaa'
def str2="bbb"
def str3='''ccc'''
println str.class
println str2.class
println str3.class

//单引号与三引号的区别：单引号无格式，三个单引号的有输出格式
def str4='''aaa
bbb
ccc'''
println(str4)

//双引号的特殊之处是支持动态的扩展,并且扩展之后类型变了，不再是String类型了
def str5="start${str}end"
println str5
println str5.class

def str6="3 add 5 result is ${3+5}"


//一些常用的方法
//在字符串首尾扩展字符
def str7="groovy Hello"
println str7.center(20,"#")

//在字符串左边扩展字符
println str7.padLeft(20,"#")

//字符串还提供了很多方便的操作符
def ss1="abc"
def ss2="def"
//比较大小
println ss1>ss2
println ss1.compareTo(ss2)

//取值
println ss1[1]
println ss1[0..1]

def str8="Hello"
//减法
println str7-str8

//反转
println str7.reverse()

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

image.png

逻辑控制

image.png

def x=1.23
def result
switch (x)
{
    case 'foo':
        result='found foo'
        break
    case 'bar':
        result='found bar'
        break
    case [1.23,4,5,6,'in']:
        result='list'
        break
    case 1..23:
        result="range"
        break
    case Integer:
        result="Integer"
        break
    case BigDecimal:
        result="BigDecimal"
        break
    default:result='default'
}
println result//输出list

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


//对List循环

for(i in [1,2,3,4,5])
{
    sim+=i
}
println sum

//对map进行循环
for(i in ['lili':1,'luck':2])
{
    sim+=i.value
}

闭包

image.png

//闭包的定义
def closure={ println "闭包的定义演示" }
//调用闭包
closure.call()
//另一种调用方法
closure()


//闭包的参数,参数与执行体用->隔开
def closure2={ String name -> println("闭包演示接收参数：${name}") }
closure2("zhangsan")

//接收多个参数，多个参数之间用逗号隔开
def closure3={ String name,int age -> println("闭包演示接收多个参数：name is ${name},age is {$age}") }
closure3("张三",10)

//如果闭包只接收一个参数，那么参数可以省略，参数名默认为it
def closure4={ println("闭包默认参数为it:${it}") }
closure4("groovy4")


//闭包的返回值,闭包都有返回值，返回值可以为null,不写return返回的是最后一行
def closure5={  "这是闭包的返回值，没有写return" }
println(closure5())

def closure6={ println "这是闭包的返回值" }
println(closure6())

闭包的测试结果
image.png

//闭包结合基本数据类型使用
//求阶乘
int fab(int number)
{
    int result=1
    1.upto(number,{
        num->result*=num
    })
    return result
}

println fab(5)


//阶乘,同上，闭包可以放到括号外面（我记得应该是如果最后一个参数是闭包的话，那么闭包可以放到括号外面）
int fab2(int number)
{
    int result=1
    number.downto(1)
            {
                num->result*=num
            }
    return result
}
println fab2(5)


//求和
int cal(int number)
{
    int result=0
    number.times {
        num->result+=num
    }
    return result
}

println cal(5)

闭包在基本数据类型中的使用

String中的闭包

其实关于在方法中运用闭包，我们可以查看源码，从源码中就能看出该方法的作用以及需要传递何种类型的闭包

//遍历
def str="abcdefc35"
str.each {
   print it
}

println "换行"

//find查找符合条件的第一个
println str.find {
    it=="c"
}

//findAll查找符合条件的所有字符，并以集合形式返回
def colls=str.findAll{
    it=='c'
}
println colls.toListString()

//any 闭包必须是boolean类型的，可以从源码查看，只要有一个满足即可
println str.any {
    it.isNumber()
}

//every
println str.every{
    it.isNumber()
}

//collect  对每一个字符运用闭包做变换并且添加到新集合中返回
def  colls2=str.collect{
    it.toUpperCase()
}
println colls2.toListString()

字符串中的闭包

闭包进阶

image.png

闭包中的三个关键字 this、owner、delegate

通过几个示例代码来区分这几个关键字

//第一段代码，直接定义闭包
def closure={
    println "直接定义闭包：this"+this
    println "直接定义闭包：owner"+owner
    println "直接定义闭包：delegate"+delegate

}
closure.call()

image.png

这种情况下，这三个关键字代表的内容都是相同的，都是指向闭包所在的类对象（我定义的类名称是F.groovy）

//第二段代码，定义一个内部类，内部类中定义闭包,闭包不是static的

class Person
{
    def closure={
        println "直接定义闭包：this"+this
        println "直接定义闭包：owner"+owner
        println "直接定义闭包：delegate"+delegate

    }
}
Person p=new Person()
p.closure.call()

image.png

//第三段代码，定义一个内部类，内部类中定义闭包,闭包是static的

class Person
{
    def static closure={
        println "直接定义闭包：this"+this
        println "直接定义闭包：owner"+owner
        println "直接定义闭包：delegate"+delegate

    }
}
Person.closure.call()

image.png

注意这儿指向的是类了，不是对象

//第四段代码，闭包中定义闭包

def closure={
    def inner={
        println "闭包中定义闭包：this"+this
        println "闭包中定义闭包：owner"+owner
        println "闭包中定义闭包：delegate"+delegate
    }
    inner.call()
}

closure.call()

image.png

this指向了类对象，owner和delegate指向的都是外部的闭包closure

//第五段代码，闭包中定义闭包，但是我们手动修改delegate的值

def closure={
    def inner={
        println "闭包中定义闭包：this"+this
        println "闭包中定义闭包：owner"+owner
        println "闭包中定义闭包：delegate"+delegate
    }
    inner.delegate=this
    inner.call()
}

closure.call()

image.png

闭包委托策略

class Person
{
    def name
    def closure={
        "my name is ${name}"
    }

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

class Student
{
    def name
}

Person p=new Person(name:"zhangsan")
Student s=new Student(name:"lisi")

println p.toString()//输出：my name is zhangsan

p.closure.delegate=s
p.closure.resolveStrategy=Closure.DELEGATE_FIRST

println p.toString()//输出：my name is lisi