Groovy入门教程

Groovy入门教程

原帖地址：http://blog.csdn.net/kmyhy/archive/2009/05/19/4200563.aspx

 

Groovy 入门教程

一、 groovy 是什么

简单地说， Groovy 是下一代的 java 语言，跟 java 一样 , 它也运行在 JVM 中。

作为跑在 JVM 中的另一种语言， groovy 语法与 Java 语言的语法很相似。同时， Groovy 抛弃了 java 烦琐的文法。同样的语句，使用 groovy 能在最大限度上减少你的击键次数——这确实是“懒惰程序员们”的福音。

 

二、 开发环境

1、   jdk 1.5 以上

2、   eclipse+groovy plugin （支持 Groovy 1.5.7 ）

打开 eclipse ，通过 Software Updates > Find and Install... 菜单，使用“ Search for new features to install ” 下载并安装groovy 插件。 New 一个 远程站点 ， url 可使用 http://dist.codehaus.org/groovy/distributions/update/ ， 插件名 ： Groovy plug-in 。根据需要你可以同时选择 groovy 和 grails （后续会学习到）：

 

 

三、 创建 groovy 项目

1、   新建一个 groovy 项目

New --> Project à Java Project 创建一个 java 项目。为了方便管理，建议在 source 中建两个 source 文件夹 java 和 groovy，分别用于存储 java 源文件和 groovy 源文件：

 

2、   添加 Groovy 特性

在项目上右击， Groovy à Add Groovy Nature ，这样会在项目中添加 Groovy Libraries 。

 

3、   添加 Groovy 类

在项目 groovy 源文件下右键， New à Other à Groovy à Groovy Class

 

自动生成的源代码如下：

public class HelloWorld{

    /**

      * @param args

      */

    public static void main( def args){

       // TODO Auto-generated method stub

    }  

}

我们在 main 方法中加一句打印语句：

println "Hello World"

4、   编译运行 groovy 类

在源文件上右键， Compile Groovy File ，然后右键， Run As à Groovy ，在控制台中查看运行结果。

实际上 groovy 语法的简练还体现在，就算整个文件中只有 println "Hello World" 这一句代码（把除这一句以外的语句删除掉吧），程序也照样能够运行。

当然，为了说明 groovy 其实就是 java ，你也可以完全按照 java 语法来编写 HelloWorld 类。 

四、 Groovy 语法简介

1、   没有类型的 java

作为动态语言， groovy 中所有的变量都是对象 ( 类似于 .net framework ，所有对象继承自 java.lang.Object) ，在声明一个变量时， groovy 不要求强制类型声明，仅仅要求变量名前使用关键字 def （从 groovy jsr 1 开始，在以前的版本中，甚至连 def 都不需要）。

修改 main 方法中的代码：

def var= "hello world"

println var

println var.class

你可以看到程序最后输出了 var 的实际类型为： java.lang.String

作为例外，方法参数和循环变量的声明不需要 def 。

2、   不需要的 public

你可以把 main 方法前面的 public 去掉 ， 实际上 ， groovy 中默认的修饰符就是 public ， 所以 public 修饰符你根本就不需要写，这点跟 java 不一样。

3、   不需要的语句结束符

Groovy 中没有语句结束符，当然为了与 java 保持一致性，你也可以使用 ; 号作为语句结束符。在前面的每一句代码后面加上 ; 号结束，程序同样正常运行 ( 为了接受 java 程序员的顽固习惯 ) 。

4、   字符串连接符

跟 java 一样，如果你需要把一个字符串写在多行里，可以使用 + 号连接字符串。代码可以这样写：

       def var= "hello " +

       "world" +

       ",groovy!"

当然更 groovy 的写法是：

       def var= """hello

       world

       groovy! """

三个 ” 号之间不在需要 + 号进行连接（不过字符串中的格式符都会被保留，包括回车和 tab ）。

5、   一切皆对象

听起来象是“众生平等”的味道，事实上 groovy 对于对象是什么类型并不关心，一个变量的类型在运行中随时可以改变，一切根据需要而定。如果你赋给它 boolean ，那么不管它原来是什么类型，它接受 boolean 值之后就会自动把类型转变为 boolean 值。看下面的代码：

def var= "hello " +

       "world" +

       ",groovy!"

       println var;

       println var. class ;

       var= 1001

       println var. class

输出结果 ：

hello world,groovy!

class java.lang.String

class java.lang.Integer

 

var 这个变量在程序运行中 ， 类型在改变。一开始给它赋值 String ，它的类型就是 String ，后面给它赋值 Integer ，它又转变为 Integer 。

6、   循环

删除整个源文件内容，用以下代码替代：

       def var= "hello " +

       "world" +

       ",groovy!"

       def repeat(val){

             for (i = 0 ; i < 5 ; i++){

             println val

             }

       }

       repeat(var)

输出：

hello world,groovy!

hello world,groovy!

hello world,groovy!

hello world,groovy!

hello world,groovy!

注意循环变量 i 前面没有 def 。当然也没有 java 中常见的 int ，但如果你非要加上 int 也不会有错，因为从 Groovy1.1beta2之后开始（不包括 1.1beta2 ）， groovy 开始支持 java 经典的 for 循环写法。

此外，上面的 for 语句还可以写成：

             for (i in 0 .. 5 )

这样的结果是一样的。       

7、   String 和 Gstring

除了标准的 java.lang.String 以外（用 ’ 号括住）， groovy 还支持 Gstring 字符串类型（用 “ 号括住）。把上面的 for 循环中的语句改成：

             println "This is ${i}:${val}"

运行一下，你就会明白什么是 Gstring 。

8、   范围

这个跟 pascal 中的“子界”是一样的。在前面的 for 循环介绍中我们已经使用过的 for (i in 0 .. 5 ) 这样的用法，其中的 0 .. 5 就是一个范围。

范围 是一系列的值。例如 “ 0..4 ” 表明包含 整数 0 、 1 、 2 、 3 、 4 。 Groovy 还支持排除范围，“ 0..<4 ” 表示 0 、1 、 2 、 3 。还可以创建字符范围：“ a..e ” 相当于 a 、 b 、 c 、 d 、 e 。“ a..<e ” 包括小于 e 的所有值。

范围主要在 for 循环中使用。

9、   默认参数值

可以为方法指定默认参数值。我们修改 repeat 方法的定义：

def repeat(val,repeat= 3 ){

             for (i in 0 ..<repeat){

             println "This is ${i}:${val}"

             }

       }

可以看到， repeat 方法增加了一个参数 repeat （并且给了一个默认值 3 ），用于指定循环次数。

当我们不指定第 2 个参数调用 repeat 方法时， repeat 参数取默认值 3 。

10、               集合

Groovy 支持最常见的两个 java 集合： java.util.Collection 和 java.util.Map 。前面所说的范围实际也是集合的一种（java.util.List ）。

(1) Collection

Groovy 中这样来定义一个 Collection ：

def collect =[ "a" , "b" , "c" ]

除了声明时往集合中添加元素外，还可以用以下方式向集合中添加元素：

collect .add( 1 );

       collect << "come on" ;

       collect [ collect . size() ]= 100 . 0

Collection 使用类似数组下标的方式进行检索：

       println collect [ collect . size ()- 1 ]

       println collect [ 5 ]

groovy 支持负索引：

println collect [- 1 ]      // 索引其倒数第 1 个元素

       println collect [- 2 ]      // 索引其倒数第 2 个元素

Collection 支持集合运算：

collect = collect + 5         // 在集合中添加元素 5

       println collect [ collect . size ()- 1 ]

       collect = collect - 'a'          // 在集合中减去元素 a( 第 1 个 )

       println collect [ 0 ]          // 现在第 1 个元素变成 b 了

同样地，你可以往集合中添加另一个集合或删除一个集合：

       collect = collect - collect [ 0 .. 4 ]   // 把集合中的前 5 个元素去掉

       println collect [ 0 ]   // 现在集合中仅有一个元素，即原来的最后一个元素

       println collect [- 1 ]  // 也可以用负索引，证明最后一个元素就是第一个元素

(2) Map

Map 是“键 - 值”对的集合，在 groovy 中，键不一定是 String ，可以是任何对象 ( 实际上 Groovy 中的 Map 就是java.util. Linke dHashMap ) 。

如此可以定义一个 Map:

       def map=[ 'name' : 'john' , 'age' : 14 , 'sex' : 'boy' ]

添加项：

       map=map+[ 'weight' : 25 ]       // 添加 john 的体重

       map.put( 'length' , 1 . 27 )      // 添加 john 的身高

       map.father= 'Keller'          // 添加 john 的父亲

可以用两种方式检索值：

       println map[ 'father' ]       // 通过 key 作为下标索引

       println map.length          // 通过 key 作为成员名索引

11、               闭包（ Closure ）

闭包是用 { 符号括起来的代码块，它可以被单独运行或调用，也可以被命名。类似‘匿名类’或内联函数的概念。

闭包中最常见的应用是对集合进行迭代，下面定义了 3 个闭包对 map 进行了迭代：

       map. each ({key,value->    //key,value 两个参数用于接受每个元素的键 / 值

       println "$key:$value" })

       map. each { println it}     //it 是一个关键字，代表 map 集合的每个元素

       map. each ({ println it.getKey()+ "-->" +it.getValue()})

除了用于迭代之外，闭包也可以单独定义：

def say={word->

           println "Hi,$word!"

       }

调用：

say( 'groovy' )

       say. call ( 'groovy&grails' )

输出：

Hi,groovy!

Hi,groovy&grails!

 

看起来，闭包类似于方法，需要定义参数和要执行的语句，它也可以通过名称被调用。然而闭包对象（不要奇怪，闭包也是对象）可以作为参数传递（比如前面的闭包作为参数传递给了 map 的 each 方法）。而在 java 中，要做到这一点并不容易（也许 C++ 中的函数指针可以，但不要忘记 java 中没有指针）。其次，闭包也可以不命名（当然作为代价，只能在定义闭包时执行一次），而方法不可以。

12、               类

Groovy 类和 java 类一样，你完全可以用标准 java bean 的语法定义一个 groovy 类。但作为另一种语言，我们可以使用更groovy 的方式定义和使用类，这样的好处是，你可以少写一半以上的 javabean 代码：

(1)     不需要 public 修饰符

如前面所言， groovy 的默认访问修饰符就是 public ，如果你的 groovy 类成员需要 public 修饰，则你根本不用写它。

(2)     不需要类型说明

同样前面也说过， groovy 也不关心变量和方法参数的具体类型。

(3)     不需要 getter/setter 方法

不要奇怪，在很多 ide （如 eclipse ）早就可以为序员自动产生 getter/setter 方法了。在 groovy 中，则彻底不需要getter/setter 方法——所有类成员（如果是默认的 public ）根本不用通过 getter/setter 方法引用它们（当然，如果你一定要通过 get/set 方法访问成员属性， groovy 也提供了它们）。

(4)     不需要构造函数

不在需要程序员声明任何构造函数，因为 groovy 自动提供了足够你使用的构造函数。不用担心构造函数不够多，因为实际上只需要两个构造函数（ 1 个不带参数的默认构造函数， 1 个只带一个 map 参数的构造函数 — 由于是 map 类型，通过这个参数你可以在构造对象时任意初始化它的成员变量）。

(5)     不需要 return

Groovy 中，方法不需要 return 来返回值吗？这个似乎很难理解。看后面的代码吧。

因此， groovy 风格的类是这样的：

(6)     不需要 () 号

Groovy 中方法调用可以省略 () 号（构造函数除外），也就是说下面两句是等同的：

 

person1.setName 'kk'

person1.setName(
'kk')

下面看一个完整类定义的例子：

class Person {

  def name

  def age

  String toString(){ // 注意方法的类型 String ，因为我们要覆盖的方法为 String 类型

      "$name,$age"

  }

如果你使用 javabean 风格来做同样的事，起码代码量要增加 1 倍以上。

我们可以使用默认构造方法实例化 Person 类：

def person1= new Person()

person1.name= 'kk'

person1.age= 20

println person1

也可以用 groovy 的风格做同样的事：

def person2= new Person([ 'name' : 'gg' , 'age' : 22 ]) //[] 号可以省略

println person2

 

这样需要注意我们覆盖了 Object 的 toString 方法，因为我们想通过 println person1 这样的方法简单地打印对象的属性值。

然而 toString 方法中并没有 return 一个 String ，但不用担心， Groovy 默认返回方法的最后一行的值。

13、               ？运算符

在 java 中，有时候为了避免出现空指针异常，我们通常需要这样的技巧：

if(rs!=null){

       rs.next()

       … …

}

在 groovy 中，可以使用 ? 操作符达到同样的目的：

rs?.next()

? 在这里是一个条件运算符，如果 ? 前面的对象非 null ，执行后面的方法，否则什么也不做。

14、               可变参数

等同于 java 5 中的变长参数。首先我们定义一个变长参数的方法 sum ：

int sum( int ... var) {

def total = 0

for (i in var)

total += i

return total

}

我们可以在调用 sum 时使用任意个数的参数（ 1 个， 2 个， 3 个……）：

println sum( 1 )

println sum( 1 , 2 )

println sum( 1 , 2 , 3 )

15、               枚举

定义一个 enum ：

enum Day {

SUNDAY, MONDAY, TUESDAY, WEDNESDAY,

THURSDAY, FRIDAY, SATURDAY

}

然后我们在 switch 语句中使用他：

def today = Day.SATURDAY

switch (today) {

//Saturday or Sunday

case [Day.SATURDAY, Day.SUNDAY]:

println "Weekends are cool"

break

//a day between Monday and Friday

case Day.MONDAY..Day.FRIDAY:

println "Boring work day"

break

default :

println "Are you sure this is a valid day?"

}

注意， switch 和 case 中可以使用任何对象，尤其是可以在 case 中使用 List 和范围，从而使分支满足多个条件（这点跟delphi 有点象）。

同 java5 一样， groovy 支持带构造器、属性和方法的 enum ：

enum Planet {

MERCURY( 3 . 303 e+ 23 , 2 . 4397 e6),

VENUS( 4 . 869 e+ 24 , 6 . 0518 e6),

EARTH( 5 . 976 e+ 24 , 6 . 37814 e6),

MARS( 6 . 421 e+ 23 , 3 . 3972 e6),

JUPITER( 1 . 9 e+ 27 , 7 . 1492 e7),

SATURN( 5 . 688 e+ 26 , 6 . 0268 e7),

URANUS( 8 . 686 e+ 25 , 2 . 5559 e7),

NEPTUNE ( 1 . 024 e+ 26 , 2 . 4746 e7)

double mass

double radius

Planet( double mass, double radius) {

this .mass = mass;

this .radius = radius;

}

void printMe() {

println "${name()} has a mass of ${mass} " +

"and a radius of ${radius}"

}

}

Planet.EARTH.printMe()

16、               Elvis 操作符

这是三目运算符“ ?: ”的简单形式，三目运算符通常以这种形式出现：

String displayName = name != null ? name : "Unknown";

在 groovy 中，也可以简化为（因为 null 在 groovy 中可以转化为布尔值 false ）：

String displayName = name ? name : "Unknown";

基于“不重复”的原则，可以使用 elvis 操作符再次简化为：

String displayName = name ?: "Unknown"

17、               动态性

Groovy 所有的对象都有一个元类 metaClass ，我们可以通过 metaClass 属性访问该元类。通过元类，可以为这个对象增加方法（在 java 中不可想象）！见下面的代码， msg 是一个 String, 通过元类，我们为 msg 增加了一个 String 类中所没有的方法 up ：

def msg = "Hello!"

println msg.metaClass

String.metaClass.up = {  delegate.toUpperCase() }

println msg.up()

通过元类，我们还可以检索对象所拥有的方法和属性（就象反射）：

msg.metaClass.methods. each { println it.name }

msg.metaClass.properties. each { println it.name }

甚至我们可以看到我们刚才添加的 up 方法。

我们可以通过元类判断有没有一个叫 up 的方法，然后再调用它：

if (msg.metaClass.respondsTo(msg, 'up' )) {

    println msg.toUpperCase()

}

当然，也可以推断它有没有一个叫 bytes 的属性：

if (msg.metaClass.hasProperty(msg, 'bytes' )) {

    println msg.bytes.encodeBase64()

}

18、               Groovy swing

到现在为止，我们的 groovy 一直都在控制台窗口下工作。如果你还不满足，当然也可以使用 swingbuilder 来构建程序：

import groovy.swing.SwingBuilder

import java.awt.BorderLayout

import groovy.swing.SwingBuilder

import java.awt.BorderLayout as BL

def swing = new SwingBuilder()

count = 0

def textlabel

def frame = swing.frame(title: 'Frame' , size :[ 300 , 300 ]) {

borderLayout()

textlabel = label(text: "Clicked ${count} time(s)." ,

constraints: BL.NORTH)

button(text: 'Click Me' ,

actionPerformed: { count ++; textlabel.text =

"Clicked ${count} time(s)." ; println "clicked" },

constraints:BorderLayout.SOUTH)

}

frame.pack()

frame.show()

怎么样？是不是跟 java 中写 swing 程序很象？

 

五、 单元测试

1、   添加 junit

使用 Build Path à Add Libraries... 把 junit 添加到项目中。

2、   新建测试

使用 New à Junit Test Case 新建测试例程： PersonTest ，在 Class under test 右边的 Browser 按钮，选择要进行测试的groovy 类 Person 。

Finish ，下面编写测试用例代码（我使用了 Junit4 ）：

import org.junit.*;

public class TestPerson {

       @Test

       public void testToString(){

              Person p=new Person();              // 注意因为 groovy 编译 Person 时默认所有属性为 private

              p.setName("ddd");                // 所以用 set 方法设置 name 属性而不用 p.name=”ddd”

              p.setAge(18);

              Assert.assertEquals("ddd-18", p.toString());

       }

}

运行 Run As à Junit Test ，发现 testToString 通过测试。

3 、使用 groovy 书写测试用例

除了使用 Java 来书写测试用例以外，我们也可以使用 groovy 书写。

New à Other à Groovy à Groovy Class ，写一个类 GroovyTestPerson ：

import org.junit.*;

 

class GroovyTestPerson {

    @Test

      void testToString(){

       Person p= new Person( "name" : "ddd" , "age" : 18 )

       Assert.assertEquals( "ddd-18" , p.toString())

    }

}

可以看到，这里使用的完全是 Groovy 风格的书写方式：不需要 public ，使用 map 参数构造对象。然而当你 Run As àJunit Test 的时候，结果跟用 java 编写的测试用例没有什么两样。

这也充分说明了， groovy 和 java ，除了语法不一样，本质上没有什么区别（对比 .net framework 中的 C# 和 VB.net ，它们除了语法不同外，本质上它们都使用 CLR ）。

评论

1 楼 kira616 2012-01-08  

mark