Groovy概述
Groovy是Apache 旗下的一种基于JVM的面向对象编程语言，既可以用于面向对象编程，也可以用作纯粹的脚本语言。在语言的设计上它吸纳了Python、Ruby 和 Smalltalk 语言的优秀特性，比如动态类型转换、闭包和元编程支持。
Groovy与 Java可以很好的互相调用并结合编程 ，比如在写 Groovy 的时候忘记了语法可以直接按Java的语法继续写，也可以在 Java 中调用 Groovy 脚本。比起Java，Groovy语法更加的灵活和简洁，可以用更少的代码来实现Java实现的同样功能。
1.变量
Groovy中用def关键字来定义变量，可以不指定变量的类型，默认访问修饰符是public。
task variable <<{
def a=10
def float b=10.5f
def c="Haha"
println(a)
println(b)
println(c)
}
2.方法
方法使用返回类型或def关键字定义，方法可以接收任意数量的参数，这些参数可以不申明类型，如果不提供可见性修饰符，则该方法为public。
（1）用def关键字来定义方法
task method << {
def result1=add(2,4)
def result2=sub(4,2)
println "result1:"+result1+",result2:"+result2
printStr()
}
def add(int a,int b)
{
return a+b
}
def sub(a,b)
{
return a-b
}
def printStr()
{
println "Print Something"
}
（2）如果指定了方法返回类型，可以不需要def关键字来定义方法。
task method << {
def result1=add(2,4)
def result2=sub 4,2
println "result1:"+result1+",result2:"+result2
}
int add(int a,int b)
{
return a+b
}
int sub(a,b)
{
return a-b
}
（3）如果不使用return ，方法的返回值为最后一行代码的执行结果。
task method << {
def result1=add(2,4)
def result2=sub 4,2
println "result1:"+result1+",result2:"+result2
}
int add(int a,int b)
{
a+b
}
int sub(a,b)
{
a-b
}
从上面的几段代码可以看出，Groovy代码可以省略的地方有如下几处：
1.语句后面的分号可以省略。
2.方法的括号可以省略，比如注释1和注释3处。
3.参数类型可以省略，比如注释2处。
4.return可以省略掉，比如注释4处。
3.类
Groovy类非常类似于Java类。
task testClass << {
def p=new Person()
p.increaseAge 10
println "Age:"+p.age
}
class Person{
String name
Integer age=10
def increaseAge(Integer years)
{
this.age+=years
}
}
Groovy类与Java类有以下的区别：
默认类的修饰符为public。
没有可见性修饰符的字段会自动生成对应的setter和getter方法。
类不需要与它的源文件有相同的名称，但还是建议采用相同的名称。
4.语句
（1）断言
Groovy断言和Java断言不同，它一直处于开启状态，是进行单元测试的首选方式。
task testAssert << {
assert 1+2==6
}
运行结果：
当断言的条件为false时，程序会抛出异常，不再执行下面的代码，从输出可以很清晰的看到发生错误的地方。
（2）for循环
Groovy支持Java的for(int i=0;i<N;i++)和for(int i :array)形式的循环语句，另外还支持for in loop形式，支持遍历范围、列表、Map、数组和字符串等多种类型。
task testFor << {
//遍历范围
def x=0
for(i in 0..3)
{
x+=i
}
assert x==6
//遍历列表
x=0
for(i in [0,1,2,3])
{
x+=i
}
assert x==6
//遍历Map中的值
def map=['a':1,'b':2,'c':3]
x=0
for(v in map.values())
{
x+=v
}
assert x==6
}
（3）Switch语句
Groovy中的Switch语句不仅兼容Java代码，还可以处理更多类型的case表达式。
task testSwitch << {
def x=16
def result=""
switch(x)
{
case "ok":
result="found ok"
break
case [1,2,3,'List']:
result="list"
break
case 10..19:
result="range"
break
case Integer:
result="integer"
break
default:
result="default"
break
}
assert result=="integer"
}
case表达式可以是字符串、列表、范围、Integer等等，因为篇幅原因，这里只列出了一小部分。
5.数据类型
Groovy中的数据类型主要有以下几种：
Java中的基本数据类型
Groovy中的容器类
闭包
（1） 字符串
Groovy中的基本数据类型和Java大同小异，这里主要介绍下字符串类型。在Groovy种有两种字符串类型，普通字符串String（java.lang.String）和插值字符串GString（groovy.lang.GString）。
单引号字符串
在Groovy中单引号字符串和双引号字符串都可以定义一个字符串常量，只不过单引号字符串不支持插值。
'Android进阶解密'
双引号字符串
要想插值可以使用双引号字符串，插值指的是替换字符串中的占位符，占位符表达式为为前缀。
def name = 'Android进阶之光'
println "hello ${name}"
println "hello $name"
三引号字符串
三引号字符串可以保留文本的换行和缩进格式，不支持插值.
task method <<{
def name = '''Android进阶之光
Android进阶解密
Android进阶？'''
println name
}
打印结果为：
Android进阶之光
Android进阶解密
Android进阶？
GString
String是不可变的，GString却是可变的，GString和String即使有相同的字面量，它们的hashCodes的值也可能不同，因此应该避免使用使用GString作为Map的key。
assert "one: ${1}".hashCode() != "one: 1".hashCode()
当双引号字符串中包含插值表达式时，字符串类型为GString，因此上面的断言为true。
（2）List
Groovy没有定义自己的集合类，它在Java集合类的基础上进行了增强和简化。Groovy的List对应Java中的List接口，默认的实现类为Java中的ArrayList。
def number = [1, 2, 3]
assert number instanceof List
def linkedList = [1, 2, 3] as LinkedList
assert linkedList instanceof java.util.LinkedList
可以使用as操作符来显式指定List的实现类为java.util.LinkedList。
获取元素同样要比Java要简洁些，使用[]来获取List中具有正索引或负索引的元素。
task method <<{
def number = [1, 2, 3, 4]
assert number [1] == 2
assert number [-1] == 4 //1
number << 5 //2
assert number [4] == 5
assert number [-1] == 5
}
注释1处的索引-1是列表末尾的第一个元素。注释2处使用<<运算符在列表末尾追加一个元素。
（3） Map
创建Map同样使用[]，需要同时指定键和值，默认的实现类为java.util.LinkedHashMap。
def name = [one: '魏无羡', two: '杨影枫', three: '张无忌']
assert name['one'] == '魏无羡'
assert name.two == '杨影枫'
Map还有一个键关联的问题：
def key = 'name'
def person = [key: '魏无羡'] //1
assert person.containsKey('key')
person = [(key): '魏无羡'] //2
assert person.containsKey('name')
注释1处魏无羡的键值是key这个字符串，而不是key变量的值 name。如果想要以key变量的值为键值，需要像注释2处一样使用(key)，用来告诉解析器我们传递的是一个变量，而不是定义一个字符串键值。
（4）闭包
Groovy中的闭包是一个开放的、匿名的、可以接受参数和返回值的代码块。
定义闭包
闭包的定义遵循以下语法：
{ [closureParameters -> ] statements }
闭包分为两个部分，分别是参数列表部分[closureParameters -> ]和语句部分 statements 。
参数列表部分是可选的，如果闭包只有一个参数，参数名是可选的，Groovy会隐式指定it作为参数名，如下所示。
{ println it } //使用隐式参数it的闭包
当需要指定参数列表时，需要->将参数列表和闭包体相分离。
{ it -> println it } //it是一个显示参数
{ String a, String b ->
println "${a} is a ${b}"
}
闭包是groovy.lang.Cloush类的一个实例，这使得闭包可以赋值给变量或字段，如下所示。
//将闭包赋值给一个变量
def println ={ it -> println it }
assert println instanceof Closure
//将闭包赋值给Closure类型变量
Closure do= { println 'do!' }
调用闭包
闭包既可以当做方法来调用，也可以显示调用call方法。
def code = { 123 }
assert code() == 123 //闭包当做方法调用
assert code.call() == 123 //显示调用call方法
def isOddNumber = { int i -> i%2 != 0 }
assert isOddNumber(3) == true //调用带参数的闭包
6.I/O操作
Groovy的 I/O 操作要比Java的更为的简洁。
（1）文件读取
可以先建立一个txt文件，在其中输入一些内容，然后用来读取。
task testReadFile << {
def filePath="E:/test.txt"
def file=new File(filePath)
file.eachLine{
println it
}
}
可以看出Groovy的文件读取是很简洁的，还可以更简洁些：
def filePath = "D:/Android/name.txt"
def file = new File(filePath) ;
println file.text
（2）文件写入
文件写入也是比较简洁的。
task testWriteFile << {
def fileName="E:/test.txt"
def file=new File(fileName)
file.withPrintWriter{
it.println("Kobe")
it.println("James")
}
}
7.其他
（1）asType
asType用于类型转换。
task testAsType << {
String a='23'
int b=a as int
def c=a.asType(Integer)
assert c instanceof java.lang.Integer
}
（2）判断是否为真
if (name != null && name.length > 0) {}
替换为
if (name) {}
（3）安全取值
在Java中，要安全获取某个对象的值可能需要大量的if语句来判空：
if (school != null) {
if (school.getStudent() != null) {
if (school.getStudent().getName() != null) {
System.out.println(school.getStudent().getName());
}
}
}
Groovy中可以使用？.来安全的取值：
println school?.student?.name
（4）with操作符
对同一个对象的属性进行赋值时，可以这么做：
task method <<{
Person p = new Person()
p.name = "杨影枫"
p.age = 19
p.sex = "男"
println p.name
}
class Person {
String name
Integer age
String sex
}
使用with来进行简化：
Person p = new Person()
p.with {
name = "杨影枫"
age= 19
sex= "男"
}
println p.name
