Refer to
http://www.ibm.com/developerworks/cn/education/java/j-groovy/j-groovy.html

使用 Groovy 的简单语法开发 Java 应用程序

开始之前

关于本教程

Groovy 并没有取代 Java，而是作为 Java 的补充，它提供了更简单、更灵活的语法，可以在运行时动态地进行类型检查。
您可以使用 Groovy 随意编写 Java 应用程序，连接 Java 模块，甚至扩展现有的 Java 应用程序 — 甚至可以用 Groovy 对 Java 代码进行单元测试。
Groovy 的美妙之处还在于，它能够比编写纯粹的 Java 代码更快地完成所有工作 — 有时候会快许多。

Groovy 是一门动态语言，它能够像 Java 语言本身一样很好地应用于 Java 平台

学习目标

Groovy 集合、Groovy 类， Groovy 的语法

系统需求

Sun 的 JDK 1.5.0_09（或更新版本）或
IBM developer kit for Java technology 1.5.0 SR3

Eclipse IDE 可以安装 Groovy Eclipse 插件

推荐系统的配置
- 支持 Sun JDK 1.5.0_09 或 IBM JDK 1.5.0 SR3 的系统， 至少 500 MB 主内存
- 至少 20 MB 可用硬盘空间

本教程的操作说明和示例均基于 Microsoft Windows 操作系统

---

关于 Groovy

什么是 Groovy？

Groovy 是 JVM 的一个替代语言 – 可以用 Groovy 在 Java 平台上进行 Java 编程，使用方式基本与使用 Java 代码的方式相同。在编写新应用程序时，Groovy 代码能够与 Java 代码很好地结合，也能用于扩展现有代码。

Groovy 的一个好处是，它的语法与 Java 语言的语法很相似。虽然 Groovy 的语法源于 Smalltalk 和 Ruby 这类语言的理念，但是可以将它想像成 Java 语言的一种更加简单、表达能力更强的变体。

Groovy 和 Java 语言的主要区别是：完成同样的任务所需的 Groovy 代码比 Java 代码更少。

Groovy 快捷方式

• Groovy 的松散的 Java 语法允许省略分号和修改符。
• 除非另行指定，Groovy 的所有内容都为 public。
• Groovy 允许定义简单脚本，同时无需定义正规的 class 对象。
• Groovy 在普通的常用 Java 对象上增加了一些独特的方法和快捷方式，使得它们更容易使用。
• Groovy 语法还允许省略变量类型。

Groovy 的新增特性

虽然 Groovy 允许省略 Java 语法中的一些元素，但也增加了一些新特性，例如本地集合、内置的正则表达式和闭包。
在标准的 Java 代码中，如果想要创建一个项列表，首先要导入 java.util.ArrayList，然后程序化地初始化 ArrayList 实例，然后 再向实例中添加项。在 Groovy 中，列表和映射都内置在语法中 — 无需导入任何内容。正则表达式也不需要额外的导入或对象；它们可以通过特殊的 Groovy 语法来创建。

关于闭包

闭包是一个令人兴奋的新技巧。这些神奇的构造将会包含在未来的 Java 发行版成为正式的 Java 语法。
可以将闭包 想像为一个代码块，可以现在定义，以后再执行。可以使用这些强大的构造做许多事，不过最著名的是简化迭代。使用 Groovy 之后，就有可能再也不需要编写 Iterator 实例了。

动态的 Groovy

从技术上讲，Groovy 可能是类型最松散的动态语言之一。从这个角度讲，Groovy 与 Java 语言的区别很大，Java 语言是一种固定类型语言。在 Groovy 中，类型是可选的，所以您不必输入 String myStr = “Hello”; 来声明 String 变量。

除此之外，Groovy 代码还能在运行时轻松地改变自己。这实际上意味着，能够在运行时轻松地为对象指定新方法和属性。这一编程领域称为元编程，Groovy 能够很好地支持这种编程方式。
要补充的是，在 Groovy 会使操作 XML 或普通的 java.io.File 实例变得非常轻松。

一体两面

用 Groovy 编写的任何内容都可以编译成标准的 Java 类文件并在 Java 代码中重用。类似地，用标准 Java 代码编写的内容也可以在 Groovy 中重用。所以，可以轻易地使用 Groovy 为 Java 代码编写单元测试。而且，如果用 Groovy 编写一个方便的小工具，那么也可以在 Java 程序中使用这个小工具。

---

Groovy 初探

为什么要学习 Groovy？

Groovy 是一种更有生产力 的语言。它具有松散的语法和一些特殊功能，能够加快编码速度。

只用一个示例即可说明问题：一旦发现使用 Groovy 在集合中导航的容易程度，您就再也不会用 Java 处理集合导航了。
在较高层面上，如果能更快地将代码交付给利益相关者，那么就能在更短的时间内交给他们更多发行版。实际上，Groovy 比 Java 更有助于敏捷开发。

入门非常容易

将 Groovy 集成到开发环境很容易。无需安装新的运行时工具或专门的 IDE。实际上，只需将 Groovy 的一个 jar 文件放在类路径中即可。

而且，Groovy 是一种开源语言，由 Java 开发人员社区管理。因为 Groovy 获得 Apache Software License,Version 2.0，所以可以自由地使用它开发自由软件和私有软件。

Groovy 和 Java 语言对比

用 Java 编写的 Hello World

public class HelloWorld {
  public static void main(String[] args) {  
    System.out.println("Hello World!");
  }
}

编译和运行 Java 示例

c:>javac HelloWorld.java

运行经过编译的类

c:>java HelloWorld

用 Groovy 编写的 Hello World

Groovy 支持松散的 Java 语法 – 不需要为打印 “Hello World!” 这样的简单操作定义类。

Groovy 使日常的编码活动变得更容易，e.g. Groovy 允许输入 println，而无需输入 System.out.println。当您输入 println 时，Groovy 会非常聪明地知道您指的是 System.out。

用 Groovy 编写 Hello World 程序

println "Hello World!"

注意，在这段代码周围没有类结构，而且也没有方法结构！使用 println 代替了 System.out.println。

运行 Groovy 示例
假设代码保存在文件 MyFirstExample.groovy 内，只要输入以下代码就能运行这个示例：

c:>groovy MyFirstExample.groovy

c:>groovy MyFirstExample.groovy

快捷方式应用

不必编译 .groovy 文件。这是因为 Groovy 属于脚本语言。脚本语言的一个特点就是能够在运行时进行解释。（在 Java 中，要从源代码编译生成字节码，然后才能进行解释。区别在于脚本语言能够直接 解释源代码。）

Groovy 允许完全省略编译步骤，不过仍然可以 进行编译。如果想要编译代码，可以使用 Groovy 编译器 groovyc。用 groovyc 编译 Groovy 代码会产生标准的 Java 字节码，然后可以通过 java 命令运行生成的字节码。
这是 Groovy 的一项经常被忽略的关键特性：用 Groovy 编写的所有代码都能够通过标准 Java 运行时编译和运行。

至于运行代码，如果希望更加简洁，还能输入

c:>groovy -e “println ‘Hello World!’”

无需定义任何文件

---

Groovy 入门

轻松安装 Groovy

需要做的全部工作就是安装 Eclipse 的 Groovy 插件;
Help 菜单中选择 Software Updates > Find and Install…

在选项中导航
Search for new features to install > Next > New Remote Site…
输入 “Groovy plugin” 作为名称，输入 “http://dist.codehaus.org/groovy/distributions/update/” 作为位置 > OK;
在随后出现的 Sites to include in search 框中确保选中了名为 “Groovy plugin” 的项目 — 现在的列表

完成安装
Search Results 对话框 > 确定选中了 “Groovy plugin” 框并单击 Next

可能需要重新启动 Eclipse;

创建 Groovy 项目

请确保创建两个源文件夹 — 一个称为 “groovy”，另一个称为 “java”。编写的 Groovy 代码放在 groovy 文件夹，Java 代码放在 java 文件夹。将二者分开将会很有用;

将 Groovy 导入项目
右键项目->Groovy选项->Add Groovy Nature->将必要的 Groovy库,编译器和运行程序导入项目;

创建 Groovy 类
选择 groovy文件夹右键->New->Other

给类命名
groovy文件夹->Groovy Class->Next->输入类名 e.g. HelloWorld;
现在可以将 HelloWorld Groovy 类保留在默认包内

Hello World! — 用 Groovy 编写的 Java 程序

class HelloWorld {
 static void main(args) {

 }
}

它不包含 public 修改符,没有类型;

编译程序

在 main 方法内加入 println “Hello World”

class HelloWorld {
 static void main(args) {
   println "Hello World"    
 }
}

右键->Compile Groovy File

运行程序
右键文件-> Run As -> Groovy;

学到了什么？
Groovy 实际上就是 Java。其语法不同 — 多数情况下会短一些 — 但 Groovy 代码 100％ 符合 Java 字节码标准。

---

Groovy 变身为 Java

Hello,Java!

为了确信 Groovy 就是 Java，现在在 HelloWorld 类声明和方法声明前面加上 public 修改符

public class HelloWorld {
 public static void main(args) {
  println "Hello World"
 }
}

还不确信？
这个代码运行起来同前面的代码完全一样; 还可以在 args 参数前加上 String[];

public class HelloWorld {
 public static void main(String[]args) {
  println "Hello World"
 }
}

现在还没完
还可以将 println 替换为 System.out.println,不要忘记加上括号

public class HelloWorld {
 public static void main(String[] args) {
  System.out.println("Hello World")
  }
}

现在的代码与前面用 Java 编写的 Hello World 示例完全相同,groovy更容易编写;

注意,原来的基于 Groovy 的 HelloWorld 类没有任何 public 修改符，没有任何类型（没有 String[]），而且提供了没有括号的 println 快捷方式。

Hello,Groovy!

如果喜欢，可以将这个过程完全翻转过来，回到基于 Java 的 Hello World 示例，删除文件里的所有内容，只保留 System.out 行，然后在这行删除 System.out 和括号。最后只剩下

println "Hello World"

运行程序！
Groovy 代码完全符合 Java 字节码标准; 在 Eclipse 中，选择 Run -> Open Run Dialog; 选择一个新的 Java Application 配置。确保项目是 Groovy 项目。
对于 Main 类，Search -> 找到 HelloWorld 类。注意，单词 class 表明 Eclipse Groovy 插件已经将 .groovy 文件编译为 .class 文件。
->Run

---

Groovy 是没有类型的 Java 代码

为什么要有类型定义？

在 Java 中，如果要声明一个 String 变量

String value = "Hello World";

但是,等号右侧的字符已经表明 value 的类型是 String。所以，Groovy 允许省略 value 前面的 String 类型变量，并用 def 代替。

def value = "Hello World"

Groovy 会根据对象的值来判断它的类型

运行程序！
将 HelloWorld.groovy 文件中的代码编辑成下面这样:

String message = "Hello World"
println message

运行代码，会在控制台上看到与前面一样的 “Hello World”。
现在，将变量类型 String 替换为 def 并重新运行代码–相同的结果.

除了输出 message 的值，还可以用以下调用输出它的类型:

def message = "Hello World"
println message.class

输出 “class java.lang.String”：Groovy 推断出 message 一定是 String 类型的，因为它的值是用双引号括起来的。

类型推断的更多内容

在 Groovy 中 “一切都是对象” – 但对于类型来说这句话意味着什么呢？
看看如果将前面示例中的 String 替换为数字会怎么样:

def message = 12
println message.class

message 变量的数字值看起来像是 Java 的原生类型 int。但是运行代码就可看出，Groovy 将它作为 Integer。这是因为在 Groovy 中 “一切都是对象”;

Java 中的所有对象都扩展自 java.lang.Object，这对 Groovy 来说非常方便。即使在最糟的情况下，Groovy 运行时不能确定变量的类型，它只需将变量当成 Object，问题就解决了。
继续使用这段代码。将 message 改成任意类型：Groovy 会在运行时尽其所能推断出这个变量的类型。

无类型有什么意义

那么，Groovy 缺少类型意味着所需的输入更少。不可否认，将 String 替换成 def 并没有真正节约多少打字工作; 但是在更高的层次上看，在编写大量不仅仅包含变量声明的代码的时候，没有类型确实减少了许多打字工作。
更重要的是，这意味着要阅读的代码要少得多。最后，Groovy 缺少类型能够带来更高的灵活性 — 不需要接口或抽象类。

所以，只需要使用 def 关键字就能在方法中声明一个独立变量，不需要将 def 关键字作为方法声明中的参数。在 for 循环声明中也不需要它，这意味着不用编写 (int x = 0; x < 5; x++)，相反，可以省略 int，保留空白。

---

—TBC— —YCR—