目录
为什么要学习Groovy
Groovy 介绍
Groovy 特点
Groovy 实战
动态类型
简单明了的list,map类型
在groovy世界任何东西都是对象
属性操作变得更容易
GString
闭包
委派：delegate
Switch变得更简洁
元编程
强制类型检查
Elvis Operator
安全访问
为什么要学习Groovy
作为Java为主语言的程序员，Groovy作为Java平台上的脚本语言（动态语言）在兼容方面是有得天独厚的优势。接触过Aandroid开发的同学大家都已经接触到啦Gradle构建项目（Gradle构建也支持Java项目的构建），Gradle就是采用Groovy实现的用于构建项目的框架。还有就是新版本的idea推荐使用Gradle进行插件开发。当然以上只是从客观方面阐述Groovy技术的发展趋势（包含但不仅限于这些方面）来说明我们需要学习，从自身层面来说多学多益，或者说有技术追求或者技术理想的同学，多学一门技术也是对自己的提升。接下来就让我们一起走进Groovy的世界吧。
Groovy 介绍
Apache Groovy是一种强大的、可选的类型和动态语言，具有静态类型和静态编译功能，用于Java平台，旨在通过简洁、熟悉和易于学习的语法提高开发人员的生产力。它可以与任何Java程序顺利集成，并立即为您的应用程序提供强大的功能，包括脚本功能、领域特定语言创作、运行时和编译时元编程以及函数式编程。
-- groovy 官网
以上是官网介绍，我个人的通俗理解如下，Groovy是用于Java虚拟机的一种敏捷的动态语言，是一种成熟的面向对象编程语言，又是一种纯粹的脚本语言。Groovy运行在JVM环境上，在语法上兼具java 语言和脚本语言特点，大大简化了语法。同时又具有闭包和动态语言中的其他特性，弥补了单纯的Java代码所不具备的动态性，我们可以在程序运行时任意修改代码逻辑，不需要重新发布。
Groovy 1.0于2007年1月2日发布。 Groovy通过Apache License v 2.0发布。Groovy的官方网站是The Apache Groovy programming language
Groovy 特点
Groovy中有以下特点（官网API文档：The Apache Groovy programming language - Groovy Development Kit）：
- Groovy是基于Java虚拟机的一种面向对象的脚本语言，同时支持静态和动态类型。
- Groovy对于Java开发人员来说很简单，因为Java和Groovy的语法非常相似，可以使用现有的Java库。
- 支持运算符重载。
- 本地语法列表和关联数组。
- 对正则表达式的本地支持。
- 各种标记语言，如XML和HTML原生支持。
- Groovy扩展了java.lang.Object。
Groovy 实战
动态类型
groovy的第一个特性就是动态特性，定义一个变量以后，可以对这个变量赋与任何类型的值；groovy提供了这种支持方式但是出于好的编码习惯而言，我们是杜绝这种开发方式的。
def v = 0;//定义了数值类型的变量v
v = new Date();//然后又给它赋与Date类型的值.
println(v);简单明了的list,map类型
我们可以使用groovy简单明了的定义list和map数据结构。不像在Java中国我们要先定义类型才能赋值，Groovy直接使用语法糖就可以快速赋值。具体看如下的代码事例，只列举了其中典型的API进行概念说明，剩余的API如果同学们感兴趣可以自行尝试练习。
- 使用"[]"定义list列表，并对其直接操作
// list 可以看到的是编译器帮我们作何类型识别
def list = [1, 2]
// 这个是groovy的list的API从左边插入一个记录
list.leftShift(3)
// push是从插入到列表前面
list.push(0)
// add和我们java的List一样是追加到最后
list.add("abc")
// groovy中的<<可以对list数据类型的作用添加值，也是追加到最后面，需要注意的是在数字类型时是位运算操作
list << "<<号";
// "+"在groovy的语法中也是追加元素到集合中，并且是追加到最后
list += "加上+="
// 查看打印结果可以看到我在每个API的功能描述上的说明
// [0, 1, 2, 3, abc, <<号, 加上+=]
println(list)
// 也可以采用 lambda 表达式遍历集合
list.forEach({ println(it)})- 使用":"分隔key和value来定义map数据，key不需要用引号引起来，并且能使用key直接对map进行读写操作
def map = [a: 2, b: new Date()];
// 写入 直接追加到map集合中
map.put("aaaa","bbb")
println(map)
// 写入 直接采用Map的key进行操作
map.a = "a value change"
println(map)
// 结果如下 可以看到 key 为 "a" 的value被改变
[a:2, b:Sun May 28 11:19:56 CST 2023, aaaa:bbb]
[a:a value change, b:Sun May 28 11:19:56 CST 2023, aaaa:bbb]在groovy世界任何东西都是对象
怎么理解上面的概念呢，对照着Java语言来说，我们都知道在Java语言中有是区分对待基本类型和引用类型的。基本类型是没有方法调用的因为基本类型是按值访问的，在这个方面Groovy比Java更像是一个面向对象语言。
// 在groovy中，一切都是对象。一切都可以当成对象来使用；
// 即使在Java中的基本类型也更像是一个对象
100.times {println("hello world")}属性操作变得更容易
不同于Java中要操作一个对象中的属性必须通过get,set方法，即使是将属性定义成private。在groovy中，定义一个javabean，不再需要写getter,setter方法。读写属性直接用"."号操作即可。
class JavaBeans {
String a
// 即使是定义成private 也可以直接访问
// private String a
}
def beans = new JavaBeans();
beans.a = "object set property value"
println(beans.a)GString
GString是Groovy提供的快速处理字符串的工具。双引号""号的下字符串，可以直接通过 $var 或者 ${var}方式简单明了的嵌入变量。并且GStrng会调用包含的闭包 无参GString会调用闭包并打印我们期待的结果到Writer。
// case1
def a = "a"
def b = "b"
// a=a,b=b 快速替换字符串变量
println("a=${a},b=$b")
// case2
def name = 'lly'
def hello = "hello $name !"
// 结果：hello lly ! 快速替换字符串变量
println hello
// 注意这一行
name = '阳仔'
// 结果：hello lly !
println hello
// case3 ：GStrng会调用包含的闭包 无参GString会调用闭包并打印我们期待的结果到Writer
def quote = "${-> name} , welcome"
// 结果：阳仔 , welcome
println quote
// 注意这一行
name = 'lisi'
// 结果：lisi , welcome
println quote闭包
在groovy中的闭包可以看成是一个代码块，它可以没有参数和返回值；它像java8以上的lambda语法或者像一个有一个方法的java内部类（这里类似于函数式编程规范定义）。在groovy闭包中的隐含内置变量，通过哪住的变量我们可以做一些获取单独元素操作的事情。比如迭代、判断等等其他业务。
it：当闭包的方法中，没有定义任何参数时，也可以直接用it变量；
this：跟java中的this一样；
owner：基本上跟this一样，只是除了一种情况，如果该闭包是在其他的闭包中定义的，owner就指向定义它的闭包对象。
// 闭包中内置了很多迭代方法，如find、findAll、collect等等。这里需要注意的是内置对象 it 的使用
def list = ['foo', 'bar']
def newList = []
list.collect(newList) {
it.toUpperCase()
}
// 结果：[FOO, BAR]
println newList
//或者
list = ['foo', 'bar']
newList = []
list.collect(newList, {
it.toUpperCase()
});
// 结果：[FOO, BAR]
println newList
// 在groovy闭包中的隐含内置变量
def a = {
println "a this:" + this
println "a owner:" + owner // ower指向b
def b = {
println "b this:" + this
println "b owner:" + owner // ower指向b
}
b.call()
}
a.call()
// 结果：这里可以看到 this 和 owner 异同
a this:script.GroovyDemo1@78b236a0
a owner:script.GroovyDemo1@78b236a0
b this:script.GroovyDemo1@78b236a0
b owner:script.GroovyDemo1$_run_closure3@304b9f1a委派：delegate
Groovy中的delegate基本上是跟owner的一样，除非它通过Closure.setDelegate()委派指向新的对象。
def scriptClosure = {
println "scriptClosure this:" + this
println "scriptClosure owner:" + owner
println "scriptClosure delegate:" + delegate
}
println "before setDelegate()"
scriptClosure.call()
scriptClosure.setDelegate("lly")
println "after setDelegate()"
scriptClosure.call()
// 结果：
scriptClosure this:script.GroovyDemo1@5c371e13
scriptClosure owner:script.GroovyDemo1@5c371e13
scriptClosure delegate:script.GroovyDemo1@5c371e13
after setDelegate()
scriptClosure this:script.GroovyDemo1@5c371e13
scriptClosure owner:script.GroovyDemo1@5c371e13
scriptClosure delegate:llySwitch变得更简洁
Groovy中的switch可以允许专入list,对象，范围...等表达式作为case依据
def x = 20;
switch (x) {
case [1, 2, 3, 4, 5]:
println("aaaaaa")
break;
case "foo":
println("bbbbb")
case 10..1000:
println("ccccc")
break;
case Date:
println("dddddd")
break;
}
// 结果： 因为 20 在 10到1000 的范围内
ccccc元编程
在Groovy中，可以使用 metaClass类来，对元对象添加属性和方法。原因是由于在Groovy中，如果你的对象使用了一个它不曾定义过的方法不会报错，至少编译的时候不会报错，这就是因为Groovy特殊的运行时机制。你调用了一个对象的方法，他会先去检查这个类里面是否定义了这个属性和方法。如果没有的话会去MeteClass中去寻找，在Java中所有的类都会集成Object，而在Groovy中，所有的类都会继承GroovyObject，这个类里面就有获取MeteClass的方法。这样，就可以在运行中去动态的给对象添加属性和方法，甚至是静态的方法。如果MeteClass中也没有定义这个方法的话，就要去依次去寻找实体类里面是否实现了methodMissing和invokeMethod方法了，在这两个方法里面可以做特殊的处理。
// 基本元编程
// 对String类，添加一个uppers方法
String.metaClass.uppers = { -> toUpperCase() };
println "aaa".uppers()
//结果：AAA
// 对Interger类，添加一个say方法
Integer.metaClass.say = { -> "I am Interger" }
def i = new Integer(100);
println i.say()
// 结果：I am Interger
// 给对象添加属性、方法、静态方法
class Person {
String name;
Integer age;
String eat() {
println(name + "like eat")
}
}
def p = new Person(name: "阳仔", age: 18)
p.eat()
// 给对象添加属性
p.metaClass.sex = '男'
// 给对象添加方法
p.metaClass.drink = {
-> println "喜欢喝饮料"
}
// 给对象添加静态方法
p.metaClass.static.play = {
-> println "喜欢玩游戏"
}
println "${p.name}，今年${p.age}岁了，性別是${p.sex}"
p.drink()
p.play()
// 结果
阳仔like eat
阳仔，今年18岁了，性別是男
喜欢喝饮料
喜欢玩游戏强制类型检查
在之前的咱们的学习过程中发现，Groovy都是弱类型检查，不管是变量还是集合都可以接收任何类型的数据，如果我们想要在某些场景中限制某种类型就要用到@TypeChecked注解尽兴强制类型检查。在闭包中，如果需要强类型检查，可以像java语法一样定义参数类型。
class Foos{
int i = 42.0; //编译通过
}
@TypeChecked
class Foo{
int i = 42.0; //编译不通过
}
//在闭包中，如果需要强类型检查，可以像java语法一样定义参数类型
def list = ["a","b","c"]
// 编译不通过
//def list = ["a","b","c", 1]
list.collect {
String it -> it.toUpperCase()
}
println(list)Elvis Operator
Groovy中采用Elvis Operator 运算，进一步简化三元运算符。
def a = null;
// 在定义b变量时，先判断a是否有值，如果有，就取a的值作为b的值，否则就取值"b"
def b = a ?: "b";
println(b)安全访问
跟我们Java中判空一样，只不过更加简洁而已。
def person;
//先判断person是否为不为null,然后，再调用getName方法
String name = person?.getName();
println(name)
