atitit groovy 总结java 提升效率。Groovy常见语法汇总。

atitit groovy 总结java 提升效率 

 一、groovy是什么

 

简地游说,Groovy 是产时的java语言,跟java一样,它也运行于 JVM 中。

#—环境布置
1

作跑在JVM中的另外一样种语言,groovy语法与 Java
语言的语法很一般。同时,Groovy
抛弃了java烦琐的文法。同样的语句,使用groovy能以最可怜限度上减小你的击键次数——这真是“懒惰程序员们”的佛法。

#——安装麻烦的
2

其次、开发条件

三、创建groovy项目
2

1、  jdk 1.5以上

3、  添加 Groovy 类
2

2、  eclipse+groovy plugin(支持Groovy 1.5.7)

4、  编译运行groovy类
3

打开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断点调试不奏效的解决
4

三、创建groovy项目
1、新建一个groovy项目
File–> New
Project..创建一个java项目。为了方便管理,建议在source中盖有限独source文件夹java和groovy,
分别用于存储java源文件及groovy源文件:
2、添加 Groovy 特性
每当档次落得右击,Groovy  Add Groovy Nature,这样会在品种蒙上加 Groovy
Libraries。
3、添加 Groovy 类
在档次groovy源文件下右键,New  Other Groovy Groovy Class

Groovy实现运行原理
5

自动生成的源代码如下:
public class HelloWorld{
    public static void main(def args){
       // TODO Auto-generated method stub
    } 
}
俺们以main方法中加以同句子打印语句:
println “Hello World”

1. Groovy脚本的运行..
5

4、编译运行groovy类
当自文件及右键,Compile Groovy File,然后右键,Run As à Groovy
,在控制台中查看运行结果。
骨子里 groovy 语法的简易还体现在,就算全文件被只有println “Hello
World”这同一句子代码(把除及时无异于句以外的言语删除掉吧),程序吗照样能运转。
自然,为了验证groovy 其实就是java,你为可了以java
语法来编排HelloWorld类。

2. Groovy类的运行..
5

季、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。

Groovy语法优点:
6

2、  不需要之public

3. 动态类型def
6

您得拿main方法前面的public去丢,实际上,groovy中默认的修饰符就是public,所以public修饰符你从就不需写,这点跟java不一致。

4. 循环变量不需要def
6

3、  不欲之口舌结束符

5. String 和Gstring
6

Groovy中从未说话结束符,当然为和java保持一致性,你吧足以采用;号作为言语结束符。在眼前的各一样句代码后面长;号结束,程序一样正常运转(为了承受java程序员的僵硬习惯)。

6. 范围 6

4、  字符串连接符

7. 默认参数值
7

跟java一样,如果您需要将一个字符串写在多行里,可以利用+号连接字符串。代码可以这么描绘:

8. 集合简化操作
7

       def var=”hello “+

9. 闭包(Closure)
8

       “world”+

10. Groovy类map构造函数
9

       “,groovy!”

11. (5)    不需要return
9

自还groovy的写法是:

12. (6)    不需要()号
9

       def var=”””hello

13. ?运算符 避免出现空指针异常,
10

       world

14. 动态增长方法metaClass
10

       groovy!”””

15. 正则表达式常量在Java中没有,在Groovy中象征也 /pattern/
11

老三单”号内未在急需+号进行连接(不了字符串中的格式符都会被保留,包括回车和tab)。

16. 未强制捕获检查大(checked exception)外 (这跟C#好像,如果我从未记错的话 🙂         并且于艺术声明时,也可以无写throws语句。
11

5、一切均对象

17. .Groovy会自动导入java.lang.*, java.util.*, java.net.*, java.io.*, java.math.BigInteger, java.math.BigDecimal,   groovy.lang.*, groovy.util.*,而Java则只有自行导入java.lang.*
11

放任起来象是“众生平等”的寓意,事实上groovy对于目标是呀类型并无关注,一个变量的门类在运转着随时可以更改,一切根据需要而一定。如果你给予给它们boolean
,那么不论它原本是啊品种,它承受boolean值之后就是会见活动把种变更吗boolean值。看下的代码:

Groovy及java的无兼容性
11

def var=”hello “+

Groovy的缺点..基于java/jvm
12

       “world”+

参考 12

       “,groovy!”

 

       println var;

作者 老哇的爪子 Attilax 艾龙,  EMAIL:1466519819@qq.com

       println var.class;

转载请注明来源: http://blog.csdn.net/attilax

       var=1001

 

       println var.class

#—环境布置

 

 

1.groovy eclipse 插件_groovy eclipse下充斥 2.9  – 新出口软件下载.htm

roovy Eclipse Plugin(插件)是script语言Groovy的开辅助工具,它提供编辑,编译,以及实施groovy脚本的意义。支持Eclipse 3.2和上述之本。本站提供的凡官网时版本支持groovy eclipse 4.3【For Eclipse 4.3 (Kepler)】

已带来了 Groovy2.1   sdk …不用么的装置groovy   runtime…也无用装什么环境变量..

 

 

2.Eclipse 4.3 (Kepler)

输出结果:

#——安装麻烦的

使用maket update 三不行..

roovy网站只有plugin update url,还是不行…

只得下载离线pakage从软件站点..  78M.尺寸不小的

运用archi安装或不行…

只好使用F:\eclipse\dropins料得只直黑头才..ok…

 

 

 

hello world,groovy!

三、创建groovy项目

 

1、  新建一个groovy项目

 

New –> Project à Java Project 创建一个java项目。为了方便管理,建议以source中建筑有限只source文件夹java和groovy,分别用于存储java源文件与groovy源文件:

 

 

class java.lang.String

3、  添加 Groovy 类

 

于品种groovy源文件下右键,New >>>Groovy Class,,生成/grv1/src/pkg1/g1.groovy

 

package pkg1

import com.attilax.core

 

import static  com.attilax.core.*;

/**

 * @author  attilax 老哇之爪子

 *@since  2014年5月25日 下午1:22:02$

 */

class g1 {

 

/**

@author attilax 老哇的爪子

@since  2014年5月25日 下午1:22:02$

 * @param args

 */

public static void main(String[] args) {

// attilax 老哇的爪子  下午1:22:02   2014年5月25日 

println (“—2”)

def $a=”hello world”

println $a

}

//  attilax 老哇的爪子 下午1:22:02   2014年5月25日   

}

 

 

class java.lang.Integer

4、  编译运行groovy类

 

当来文件上右键,Compile Groovy File,然后右键,

Run As groovy script /  java appliacation 效果等同

Run As à Groovy  console,走打开了groovy的控制台程序gui, 是只mini ide,可以edit/run  groovy script

 

 

 

 

 

Groovy断点调试不见效的解决

累加 package定义….贝儿不特别效.

 

package pkg1

println “ac” 

println “ac2”

var这个变量在程序运行中,类型在变更。一开始为其赋值String,它的门类就是String,后面给它们赋值Integer,它同时变化为Integer。

Groovy实现运行原理

6、循环

1. Groovy脚本的运行.. 

· // 对于groovy程序来说,可以无看似及main方法,直接写的代码就足以运行  

 实际上,最终编译器仍会否就段代码生成一个看似,类名和文书称相同,只不过由源码的角度达,确实并非写类或者main方法了,这无异于接触非常像Javascript等其它脚本语言。

println “ac” 

println “ac2”

 

 

“F:\jre7\bin\javaw.exe” -agentlib:jdwp=transport=dt_socket,suspend=y,address=localhost:1723 -Dgroovy.home=/F:/eclipse/plugins/org.codehaus.groovy_2.1.5.xx-20130703-1600-e43-RELEASE/ -Dfile.encoding=GBK -classpath “D:\workSpace\grv1\bin;F:\eclipse\plugins\org.codehaus.groovy_2.1.5.xx-20130703-1600-e43-RELEASE\lib\groovy-all-2.1.5.jar;F:\eclipse\plugins\org.codehaus.groovy_2.1.5.xx-20130703-1600-e43-RELEASE\lib\bsf-2.4.0.jar;F:\eclipse\plugins\org.codehaus.groovy_2.1.5.xx-20130703-1600-e43-RELEASE\lib\ivy-2.2.0.jar;F:\eclipse\plugins\org.codehaus.groovy_2.1.5.xx-20130703-1600-e43-RELEASE\lib\servlet-api-2.4.jar;C:\Documents and Settings\Administrator\.groovy\greclipse\global_dsld_support;F:\eclipse\plugins\org.codehaus.groovy_2.1.5.xx-20130703-1600-e43-RELEASE\plugin_dsld_support\\” org.codehaus.groovy.tools.GroovyStarter –classpath “D:\workSpace\grv1\src;D:\workSpace\grv1\bin” –main groovy.ui.GroovyMain “D:\workSpace\grv1\src\pkg1\g3.groovy”

 

删去所有源文件内容,用以下代码替代:

2. Groovy类的运行..

class g5 {

//  attilax 老哇的爪子 下午2:53:50   2014年5月25日   

// 静态的main方法作为次入口

static main(args) {

  

// 以println命令输出

println “HelloWorld in class”

}

 

}

       def var=”hello “+

Groovy语法优点:

       “world”+

3. 动态类型def 

实则Groovy同时支持强类型变量和“弱”类型变量,强类型变量拥有和谐之类别,而“弱”类型变量则遍晤为编译为Object类型,从代码的角度达,Groovy的变量无需声明类型了:

       “,groovy!”

4.  循环变量不欲def

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

  println val

 }

 for(i in 0..5)

 

       def repeat(val){

5. String 和Gstring

而外专业的java.lang.String以外(用’号括住),groovy还支持Gstring字符串类型(用“号括住)。把方的for循环中之语句改化:

  println “This is ${i}:${val}”

运行一下,你尽管见面理解啊是Gstring。

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

6. 范围

夫跟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循环中动用。

             println val

7. 默认参数值

足吗法指定默认参数值。我们修改repeat方法的概念:

def repeat(val,repeat=3){

 for(i in 0..<repeat){

  println “This is ${i}:${val}”

 }

}

得看到,repeat方法增加了一个参数repeat(并且为了一个默认值3),用于指定循环次数。

当我们不点名第2个参数调用repeat方法时,repeat参数取默认值3。

            }

8. 集合简化操作

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作为成员名索引

 

 

 

       }

9.       闭包(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!

 

       repeat(var)

10. Groovy类map构造函数

切莫以用程序员声明任何构造函数,因为groovy自动提供了十足你下的构造函数。不用顾虑构造函数不够多,因为实在仅需要简单个构造函数(1单非带来参数的默认构造函数,1个只带一个map参数的构造函数—由于是map类型,通过这个参数你得当组织对象时任意初始化它的分子变量)。

 

输出:

11. (5)    不需要return

Groovy中,方法无需return来返回值吗?这个像大不便了解。看后面的代码吧。

就此,groovy风格的切近是这般的:

hello world,groovy!

12. (6)    不需要()号

Groovy中智调用可以简简单单()号(构造函数除外),也就是说下面两句是平等的:

 

person1.setName ‘kk’

person1.setName(‘kk’)

 

hello world,groovy!

13.   ?运算符 避免出现空指针异常,

当java中,有时候为避免出现空指针异常,我们便需这么的技巧:

if(rs!=null){

rs.next()

… …

}

以groovy中,可以行使?操作符达到平等的目的:

rs?.next()

?在此处是一个条件运算符,如果?前面的靶子非null,执行后的法子,否则什么吗无开。

hello world,groovy!

14.  动态增长方法metaClass

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()

}

hello world,groovy!

15. 正则表达式常量在Java中尚无,在Groovy中代表也 /pattern/ 

hello world,groovy!

16. 勿强制捕获检查好(checked exception)外 (这跟C#怪像,如果自己没有记错的话 🙂         并且在点子声明时,也足以免写throws语句。

只顾循环变量i前面没有def。当然为尚无java中广泛的int,但若你切莫要加上int也无会见发摩擦,因为于Groovy1.1beta2以后开始(不包1.1beta2),groovy开始支持java经典的for循环写法。

17. .Groovy会自动导入java.lang.*, java.util.*, java.net.*, java.io.*, java.math.BigInteger, java.math.BigDecimal,   groovy.lang.*, groovy.util.*,而Java则单纯自行导入java.lang.*

除此以外,上面的for语句还可形容成:

Groovy与java的未兼容性

一致开始,走来groovy的非兼容性  {} 大的括号不支持

然中间走ok了.

def s=””

 {}

println “a”

            for(i in 0..5)

Groovy的缺点..基于java/jvm

这么的结果是同一的。      

总结:

Groovy还是只语言层次提升了效率.工具没方法…提升效率是有些,大概非常要出只20%吧..还是比较好的..

7、String 和 Gstring

参考

Groovy入门教程 – kmyhy的专辑 – 博客频道 – CSDN.NET.htm

Groovy无痛AOP之旅.htm

Groovy探索的MOP 十四 对Java类使用Groovy语言的MOP – 软件之信雅达 – 博客频道 – CSDN.NET.htm

 

除外正规的java.lang.String以外(用’号括住),groovy还支持Gstring字符串类型(用“号括住)。把点的for循环中之喻词改化:

             println “This is ${i}:${val}”

运转一下,你尽管会知道啊是Gstring。

def name=”Tom”
println “Myname is ${“John”+name}”

输出:

Myname is JohnTom

 

def name=”Tom”
println “Myname is ${“Tom”==name}”

输出:

Myname is true

必威 1

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

d={println "Size:${it.size}.Last Element:${it[-1]},Last Second Element:${it[-2]}"}
c=["idx0","idx1","idx2"]
d c
//使用add往集合中添加元素
c.add(1)
println c
d c
//使用<<往集合中添加元素
c<<"come on"
println c
d c

println c
//使用+往集合中添加元素
c=c+5
println c
d c
//在集合中减去元素idx1
c=c-'idx1'
println c
//把集合中的前3个元素去掉
c=c-c[0..2]
println c

Output:

groovy> d={println "Size:${it.size}.Last Element:${it[-1]},Last Second Element:${it[-2]}"} 
groovy> c=["idx0","idx1","idx2"] 
groovy> d c 
groovy> //使用add往集合中添加元素 
groovy> c.add(1) 
groovy> println c 
groovy> d c 
groovy> //使用<<往集合中添加元素 
groovy> c<<"come on" 
groovy> println c 
groovy> d c 
groovy> println c 
groovy> //使用+往集合中添加元素 
groovy> c=c+5 
groovy> println c 
groovy> d c 
groovy> //在集合中减去元素idx1 
groovy> c=c-'idx1' 
groovy> println c 
groovy> //把集合中的前3个元素去掉 
groovy> c=c-c[0..2] 
groovy> println c 

Size:3.Last Element:idx2,Last Second Element:idx1
[idx0, idx1, idx2, 1]
Size:4.Last Element:1,Last Second Element:idx2
[idx0, idx1, idx2, 1, come on]
Size:5.Last Element:come on,Last Second Element:1
[idx0, idx1, idx2, 1, come on]
[idx0, idx1, idx2, 1, come on, 5]
Size:6.Last Element:5,Last Second Element:come on
[idx0, idx2, 1, come on, 5]
[come on, 5]

(2) Map

Map是“键-值”对的聚集,在groovy中,键不肯定是String,可以是其它对象(实际上Groovy中之Map就是java.util.LinkedHashMap)。

如此这般可以定义一个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)
闭包是Groovy中那个关键之一个数据类型或者说一样种概念。
闭包是均等栽多少类,它意味着了平截可实行之代码。

概括,Closure的定义格式是:
(1)有参数:
def 闭包名={

parameters->code

}
(2)无参数(不需要->符号)
def 闭包名={code}
要是闭包没有概念参数的言语,则带有有一个参数,这个参数名字叫it,和this的来意类似。it代表闭包的参数
def 闭包名={
it->code
}
某种意义上,从C/C++语言的角度看,闭包和函数指针很像。闭包定义好后,要调用它的章程就是是:
(1)闭包名.call(参数)
(2)闭包名(参数)

闭包是因此{符号括起来的代码块,它好为单独运行还是调用,也可给取名。类似‘匿名类’或外联函数之概念。

必威 2

闭包中最为广泛的用是本着聚集进行迭代,下面定义了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.303e+23, 2.4397e6),

VENUS(4.869e+24, 6.0518e6),

EARTH(5.976e+24, 6.37814e6),

MARS(6.421e+23, 3.3972e6),

JUPITER(1.9e+27,7.1492e7),

SATURN(5.688e+26, 6.0268e7),

URANUS(8.686e+25, 2.5559e7),

NEPTUNE(1.024e+26, 2.4746e7)

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–>Libraries–>Add Library–>JUnit
把junit添加到项目蒙。
2、新建测试 使用 New a Junit Test Case
新建测试例程: PersonTest,
每当Class under test右边的Browser按钮,选择要开展测试的groovy类Person。
下编辑测试用例代码(我下了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书写。
写一个类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)。

http://blog.csdn.net/kmyhy/article/details/4200563

 

collect和each的区别:

c=[1,2,3,7,5,6]

println c.collect {print " ${it*it} "}
println c.collect {"result:${it*it}"}
println "================="
println c.each {print " ${it*it} " }


p={k,v->println k+"="+v}
c=["r":"red","b":"blue","y":"yellow"]
e=c.each(p)
println "================="
assert e==c
d=c.collect p
println "================="
assert d==[null,null,null]
assert d==[null,null,"g"]

Output:

groovy> c=[1,2,3,7,5,6] 
groovy> println c.collect {print " ${it*it} "} 
groovy> println c.collect {"result:${it*it}"} 
groovy> println "=================" 
groovy> println c.each {print " ${it*it} " } 
groovy> p={k,v->println k+"="+v} 
groovy> c=["r":"red","b":"blue","y":"yellow"] 
groovy> e=c.each(p) 
groovy> println "=================" 
groovy> assert e==c 
groovy> d=c.collect p 
groovy> println "=================" 
groovy> assert d==[null,null,null] 
groovy> assert d==[null,null,"g"] 

 1  4  9  49  25  36 [null, null, null, null, null, null]
[result:1, result:4, result:9, result:49, result:25, result:36]
=================
 1  4  9  49  25  36 [1, 2, 3, 7, 5, 6]
r=red
b=blue
y=yellow
=================
r=red
b=blue
y=yellow
=================
Exception thrown

Assertion failed: 

assert d==[null,null,"g"]
       ||
       |false
       [null, null, null]


    at ConsoleScript1.run(ConsoleScript1:17)

 

 

class Main {

    static void main(def args) {

        /**
         * NPE operator ?.
         */
        def people = [null, new Person(name: "Gweneth")]
        for (Person person : people) {
            println "Valid person:${person?.name}"
        }

        /**
         * ==,equals,is
         */
        Integer x = new Integer(2)
        Integer y = new Integer(2)
        Integer z = null
        if (x == y)
            println "x==y:${x == y}"
        if (!x.is(y))
            println("x is not y:${x.is(y)}")
        if (z.is(null))
            println "z is null:${z.is(null)}"
        if (z == null)
            println "z is null:${z == null}"

        /**
         * Process List Construct
         */
        def jvmLanguages = ["Java", "Groovy", "Scala", "Clojure"]
        println "Output List:$jvmLanguages"
        println "Output index 0:${jvmLanguages[0]}"
        println(jvmLanguages.size())
        println "Output list with range:${jvmLanguages[0..2]}"
        println "Output list with -1 index:${jvmLanguages[-1]}"
        jvmLanguages = []
        println(jvmLanguages)

        /**
         * Process map construct
         */
        def languageRatings = [Java: 100, Groovy: 99, Clojure: "N/A"]
        println "Output map construct with key:${languageRatings["Java"]}"
        println "Output with .:${languageRatings.Clojure}"
        languageRatings["Clojure"] = 75
        println "Output new value:${languageRatings["Clojure"]}"
        languageRatings.Java = "100Java"
        println "Output new value:${languageRatings["Java"]}"
        languageRatings = [:]
        println languageRatings

        /**
         * For Number process
         */
        println 3 + 0.2

        /**
         * Process xml
         */
        def writer = new StringWriter();
        def xml = new groovy.xml.MarkupBuilder(writer);
        xml.person(id: 2) {
            name 'Gweneth'
            age 1
        }
        println writer.toString()

        /**
         * for Hello
         */
        println "Hello!"

        /**
         * lamba
         */
        def sayHello = {
            name ->
                if (name == "Tom")
                    println "Hello author:$name"
                else
                    println "Hello reader:$name"
        }
        println "Lamba:${sayHello("Tom")}"
        println "Lamba:${sayHello("Jack")}"

        /**
         * Lamba used by Collection
         */
        def movieTitles=["Seven","SnowWhite","Die Hard"]
        movieTitles.each {movieTitle->println movieTitle}
        movieTitles.each {movieTitle->println "Seven"==movieTitle }
        movieTitles.each {movieTitle->println "Result:${"Seven"==movieTitle}" }

        movieTitles.each {println it }
        movieTitles.each {println "Seven"==it }
        movieTitles.each {println "Result:${"Seven"==it}" }

        /**
         * regex
         */

        def pattern=/1010/
        def input="1010"
        def matcher=input=~pattern
        if (input==~pattern){
            input=matcher.replaceFirst("0101")
            println input
        }

        ("Hazel 1"=~/(\w+) (\d+)/).each {full,name,age->println "$name is $age years old"}


    }
}

class Person{
    def name;
}

Output:

Valid person:null
Valid person:Gweneth
x==y:true
x is not y:false
z is null:true
z is null:true
Output List:[Java, Groovy, Scala, Clojure]
Output index 0:Java
4
Output list with range:[Java, Groovy, Scala]
Output list with -1 index:Clojure
[]
Output map construct with key:100
Output with .:N/A
Output new value:75
Output new value:100Java
[:]
3.2
<person id='2'>
  <name>Gweneth</name>
  <age>1</age>
</person>
Hello!
Hello author:Tom
Lamba:null
Hello reader:Jack
Lamba:null
Seven
SnowWhite
Die Hard
true
false
false
Result:true
Result:false
Result:false
Seven
SnowWhite
Die Hard
true
false
false
Result:true
Result:false
Result:false
0101
Hazel is 1 years old

 

xml_content=   
"""   
<langs type="current">   
  <language>Java</language>   
  <language>Groovy</language>   
  <language>JavaScript</language>   
</langs>   
"""   
xml=new XmlParser().parseText(xml_content)   
xml.language.eachWithIndex {   
  it,idx->   
  println "$idx: ${it.text()}"  
}

Output:

groovy> xml_content=   
groovy> """   
groovy> <langs type="current">   
groovy>   <language>Java</language>   
groovy>   <language>Groovy</language>   
groovy>   <language>JavaScript</language>   
groovy> </langs>   
groovy> """   
groovy> xml=new XmlParser().parseText(xml_content)   
groovy> xml.language.eachWithIndex {   
groovy>   it,idx->   
groovy>   println "$idx: ${it.text()}"  
groovy> }

0: Java
1: Groovy
2: JavaScript
Result: [language[attributes={}; value=[Java]], language[attributes={}; value=[Groovy]], language[attributes={}; value=[JavaScript]]]

http://kldn.iteye.com/blog/1279540 

 

相关文章