文章目录
- 二、Groovy入门
- 2.1 Groovy 简介
- 2.2 Groovy 安装[非必须]
- 2.3 IDEA创建 Groovy 项目
- 2.4 Groovy 基本语法
- 2.4.1 案例 1:基本注意点
- 2.4.2 案例 2:引号说明
- 2.4.3 案例 3:三个语句结构
- 2.4.4 案例 4:类型及权限修饰符
- 2.4.5 案例 5:集合操作
- 2.4.6 案例 6:类导入
- 2.4.7 案例 7:异常处理
- 2.4.8 案例 8:闭包
【尚硅谷】Gradle教程-讲师：刘辉
生活明朗，万物可爱，人间值得，未来可期
二、Groovy入门
2.1 Groovy 简介
在某种程度上，Groovy 可以被视为 Java 的一种脚本化改良版，Groovy 也是运行在 JVM 上，它可以很好地与 Java 代码及其相关库进行交互操作。
它是一种成熟的面向对象编程语言，既可以面向对象编程，又可以用作纯粹的脚本语言。
大多数有效的 Java 代码也可以转换为有效的 Groovy 代码，Groovy 和 Java 语言的主要区别是：
完成同样的任务所需的Groovy 代码比 Java 代码更少。
Groovy 其特点为：
- 功能强大，例如提供了动态类型转换、闭包和元编程（metaprogramming）支持。
- 支持函数式编程，不需要 main 函数。
- 默认导入常用的包。
- 类不支持 default 作用域，且默认作用域为 public。
- Groovy 中基本类型也是对象，可以直接调用对象的方法。
- 支持 DSL（Domain Specific Languages 领域特定语言）和其它简洁的语法，让代码变得易于阅读和维护。
- Groovy 是基于 Java 语言的，所以完全兼容 Java 语法，所以对于 java 程序员学习成本较低。
详细了解请参考官房文档
2.2 Groovy 安装[非必须]
下载地址
解压配置环境变量：
查看groovy版本：groovy -v
2.3 IDEA创建 Groovy 项目
2.4 Groovy 基本语法
- Groovy是基于Java语言的，所以完全兼容Java语法，可作为面向对象编程语言[定义类]，也可作为脚本类型语言[文件定义中不再出现类]。
- 在一个Groovy文件中可以混合类的定义和脚本定义。此时不要在定义一个和文件同名的类。
- Groovy中使用def定义变量、方法，不建议使用具体的数据类型。
- Groovy中的注释：单行注释用//，多行注释用：/**/。
- Groovy中语句末尾的分号是可以省略的，以换行作为结束。
- 默认类、方法、字段都是public修饰的
- 对象的属性操作
- 对象属性赋值
- 对象.属性名=xxx
- 对象的setter方法
- 具名构造器[Groovy类自带的]：用处 后面给task指定组，description描述信息使用
- 对象属性读取操作
- 对象.属性
- 对象[“属性名”]
- 对象.getter方法
- 对象属性的操作本质是通过属性对应的getter、setter方法完成的
- 方法
- 声明时
- 参数类型、返回值类型 可省略
- retrun关键字 默认使用方法最后一句的返回值作为方法返回值
- 调用时，()可以省略
- 支持顺序结构、分支结构、循环结构语句
- 支持的各种运算符：算术、关系、位、赋值、范围运算符
- 基本类型也是对象，可以直接调用对象的方法 Groovy中的字符串有单引号、双引号、三引号
- 单引号：作为字符串常量使用，没有运算能力
- 双引号：可引用变量${}，有运算能力
- 三引号：模板字符串，支持换行
- 数据类型：变量、属性、方法、闭包的参数以及方法的返回值的类型都是可有可无的，都是在给变量赋值的时候才决定它的类型。
类型转换：当需要时，类型之间会自动发生类型转换:
字符串（String）、基本类型(如 int) 和类型的包装类 (如 Integer)
类说明：如果在一个 groovy 文件中没有任何类定义，它将被当做 script 来处理，也就意味着这个文件将被透明的转换为一个 Script 类型的类，这个自动转换得到的类将使用原始的 groovy 文件名作为类的名字。
groovy 文件的内容被打包进run 方法，另外在新产生的类中被加入一个 main 方法以进行外部执行该脚本。
2.4.1 案例 1:基本注意点
class Demo01BasicNotice {
/**---------------------
1.groovy中使用def 定义属性、方法，def支持动态类型声明
2.单行注释：// 多行注释：/**
3.groovy语句最后的;可以省略
4.groovy可以作为属性自动生成getter、setter方法
5.方法声明时：参数类型、返回值类型、return关键字可以省略，方法调用时，
在不引起歧义的地方，可以省略()
6.变量引用时：在不引起歧义的前提下{}也是可以省略，在容易引起歧义的地方就
不能省略{}
7.对象属性赋值：
方式1：对象.属性名
方式2：对象.{"属性名"}=
方式3：对象.属性setter方法()
方式4：具名构造器的方式
读取属性值：
方式1：对象.属性名
方式2：对象.{"属性名"}
方式3：对象.属性getter方法()
*/
def description = "描述信息"
def bookname = "斗破苍穹"
def sale(price) {
"the book is ${price}" // 不省略{}:${price}
}
def sum(price1, price2) {
"$price1 + $price2 = ${price1 + price2}"
}
}
提示:
方法调用时，在不含有歧义的地方可以省略方法调用时的括号。
这类似于使用${变量名}时，括号在不引起歧义的地方可以省略是一样的。
如
def num1=1;
def num2= 2;
println "$num1 + $num2 = ${num1+num2}"
2.4.2 案例 2:引号说明
//---------------字符串------------------
def desc = "测试";
def str1 = '单引号，不支持变量引用，不支持换行操作${desc}';
println(str1);
def str2 = "双引号，支持变量引用，不支持换行操作${desc}";
println(str2);
def str3 = '''三引号，模板字符串，不支持变量引用，支持
换行操作${desc}''';
println(str3);
// 基本数据类型也可以作为对象使用，可以调用对象的方法
def num1 = 1;
println(num1.getClass().toString())
println(str1.getClass().toString());
println(str2.getClass().toString());
println(str3.getClass().toString());
2.4.3 案例 3:三个语句结构
Groovy 支持顺序结构从上向下依次解析、分支结构(if…else、if…else if …else…、switch…case、for、while、do…while)
具体参考官网
2.4.4 案例 4:类型及权限修饰符
Groovy 中的类型有:
- 原生数据类型及包装类
| 原生数据类型(Primitive type) | 包装类(Wrapper class) |
|---|---|
| boolean | Boolean |
| char | Character |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
-
类、内部类、抽象类、接口
-
注解
-
Trait: 可以看成是带有方法实现的接口
权限修饰符：public、protected、private
拓展：Groovy 类与 Java 类之间的主要区别是：
- 没有可见性修饰符的类或方法自动是公共的（可以使用一个特殊的注释来实现包的私有可见性）。
- 没有可见性修饰符的字段将自动转换为属性，不需要显式的 getter 和 setter 方法。
- 如果属性声明为 final，则不会生成 setter。
- 一个源文件可能包含一个或多个类(但是如果一个文件不包含类定义的代码，则将其视为脚本)。
- 脚本只是具有一些特殊约定的类，脚本类的名称与源文件相同（所以不要在脚本中包含与脚本源文件名相同的类定义）。
提 示：
有 关 Groovy 中 各 种 各 样 的 数 据 类 型 和 权 限 修 饰 符 及 Goovy 与 Java 区别请参考官方文档
2.4.5 案例 5:集合操作
Groovy 支持 List、Map 集合操作，并且拓展了 Java 中的 API，具体参考如下方法：
-
List：
- add()：添加某个元素
- plus()：添加某个 list 集合
- remove()：删除指定下标的元素
- removeElement()：删除某个指定的元素
- removeAll()： 移除某个集合中的元素
- pop()：弹出 list 集合中最后一个元素
- putAt()：修改指定下标的元素
- each()：遍历
- size()：获取 list 列表中元素的个数
- contains()：判断列表中是否包含指定的值，则返回 true
-
Map：
- put()：向 map 中添加元素
- remove()：根据某个键做移除，或者移除某个键值对
- +、-：支持 map 集合的加减操作
- each()：遍历 map 集
请参考官网
提示：
可以把不同的基本类型添加到同一集合中。
代码练习
//----------------------list增删改查----------------------
//1.增：在集合中添加元素
def list = [5, 6, 7, 8];
assert list instanceof java.util.List
list.add(12);
println(list.size());
//2.增：集合与集合相加
def list2 = [1, 2, 3, 4];
println(list.plus(list2)); //将list2添加在list之后
//3.删：删除下表为2的元素
list.remove(2);
println(list);
//4.删：删除集合中指定的元素
list.removeElement(12);
println(list);
//5.删：从list集合中移除list3集合中的元素
def list3 = [6, 8];
list.removeAll(list3);
println(list)
//6.删：从list表中弹出最后一个元素
println(list.pop());
println(list)
//7.改：修改指定下标元素
list.putAt(2, 10);
println(list)
//8.list遍历
[1, 2, 3].each { it ->
println("Item:${it}") //it是对应于当前元素的隐式参数
}
//size():获取此列表中的元素数
//contains():如果此列表中包含指定的值，返回true
//----------------------map增删改查----------------------
//1.键key可以不适用引号，可以使用单引号''，也可以使用双引号""
def map = [J: "Java", 'K': "Kotlin", "G": "Groovy"];
//2.增：增加一个键值对
map.put("P", "Python");
println(map);
//3.删：将某个key移除
map.remove("P");
//4.删：将某个key-value移除
map.remove("J", "Java");
println(map);
//5."-" "+" 操作符重载
map2 = map - [K: "Kotlin"];
println(map2);
map3 = map + [G: "Gradle"] //键相同会覆盖
println(map3);
//6.查看
map.each { key, value ->
println("key:${key} value:${value}")
}
map.each { entry ->
println("key:$entry.key value:$entry.value")
}
2.4.6 案例 6:类导入
Groovy 遵循 Java 允许 import 语句解析类引用的概念
import groovy.xml.MarkupBuilder
def xml = new MarkupBuilder()
assert xml != nul
Groovy 语言默认提供的导入
import java.lang.*
import java.util.*
import java.io.*
import java.net.*
import groovy.lang.*
import groovy.util.*
import java.math.BigInteger
import java.math.BigDecimal
这样做是因为这些包中的类最常用。
通过导入这些样板代码减少了。
参考官网地址
2.4.7 案例 7:异常处理
Groovy 中的异常处理和 java 中的异常处理是一样的。
def z
try {
def i = 7, j = 0
try {
def k = i / j
assert false
} finally {
z = 'reached here'
}
} catch ( e ) {
assert e in ArithmeticException
assert z == 'reached here'
}
参考官网地址
2.4.8 案例 8:闭包
闭包：
Groovy 中的闭包是一个开放的、匿名的代码块，它可以接受参数、也可以有返回值。
闭包可以引用其周围作用域中声明的变量。
语法：
{ [closureParameters -> ] statements }
其中[ closureParameters-> ]是一个可选的逗号分隔的参数列表，参数后面是 Groovy 语句。
参数类似于方法参数列表，这些参数可以是类型化的，也可以是非类型化的。
当指定参数列表时，需要使用-> 字符，用于将参数与闭包体分离。
参考
//闭包体完成变量自增操作
{ item++ }
//闭包使用 空参数列表 明确规定这是无参的
{ -> item++ }
//闭包中有一个默认的参数[it]，写不写无所谓
{ println it }
{ it -> println it }
//如果不想使用默认的闭包参数it,那需要显示自定义参数的名称
{ name -> println name }
//闭包也可以接受多个参数
{ String x, int y ->
println "hey ${x} the value is ${y}"
}
//闭包参数也可是一个对象
{ reader ->
def line = reader.readLine()
line.trim()
}
闭包调用方式：
闭包是 groovy.lang.Closure 的实例。
它可以像任何其他变量一样分配给一个变量或字段。
闭包对象(参数)
闭包对象.call(参数)
def isOdd = { int i -> i%2 != 0 }
assert isOdd(3) == true
assert isOdd.call(2) == false
def isEven = { it%2 == 0 }
assert isEven(3) == false
assert isEven.call(2) == true
闭包在实际开发中的使用：
作为方法的参数使用
特殊说明：
可以把闭包当作一个对象，作为参数传递给方法使用
//无参闭包
def run(Closure closure){
println("run start....")
closure()
println("run end....")
}
run {println "running......"}
//有参闭包
def caculate(Closure closure) {
def num1 = 1;
def num2 = 3;
println("caculate start....");
closure(num1, num2);
println("caculate end....");
}
caculate({ x, y -> println("计算结果: $x + $y = ${x + y}") });
//在build.gradle文件中我们见到的很多都是闭包格式的。
//当闭包作为最后一位参数，可以写在方法外面
/*
caculate() {x,y ->
println "计算结果为：$x+$y=${x+y}"
}
*/
