Groovy-语法基础
Groovy 简介
Groovy 是一种基于 JVM 的动态语言，他的语法和 Java 类似，最终也是要编译 .class 在JVM上运行。html
Groovy 彻底兼容 Java 而且在此基础上添加了不少动态类型和灵活的特性，好比支持闭包，支持DSL，是一门很是灵活的动态脚本语言。java
这篇文章是为了能看懂在 Gradle脚本中的代码，知道怎么写。因此不会深刻Groovy。express
每一个 build 脚本配置文件都是一个 Groovy脚本文件。在里面能够写任何符合 Groovy 语法的代码。 例如定义类，方法，变量等。又由于Groovy 是彻底兼容Java的，故也能够写任何Java代码，是彻底兼容的。api
DSL
DSL（Domain Specific Language) 中文意思是 领域特定语言，专门关注某一领域，在于专而不是全。因此才是领域特定的。数组
Gradle 的脚本就是基于 Groovy 的DSL，专门解决自动化构建的DSL。 咱们只须要按照相应的语法，配置相应的 Gradle 脚本就能够达到自动化构建的目的，这也是 DSL 的初衷。安全
注释
单行注释
//这里是注释
def name = "佛系编码"
复制代码
多行注释
/* 这里是多行注释
啦啦啦啦 */
复制代码
doc 注释
/**
* 这里是 doc 注释
* 啦啦啦啦
*/
复制代码
数据类型
Java中的基本数据类型，对象它都支持；另外还有 闭包 增强的 List，Map的集合 增强的File，Stream等IO类型bash
类型能够显式声明，也能够用 def 来声明，用 def 声明的类型Groovy将会进行类型推断。闭包
基本数据类型都是和Java 中的一致，就不拿出来讲了。下面说一下，对象，字符串，闭包等;单元测试
另外：Groovy 中的分号是能够省略的；测试
字符串
使用单引号和双引号均可以定义一个字符串常量。
差异是 单引号只是单纯的字符串，不能使用表达式，运算，求值，正则等。
task character(){
doLast{
def name = '张三'
def address ="北京市"
def age = 19
println "单引号双引号都是字符串 name is ${name}; age is $age ; address is ${address}"
println '单引号里没法运算表达式例如 name is ${name}'
}
}
复制代码
执行 character
gradle character
复制代码
获得结果以下
单引号双引号都是字符串 name is 张三; age is 19 ; address is 北京市
单引号里没法运算表达式例如 name is ${name}
复制代码
双引号的字符串能够直接进行表达式计算，规则是一个美圆符号紧跟一个花括号: age
集合
集合默认是 java.util.ArrayList 类型的
def nums = [1,2,4,5,6]
println "nums is ${nums.getClass().getName()} size = ${nums.size()}"
复制代码
输出结果为
nums is java.util.ArrayList size = 5
复制代码
也能够显式指定集合类型 使用 as 关键字；
def nums1 = [0,"23",4,5,62,false] as LinkedList
println "nums1 is ${nums1.getClass().getName()};size = ${nums1.size()}"
复制代码
输出为
nums1 is java.util.LinkedList;size = 6
复制代码
或者在前面显式指定类型
LinkedList otherLinked = [3, 4, 5]
复制代码
访问元素
元素的访问是经过下标访问的
println "第三个元素是 ${nums1[2]},倒数第一个是 ${nums1[-1]};第一个和倒数第一个：${nums1[0,-1]}"
println "第二个到第四个：${nums1[1..3]}"
复制代码
输出为：
第三个元素是 4,倒数第一个是 false;第一个和倒数第一个：[0, false]
第二个到第四个：[23, 4, 5]
复制代码
遍历元素
使用 each 方法遍历集合 参数默认是 it
//遍历
nums1.each {
print "$it, "
}
复制代码
输出为：
0, 23, 4, 5, 62, false,
复制代码
带有下标的遍历：使用 eachWithIndex 方法
numList.eachWithIndex { int value ,int index->
println "list[$index] = $value"
}
复制代码
数组
数组的定义要明确的指定数组类型
String [] strings = ["I","'","m","is","a","dog","."]
println "\n 数组 :${strings.getClass().getName()}"
strings.each{
print "$it "
}
def multi = [5,7,5,8,54,87] as int[]
println "\n使用 as 显式指定类型: ${multi.getClass().getName()}"
multi.each{
print "$it "
}
复制代码
输出是
数组 :[Ljava.lang.String;
I ' m is a dog . 使用 as 显式指定类型: [I 5 7 5 8 54 87 复制代码
添加元素
使用 List.add() 添加元素
numList.add(-11)
复制代码
使用 可使用 << 操做符添加一个
numList << 13
复制代码
修改元素
numList[0] = 0
复制代码
不用担忧下标越界；Groovy就自动增长到所需的下标,中间的会设置为 null
def numList = [0,1,2,3,4,5] as LinkedList
numList.each{
print "$it "
}
println "\n 在 10位置添加一个 11"
numList[10] =11
println "添加后的："
numList.each{
print "$it "
}
复制代码
输出为：
> Task :collect1
0 1 2 3 4 5
在 10位置添加一个 11
添加后的：
0 1 2 3 4 5 null null null null 11
BUILD SUCCESSFUL in 0s
复制代码
删除元素
使用 List.remove() 移除元素 参数能够是 下标，能够是值
numList.remove 0
numList.remove((Object)10)
复制代码
使用 List.removeLast() 移除最后一个元素
numList.removeLast()
复制代码
查找元素
使用 List.find() 查找第一个符合条件的元素
print "\n list.find() 查找第一个符合条件的元素 numList.find { it%2==0}"
print numList.find { it%2==0}
复制代码
使用 List.findAll() 查找全部符合条件的元素
print "\n list.findAll() 查找全部符合条件的元素 numList.findAll {it % 2 ==0 }"
print numList.findAll { it % 2 ==0}
复制代码
使用 List.any() 查找元素，只要有一个元素符合就返回 true
print "\n list.any() 只要有一个元素符合条件就返回 true numList.any { it % 2 ==1} "
print numList.any { it % 2 ==1}
复制代码
使用 List.every() 查找元素，必须全部元素都符合条件才会返回 true
print "\n list.every() 必须全部元素都符合条件才会返回 true numList.every {it % 2 == 0} "
print numList.every { it % 2 == 0}
复制代码
统计元素
统计符合条件的元素个数：使用 List.count()
print numList.count { it % 2 ==0 }
复制代码
统计最大值：List.max()，最小值：List.min()
print "\n 最大值是 ${numList.max()} ,最小值是 ${numList.min()}， 最小的绝对值是 "
print numList.min { Math.abs it}
复制代码
Map
Map 的定义是键值对的方式，使用逗号隔开
def colors = [red:'#FF0000',green:'#00FF00',blue:'#0000FF']
复制代码
访问 Map 中的元素有三种方式：
- map.key
- map[key]
- map.get(key)
例如：
task map{
doLast{
def colors = [red:'#FF0000',green:'#00FF00',blue:'#0000FF']
println " map calss is ${colors.getClass().getName()}"
println "经过 map.key 的方式访问 colors.red = ${colors.red}"
println "经过 map[key] 的方式访问 colors['red'] = ${colors['red']}"
println "经过 map.get(key) 的方式访问 colors.get(red) = ${colors.get('red')}"
}
}
复制代码
输出为 ：
> Task :map
map calss is java.util.LinkedHashMap
经过 map.key 的方式访问 colors.red = #FF0000
经过 map[key] 的方式访问 colors['red'] = #FF0000
经过 map.get(key) 的方式访问 colors.get(red) = #FF0000
BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
复制代码
添加元素
//添加元素
colors['pink'] = '#FF00FF'
colors.yellow = '#FFFF00'
复制代码
修改元素
//修改元素
colors.red = 'red'
colors['blue'] = 'blue'
println "修改后的元素是 colors.red = ${colors.red},colors.blue = ${colors.blue}"
复制代码
删除元素
//删除元素
colors.remove('red')
复制代码
遍历元素
和上面的同样 使用 each 方法
//遍历
colors.each{
println "${it.key} :${it.value}"
}
复制代码
查找元素
查找的方法 和 上面的都同样，只是 参数换成了 Map.Entry 或者 key,value ; 这里只用 find 作一个示例：
find 方法
def green = colors.find { key ,value ->
if(key.equals('green')) {
return colors[key]
}
return null
}
println "查找结果是 ${green}"
def blue = colors.find { Map.Entry entry ->
if(entry.key.equals('blue')){
return entry.value
}
return null
}
println "查找的结果是 ${blue}"
复制代码
方法
方法也是使用 def 定义的
/*
* 返回大的那个
*/
def max(int a ,int b){
if(a>b){
return a
}else{
return b
}
}
复制代码
return 是能够省略的
Groovy 会把执行过程当中的最后一句代码做为返回值
/*
* 返回大的那个
*/
def max(int a ,int b){
if(a>b){
a
}else{
b
}
}
复制代码
括号是能够省略的；
在调用方法时括号是能够省略的；使用 空格间隔开参数便可
def printMaximum(int a,int b){
if(a>b){
println "The maximum value of $a and $b is $a"
}else{
println "The maximum value of $a and $b is $b"
}
}
task method {
doLast{
println "max is ${max(0,1)}"
printMaximum 10,20
}
}
复制代码
输出是
> Task :method
max is 1
The maximum value of 10 and 20 is 20
BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
复制代码
代码块是能够做为参数传递的
代码块就是一段被花括号包围的代码，其实就是闭包；
例如 each 方法
最原始的应该是这样的
colors.each({println it})
复制代码
格式化后
colors.each({
println it
})
复制代码
Groovy 规定最后一个参数是闭包,能够将闭包放在方法外面
colors.each(){
println it
}
复制代码
调用时方法的括号是能够省略的 就成了这样
colors.each {
println it
}
复制代码
闭包
闭包是 Groovy 的一个重要特性，能够说是 DSL 的基础。
闭包其实就是一段匿名代码块。
闭包在 Groovy 中是 groovy.lang.Closure 类的实例，这使得闭包能够赋值给变量或字段。
定义一个闭包
def hello = { println "Hello 佛系编码" }
复制代码
调用这个闭包
hello.call()
复制代码
另外一种调用方式 直接在后面跟上 ()
hello()
复制代码
下面模拟一个 each 的执行，定一个方法迭代集合中的元素
/*
* closure 就是 闭包参数
*/
def customEach(closure){
//迭代元素
for(int i in 1..10){
//在闭包后跟上 () 就是调用了 括号里的参数就是闭包要接收的参数
closure(i)
}
}
复制代码
调用这个方法，传入一个闭包打印元素; 若是闭包只有一个参数，那么默认就是 it
// 若是只有一个参数 默认就是 it
customEach {
println it
}
复制代码
若是闭包要接收多个参数，那就必须把参数显式的列出来，使用 -> 将参数和主体分开
再次模拟一个 map 的 迭代:
def eachMap(closure){
def map1 = [name:'佛系编码',age:666]
map1.each {
closure(it.key,it.value)
}
}
·····
//若是有多个参数，就必需要把参数列出来，使用 -> 将 参数和主体分开
eachMap { key,value ->
println "$key:$value"
}
复制代码
闭包委托
Groovy 闭包的强大之处在于它支持闭包方法的委托。
Groovy 的闭包有三个重要属性
- thisObject 闭包定义所在的类
- owner 表示闭包定义所在的对象或闭包（闭包内仍是能够定义闭包的），这个是最近原则，下面会作说明
- delegate 默认和 owner 一致，能够手动修改。
若是将闭包定义在一个类中，默认三个属性都是相等的；
举个例子： 在 Person 类中 定义了 一个 act 闭包
class Person{
private String name
public int getAge(){
12
}
Closure act ={
println "thisObject:${thisObject.getClass()}"
println "owner:${owner.getClass()}"
println "delegate:${delegate.getClass()}"
}
}
复制代码
调用这个闭包，将会有下面的输出
> Task :test
thisObject:class Person
owner:class Person
delegate:class Person
BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
复制代码
若是将 闭包定义在一个 闭包里，那么 thisOjbect 就和 其余两个不同，由于 thisObject 是表示的定义闭包所在的类，而 owner 表示 类或闭包
此次在 一个闭包里再定一个闭包看一下
class Person{
private String name
public int getAge(){
12
}
Closure act ={
println "thisObject:$thisObject"
println "owner:$owner"
println "delegate:$delegate"
}
Closure eat = {
def test = {
println "thisObject:${thisObject.getClass()}"
println "owner:${owner.getClass()}"
println "delegate:${delegate.getClass()}"
}
test()
}
}
复制代码
执行这个 eat 闭包，将会获得如下结果
> Task :test
thisObject:class Person
owner:class Person$_closure2
delegate:class Person$_closure2
BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
复制代码
能够看到 thisObject 和 owner 已经不同了，由于 thisObject 表示的是 所在的类，而 owner 表示的定义所在的类或闭包（最近原则）
三个属性已经很明白了吧，
委托策略
不管何时在闭包中访问某属性或调用某方法时，若没有明确的设置对象，那么就会调用一个委托策略。经过这个委托策略来决定若是访问属性或调用方法。
有如下几个策略，能够经过 闭包的属性更改：resolveStrategy
- Closure.OWNER_FIRST 默认策略，首先在 owner 上寻找属性和方法，找不到则在 delegate 上找。
- Closure.DELEGATE_FIRST 和上面的相反，首先在 delegate 上寻找，找不到则在 owner 上找
- Closure.OWNER_ONLY 只在 owner 上找，忽略 delegate
- Closure.DELEGATE_ONLY 只在 delegate 上找 忽略 owner
- Closure.TO_SELF 高级选项，开发者本身定义策略
下面经过一个嵌套类演示一下 策略更改的实际应用。
定义两个类 Person 和 内部类 Foot ，而且二者都有 name 属性。Person 多一个 age 属性。
class Person{
private String name
public int getAge(){
12
}
class Foot {
String name
Closure walk = { it ->
println "name is $name,age is $age ,delegate is ${delegate.getClass()}"
//设置 delegate 属性
delegate = it;
resolveStrategy = Closure.DELEGATE_FIRST
println "修改策略为 Closure.DELEGATE_FIRST delegate 优先"
println "name is $name, age is $age ,delegate is ${delegate.getClass()}"
}
}
void walk(){
Foot foot = new Foot(name:'脚');
foot.walk(this)
}
}
复制代码
调用 Person 的 walk 方法
Person person = new Person()
person.name ="佛系编码"
person.walk()
复制代码
将会获得下面的输出
> Task :test
name is 脚,age is 12 ,delegate is class Person$Foot
修改策略为 Closure.DELEGATE_FIRST delegate 优先
name is 佛系编码, age is 12 ,delegate is class Person
BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
复制代码
我来解释一下这个输出
第一个name 是 脚 ；这是由于默认策略是 Closure.OWNER_FIRST 是在 owner 寻找属性的；owner 固然是 Foot了。
第二个 name 是 佛系编码;这是由于 策略改成了 Clousre.DELEGATE_FIRST 是优先在 delegate 上寻找的，而又把 delegate 属性修改成了传进去的 Person 实例，他的值在上面已经明确声明为了 佛系编码 。
而 age 只有在 Person 中声明了 getAge() 方法，明确返回了 12.因此即便更改了策略，换了delegate 的值，仍然是 12.
注：三个属性中 只有 delegate 属性能够修改。
在 Gradle 中常见的闭包使用
定义一个 User 类
class User{
String name
int age
def dumpUser(){
println "name is $name,age is $age ."
}
}
复制代码
在构建配置脚本中定义一个方法，传入一个闭包参数用来配置 User 类
将闭包委托策略更改，并设置 delegate 属性
def user(Closure<User> closure){
User user = new User()
closure.delegate = user
closure.resolveStrategy = Closure.DELEGATE_FIRST
closure()
}
复制代码
在使用的时候就是这样的了，Gradle 中就有不少这种的 DSL 配置，例如咱们建立的 task
task configClosure(){
doLast{
user {
name = '佛系编码'
age = 0
dumpUser()
}
}
}
复制代码
输出为
> Task :configClosure
name is 佛系编码,age is 0 .
BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
复制代码
类
这里只介绍和 Java 中不一样的地方.
先看段代码：
task obj{
doLast{
Person p = new Person()
println "没赋值前的 ：${p.name}"
p.name = '佛系编码'
println "赋值后的 ：${p.name}"
println "age is ${p.age}"
}
}
class Person{
private String name
public int getAge(){
12
}
}
复制代码
执行 obj 任务的输出
Task :obj
没赋值前的 ：null
赋值后的 ：佛系编码
age is 12
BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
复制代码
在 Person 类中并无定义 name 属性的 get/set 方法；却能够设置和修改它的值；
这是由于 Groovy 帮咱们搞定了 get/set 方法。
age 属性也没有在 Person 类中定义，只是定义了一个 getAge() 方法却可使用 age 属性。
可是,由于没有定义 set 方法，因此 age 属性只能访问。
运算符
这里只列出来和 Java 不一样且经常使用的运算符
可空运算符
对象非空时使用对象自己，对象为空时使用给定值；经常使用于给定某个可空变量的默认值。
task operator {
doLast{
Person person = new Person();
//person.name 为 null 因此会使用 佛系编码
def name = person.name ? person.name:'佛系编码'
// getAge 返回 12 不为空 因此使用自己
def age = person.age ?:10
println "name is $name , age is $age"
}
}
复制代码
输出
> Task :operator
name is 佛系编码 , age is 12
BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
复制代码
安全导航运算符
当调用一个对象上的属性或方法时，若是对象是空的，就会抛出空异常，这个使用 ?. 运算符，当对象为空时，表达式的值也是空，就不会抛出异常。
task operator {
doLast{
User user
println "user.name is ${user?.name}"
}
}
复制代码
输出是
> Task :operator
user.name is null
BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed
复制代码
断言
断言是用于验证假设条件是否为真，在Groovy的断言中，若是假设的条件不为真，那么就会抛出java.lang.AssertionError异常。
Groovy断言和Java断言彻底不一样。Groovy断言是一项语言功能，一直处于开启状态，和JVM的断言功能-ea彻底无关。因此它是咱们进行单元测试的首选方式。
例如
assert 1==2 :"1不等于2"
复制代码
会抛出如下异常
FAILURE: Build failed with an exception.
······
* What went wrong:
Execution failed for task ':operator'.
> 1不等于2. Expression: (1 == 2)
复制代码
固然不给出消息也是能够的
assert 1==2
复制代码
那么异常就是这样的。
Execution failed for task ':operator'.
> assert 1==2
|
false
复制代码
在使用断言时最好是给出一条消息，此消息能够帮助其余人理解和维护你的代码，理清你的意图。
Groovy API 查询方式
对于闭包的参数，只能在 API 查询了，没有什么好的办法。
这里把 Groovy 文档地址列出来，方便你们查询相关 API
运行须知
要使用 gradle 或者 ./gradle 或者 gradlew 命令，必须是要安装Gradle 并设置过环境变量的，固然在Gradle所在的目录也是能够的。
build.gradle 是Gradle 的默认构建脚本文件，在执行 Gradle 命令的时候会默认找在当前目录下的 build.gradle 文件。
也能够经过 -b 参数指定加载执行的文件。
例如 要执行 groovu-basic.build 里的 operator 任务
gradle -b groovy-basic.gradle operator
复制代码
若是要执行上面的测试代码，步骤是
- 新建一个 build.grale 文件 或者是经过 gradle 新建一个项目 看这篇
- 定义一个任务，添加动做
task test{
doLast{
//这里是代码
}
}
复制代码
- 粘贴代码
- 运行任务
gradle test
复制代码
附上个人 Gradle 版本
欢迎关注
- 1. Groovy语法基础
- 2. Groovy入门 | 基础语法
- 3. Gradle Groovy 基础语法 MD
- 4. Groovy基本语法
- 5. Gradle笔记1之Groovy基础语法
- 6. Gradle 之语言基础 Groovy
- 7. jenkins2 groovy语法
- 8. groovy语法
- 9. Groovy入门基础
- 10. Groovy 语法学习
- 更多相关文章...
- • Kotlin 基础语法 - Kotlin 教程
- • Scala 基础语法 - Scala教程
- • Kotlin学习（一）基本语法
- • Kotlin学习（二）基本类型
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Groovy语法基础
- 2. Groovy入门 | 基础语法
- 3. Gradle Groovy 基础语法 MD
- 4. Groovy基本语法
- 5. Gradle笔记1之Groovy基础语法
- 6. Gradle 之语言基础 Groovy
- 7. jenkins2 groovy语法
- 8. groovy语法
- 9. Groovy入门基础
- 10. Groovy 语法学习