语法分类：
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
网友评论