Groovy 学习手册（1）

1. 需要安装的软件

Java / Groovy

对应 Java 和 Groovy，你需要安装以下软件：

• Java JDK，例如 JDK 8
• IDE，例如 Eclipse，NetBeans 8
• Groovy

下载以后，安装即可。接下来需要配置 Java_Home 和 Groovy_Home环境变量。如下（以 Mac为例）：

1. 在你的用户根目录下，使用命令ls -a 找到.bash_profile文件，注意，它是一个隐藏文件，而且对它的修改只对当前用户生效。
2. 使用 vi 命令， vi .bash_profile 打开此文件，并进入编辑状态，
   
3. 修改完成保存退出，在命令行窗口执行使修改生效：
   . .bash_profile
4. 测试 JDK 是否配置正确。在命令行中输入java -version，回车，出现以下信息：
   
5. 测试 Groovy 是否配置正确。在命令行中输入groovyConsole并回车，

至此，开发环境已经完成。

2. Groovy 是什么？

Groovy 是基于Java虚拟机的一种敏捷的动态语言，它是一种成熟的面向对象编程语言，既可以用于面向对象编程，又可以用作纯粹的脚本语言。支持闭包，多重继承，元编程等很多特性。

紧凑的语法

Groovy 的语法比 Java 语法更加紧凑简洁，例如下面的例子，分别用 Java 和 Groovy 来实现。
Java 版本：

for (String it : new String[] { "Rod", "Carlos", "Chris" }) {
        if (it.length() < 4) {
        System.out.println(it); // print Rod
        }
    }

Groovy 版本：

["Rod", "Carlos", "Chris"].findAll{it.size() < 4}.each{println it} 

动态定义

Groovy 一个重要的特性就是可以使用 def 关键字来定义动态类型，你可以用 def 来定义任何类型的变量。

List 和 Map 的定义

在 Groovy 中 List 和 Map 的定义和使用更加简洁和简单，只需使用 [] 即可，Map 中的键值对使用“:” 来表示。

def list = [1, 2]
def map = [cars: 2, boats: 3]
println list.getClass()
println map.getClass()

默认情况下，Map 的 key 如果不带引号的话，默认就是字符串类型，这样用起来就非常方便：

map.cars = 20
map.botst = 30
map.planes = 50
print map.cars

在 Groovy 里甚至可以重载了“<<”运算符，用来向 list 中添加元素：

list.add("Hello")
list << "World"
list += "!"
println list

Groovy GDK

内置的 Groovy 类型（GDK）很多地方跟 Java 是很相像的，但是 GDK为每个类增加了很多方法。
使用 each 方法来迭代集合里的元素：
["Java", "Groovy", "Scala"].each{ println it }
这里的println是System.out的简写。

万物皆对象

跟Java 不一样，基本类型的变量在 Groovy 里面也会被当做一个对象来对待，跟其他的对象没有区别。例如，下面的例子，打印100次"hi"字符串：
100.times{print "hi"}

属性的快速访问

Groovy 对 Java Bean 的操作有了新的想法，你可以使用"." 对其属性进行操作来代替繁琐的 getter 和 setter 操作。
例如,

// Java style
person.setName("Jim")
person.getName()
// Groovy style
person.name = "Jim"
Person.name

Tip
这里需要注意的是，Groovy 的默认的访问修饰符为 public。

当然，你还可以使用println person.properties来打印对象的所有属性。太贴心了。

GString 类型

Groovy 自己新增了此类型，目的用来在字符串里嵌入 Groovy 本身的代码。GString每次使用时要有双引号来创建。

def os = 'Linux'
def cores = 2
println("Cores: $cores, OS: $os, Time: ${new Date()}")

这里的(可以直接引用一个变量，而){code}则可以直接在 GString 类型里写 Groovy 代码。

Tip
如果你想使用java.lang.String，则使用单引号(''）。

闭包

在 Groovy 里面，闭包就是一个代码块，它即可以有参数，有返回值，当当然，也可以没有。其实，它就像 Java8 里的 Lambda 表达式，或者是内部类的一个方法。闭包在有很多有用的方式，例如用在findAll方法中，each方法中，times方法中。
Groovy 闭包里有些隐性的变量：

1. it——如果闭包里有参数，则 it 就隐形地指向这个参数；
2. this——指向被包含的类；
3. owner——如果闭包里没有包含另外的闭包的话，跟 this 是一样的；
4. delegate——通常情况下，跟 owner 是一样的，但是你可以修改它。

闭包可以作为方法的参数来传递，当 this 已经完成（它是最后一个参数），闭包就会从括号里走出来，例如，当你使用“collect”方法时，这个方法用来在闭包里把一个List 转换成一个新的 List，看下面的例子：

def alist = ['foo', 'bar']
def newList = []
alist.collect(newList) {it.toUpperCase()}
println newList //  ["FOO",    "BAR"]

Tip
return 关键字在 Groovy 里完全是可选的，一个方法或闭包会返回最后一个表达式的类型，你也可以把闭包赋给一个变量，在稍后调用。

def closr = {x -> x + 1}
println( closr(2) ) // prints 3

更加好用的 switch 语句

Groovy 里的 switch 语句用法与 Java 里基本一样，但是它允许更多了的类型，例如，除了字符串，还可以是 List，一个范围区间，一个Class 类型。

  def x = 42
  switch  ( x ) {
  case "foo":
      result = "found foo"
          break
  case [4, 5, 6]:
       result = "4 5 or 6"
       break
   case 12..30: // Range
       result = "12 to 30"
       break
   case Integer:
       result = "was integer"
       break
   case Number:
       result = "was number"
       break
   default:
       result = "default"
   }

元编程

在 Groovy 中，你可以为正在运行中的对象添加方法，甚至是 Java 核心库里的对象。例如，下面的代码给String 类添加了 upper 方法。

String.metaClass.upper = { -> toUpperCase() }

或者对一个实例添加 upper 方法：

def str = "test"
str.metaClass.upper = { -> toUpperCase() }

静态类型检查

如果你在类里使用 @TypeChecked注解，则编译器就会强制在运行期间做类型检查，它能为你推理出对应的类型，所以你的代码依旧是 Grooby 的代码。

import   groovy.transform.*
@TypeChecked
class Foo {
    int i = 42.0 // this does not compile
}
import   groovy.transform.*
@TypeChecked
class Foo {
    int i = 42 // this works fine
}
new Foo()

Tip
静态类型检查不适用于元编程；
在闭包中要显式指定参数类型：a.collect {String it -> it.toUpperCase()}

如果在类中使用@CompileStatic注解，编译器就会把 Groovy 代码编译为字节码，当在极度强调性能和需要 Java字节码为了别的原因的话，会有用。同时生成的字节码与 Java编译产生的字节码几乎一致。

import   groovy.transform.*
@CompileStatic
class Foo {
   void getFibs(int count) {
      def list = [0, 1] // print first #count Fibonacci numbers
      count.times {
         print "${list.last()}"
         list << list.sum()
         list = list.tail()
      }
   }
}

Tip
@TypeChecke 与def 关键字能很好地在一起工作。

Elvis 运算符

这个运算符产生在 Java 的日常使用中，为变量提供一个默认值，而不像Java 那样繁琐。

String name = person.getName() == null ? "Bob" : person.getName();
// Instead in Groovy you can just use the elvis operator:
String name = person.getName() ?: "Bob"

安全解引用操作符

此操作符用来避免发生空指针异常的情况，只需要在语句里面添加一个问号（？）即可，看例子。

String name = person?.getName()

当 person 为 null 时，对应的name 属性也设置为 Null。同样，对方法调用也同样适用。