Groovy编程入门攻略
当一个java开发人员加入到groovy的开发之旅的时候,他/她经常带着java思想去思考,并逐步地学习groovy,每次学习一个特性,这会让他慢慢变得更有创造性和写出更符合语言习惯的groovy代码。这篇文章的目的是引导这些开发人员去学习基本的groovy编程风格,学习新的操作技巧,新的语言特性,例如闭包等等。这篇文章并不会详细铺开描述,而是给读者一个入门的指引,并让读者在以后的深入学习打好基础。如果你喜欢这篇文章,可以贡献你的一份力量去丰富它。
无分号
c / c++ / c# / java开发者,经常到处使用分号。尽管groovy支持99%的java语法,有时你只需简单的把java代码粘贴到groovy程序里,但是却带着一大堆分号。在groovy里,分号是可选的,你可以省略他们,更常用的用法是删除它们。
返回关键字 (return) 变得可选
在groovy的世界里面,方法的程序块结尾可以不写'return'关键字而照样返回值。尤其是对于语句不多的方法和闭包。这样的写法更优美更简洁:
string tostring() {return"a server"} string tostring() {"a server"}
但有些情况却不那么优美,例如你使用了变量,并在两行里面出现两次:
def props() { def m1 = [a:1, b:2] m2 = m1.findall { k, v -> v %2==0} m2.c =3 m2 }
我自己个人习惯,有时候喜欢用return关键字,有时候又不喜欢,这跟个人口味有关系吧。但是,更多时候,例如在闭包里面,我更喜欢不写return关键字。所以即使return关键字是可选的,也不会强制你不能使用它,如果你认为它会打破代码的可读性。
谨慎为上,然而当你使用def关键字定义,而并非用代替具体某一个类型去定义的方法,有时候你会惊奇的发现最后一条表达式会作为返回结果而返回。所以更多时候更推荐使用具体的类型(例如void或类型)作为返回类型。在我们上面的例子中,如果我们忘记了把m2放在最后一行并作为返回值,那么最后的一个表达式将是m2.c = 3,这样会导致数值3作为返回值返回,而不是我们期待的结果。
形如if/else语句,try/cath语句同样可以返回值,因为它们里面都有"最后一个表达式"会被返回。
def foo(n) { if(n ==1) { "roshan" }else{ "dawrani" } } assertfoo(1) =="roshan" assertfoo(2) =="dawrani"
def 和 类型
当我们讨论def和类型,我经常会发现一些开发人员既用'def'又用类型。但是'def'在这里是多余的。所以,大家要做一个选择,要不用'def', 要不就用类型。
所以不要写出如下的代码:
def string name = "guillaume"
可以写成
string name ="guillaume"
当我们在groovy里面使用def,真正的类型是object(所以你可以向用def定义的变量,赋值任何的对象,并且,当一个方法是用def作为返回值的时候,可以以任何对象类型作而返回)。
当一个方法未声明变量类型,你可以使用def,但是这不是必须的,所以可以省略他,所以可以代替下面的语句:
void dosomething(def param1, def param2) { }
推荐:
void dosomething(param1, param2) { }
但是,就如我们在文章末尾提到的,我们更推荐为方法的参数指定类型。这样可以帮助提高代码的可读性,也可以帮助ide工具使代码完整,或者利用groovy的静态类型检查或静态编译功能。
另外一个def多余的地方是定义构造函数,应避免使用:
class myclass { def myclass() {} }
应去掉 构造函数前的'def':
classmyclass { myclass() {} }
默认的public
默认情况,groovy会认为类和方法是定义为'public'的。所以你不需要显式的声明public。当需要声明为非public的时候,你需要显式的指定修饰符。
所以避免如下写法:
public class server { public string tostring() {return "a server"} }
推荐使用如下简洁的写法
class server { string tostring() {"a server"} }
你可能会关心包范围内的可访问性问题。事实上,groovy允许省略public, 是因为这个包范围里面默认情况下是不支持public,但是事实上有另外一个groovy注释语法去实现可访问性:
class server { @package scopecluster cluster }
省略圆括号
groovy允许你在*表达式中省略圆括号,例如println语句:
println"hello" method a, b
对比:
println("hello") method(a, b)
当方法的最后一个参数是闭包的时候,例如使用groovy的'each'迭代机制,你可以把闭包放在括号之外,甚至省略括号:
list.each( { println it } ) list.each(){ println it } list.each { println it }
通常我们推荐使用上面第三种写法,它显得更自然,因为没有圆括号是多么的多余!
但是groovy在某些情况并不允许你去掉圆括号。就像我之前说的,*表达式可以省略,但是嵌套的方法或者赋值表达式的右边,你却不能省略:
def foo(n) { n }
println foo1// 错误写法 def m = foo1
类,一级公民
在groovy里面,.class后缀是不需要的,有点像java的instanceof。
例如:
connection.dopost(base_uri +"/modify.hqu", params, resourcesresponse.class)
下面我们使用gstring,并使用第一类公民:
connection.dopost("${base_uri}/modify.hqu", params, resourcesresponse)
getters和setters
在groovy的世界里,getters和setters就是我们常说的"属性",groovy提供一个注释语法捷径给我们去访问或给属性赋值。摒弃java方式的getters/setters,你可以使用注释语法:
resourcegroup.getresourceprototype().getname() == server_type_name resourcegroup.resourceprototype.name == server_type_name resourceprototype.setname("something") resourceprototype.name = "something"
当你用groovy写beans的时候,我们通常叫做pogos(普通groovy对象),你不需要自己创建属性,和getters/setters方法,而是留给groovy编译器来完成。
所以,不再需要这样去写:
class person { private string name string getname() {returnname } void setname(string name) {this.name = name } }
而是:
class person { string name }
就如你看到的,一个简洁的"属性"并不带任何的访问修饰符,会让groovy编译器为你自动生成一个私有的属性和getter和setter方法。
当你在java中使用这样一个pogos对象,getter和setter方法其实是存在的,当然跟正常的写法无异。
虽然编译器可以创建getter/setter方法,但是当你需要在这方法里面增加一些特殊的逻辑或者跟默认的getter/setter方法不一样,你可以自己去定义它,编译器自动会选择你的逻辑代替默认逻辑。
用命名参数和默认构造器初始化beans
有这样一个bean:
class server { string name cluster cluster }
为避免像下面这样的麻烦:
def server =newserver() server.name ="obelix" server.cluster = acluster
你可以使用命名参数和默认构造器(首先会调用构造器,然后依次调用setter方法):
def server =newserver(name:"obelix", cluster: acluster)
在同一个bean里面使用with()语法处理重复操作
默认构造器中,命名参数在创建新的实例时是一件十分有趣的事情。但是当你需要更新一个实例时,你是否需要重复地在变量前重复敲打'server'这个前缀呢?答案是否定的,因为多亏了with()语句,groovy会自动为你填上:
server.name = application.name server.status = status server.sessioncount =3 server.start() server.stop()
对比:
server.with { name = application.name status = status sessioncount =3 start() stop() }
equals 和 ==
java世界里,==就相当于groovy里面的is()方法,另外groovy的==就是聪明的equal()方法!
当你需要比较对象的引用的时候,你应该使用groovy的==,因为他会帮你避开nullpointerexception,而你就不需要关心操作符的左侧或右侧是否为null。
不应该这样写:
status !=null&& status.equals(controlconstants.status_completed)
而是:
status == controlconstants.status_completed
gstrings ()
我们经常再java里面使用string和变量连接,并使用大量的双引号,加号,还有\n字符去创建新的一行。而使用插值字符串(在groovy里面叫做gstrings),可以简化我们的代码写法:
throw new exception("unable to convert resource: "+ resource)
对比:
throw new exception("unable to convert resource: ${resource}")
在花括号里面,你可以放任何的表达式,而不单单是变量。对于简单的变量,或者变量属性,你甚至可以丢掉花括号:
throw new exception("unable to convert resource: $resource")
你甚至可以通过闭包注释(${-> resource})对表达式进行延迟计算。当gstring变量强制转换为string变量的时候,它会自动计算闭包的值,并通过调用tostring()方法作为返回值。例如:
int i =3 def s1 ="i's value is: ${i}" def s2 ="i's value is: ${-> i}" i++ asserts1 =="i's value is: 3"// 预先计算,在创建的时候赋值 asserts2 =="i's value is: 4"// 延迟计算,使用最新的变量值
在java里面,字符串连接是十分的累赘:
throw new pluginexception("failed to execute command list-applications:"+ " the group with name "+ parametermap.groupname[0] + " is not compatible group of type "+ server_type_name)
你可以使用 \ 连续字符 (这不等同于多行文本)
throw new pluginexception("failed to execute command list-applications: \ the group with name ${parametermap.groupname[0]} \ is not compatible group of type ${server_type_name}")
或者使用三个双引号实现多行文本:
throw new pluginexception("""failed to execute command list-applications: the group with name ${parametermap.groupname[0]} is not compatible group of type ${server_type_name)}""")
另外,你也可以使用.stripindent()函数实现删除多行文本里面的左侧多余空格。
同时请注意groovy里面单引号和双引号的区别:单引号通常用来创建java字符串,不带任何的插值变量,而双引号可以创建java字符串,也可以用来创建带插值变量的gstrings。
对于多行字符串,你可以使用三个引号:例如在gstrings变量使用三个双引号,在简单的string变量中使用三个单引号。
如果你需要写正则表达式,你必须使用斜杠字符标记:
assert"foooo/baaaaar"==~ /fo+\/ba+r/
斜杠标记的好处是,你不需要写两个反斜杠去做转义,让正则表达式更简洁。
最后但并非不重要,请使用单引号去定义字符常量,使用双引号定义需要使用插值函数的字符串。
原生的数据结构语法
groovy对数据结构提供原生语法,例如列表,映射,正则表达式或者一个范围内的数值。请在你的groovy程序中好好使用它们。
以下是一些例子是使用那些原生数据结构的:
def list = [1,4,6,9] // 默认情况下,键是字符的,所以没必要用引号括着它们 // 你可以使用with()包含着键,例如使用[(状态变量):状态名],利用变量或对象作为键 def map = [ca:'california', mi:'michigan'] def range =10..20 def pattern = ~/fo*/ // 等同于 add() list <<5 // 调用 contains() assert4in list assert5in list assert15in range // 下标符号 assertlist[1] ==4 // 增加键值对 map << [wa:'washington'] // 下标符号 assertmap['ca'] =='california' // 属性 assertmap.wa =='washington' // 使用正则表达式匹配字符串 assert'foo'=~ pattern
grovvy 开发工具
我们来继续说说数据结构,当你需要迭代集合,groovy提供非常丰富的方法,装饰java的核心数据结构,例如each{}, find{}, findall{}, every{}, collect{}, inject{}.这些方法给编程语言增加了些乐趣,同时帮助我们更轻松的设计复杂的算法。通过装饰器,大量的新方法已应用于java的各种类型,这得得益于语言得的的动态特性。你可以查找更多的使用在字符串,文件,流,集合或者其他的方法:
http://groovy.codehaus.org/groovy-jdk/
switch的力量
groovy的switch比c语言家族的更强大,因为它们通常只接收基本数据类型和。而groovy的switch可以接受丰富的数据类型:
def x =1.23 def result ="" switch(x) { case"foo": result ="found foo" // lets fall through case"bar": result +="bar" case[4,5,6,'in list']: result ="list" break case 12..30: result ="range" break case integer: result ="integer" break case number: result ="number" break default: result ="default" } assert result =="number"
通常情况,使用iscase()方法可以判断一个数值是否为大小写。
别名导入 import aliasing
java,中当要使用来自两个不同包的同名class时,如
java.util.list 和 java.awt.list, 你能导入其中的一个类,而另一个你就不得不给其有效的重命名了.
还有时候我们在代码中经常使用一个名字非常长的类,使得整个代码变得臃肿不堪.
为了改善这些状况, groovy 提供了别名导入的特性:
importjava.util.list as julist importjava.awt.list as alist
importjava.awt.windowconstants as wc //import的时候 用 as 设置一个别名
当然也可以静态的导入某个方法:
import static pkg.someclass.foo foo()
groovy 的真值体系
在groovy中所有对象都可以被强制转为为一个boolean值,即: null, void 或空值 都 会视为 false, 其他的都视为 true.
所以不要再写 这种代码了:if (name != null && name.length > 0) {} 改为: if (name) {}
对于集合和其他数据类型同样适用.
因此,你可以在 诸如while(), if(), 三目运算符,elvis 运算符(下面会讲)等等的判断条件中使用这种简单的方式.
更强悍的是可以给你的 类 添加 asboolean() 方法,从而定制你这个类的真值的。
安全的操作对象图(嵌套的对象) safe graph navigation
groovy支持使用 . 操作符来安全的操作一个对象图.
java中如果你对一个对象图中的某个节点感兴趣,想检查其是否为null的时候,经常会写出复杂的if嵌代码,如下:
if(order !=null) { //1 if(order.getcustomer() !=null) { //2 if(order.getcustomer().getaddress() !=null) { //3 system.out.println(order.getcustomer().getaddress()); } } }
而使用groovy的安全操作符 ?. 可以讲上述代码简化为:
println order?.customer?.address
太精妙了。
操作连上 每个?.操作符前面的元素都会做null检查,如果为null则抛出 nullpointerexception 并且返回 一个 null值
断言 assert
要检查参数、返回值等,你可以使用 assert 语句。
和 java 的 assert 对比,groovy 的 assert 无需单独激活。
def check(string name) { // name non-null and non-empty according to groovy truth assertname // safe navigation + groovy truth to check assertname?.size() >3 }
你将注意到 groovy 的 power assert 语句提供更好的输出,包括每个子表达式断言时不同值的图形化视图。
elvis (埃尔维斯) ?: 操作符给变量赋默认值
?: 是一个非常方便的给变量 赋 默认值的操作符,他是三目运算符(xx? a:b)的简写.
我们经常写如下三目运算代码:
def result = name !=null? name :"unknown"//如果name为null时给'unknown'的默认值,否则用原name的值
感谢groovy的真值体系,null的检查可简单直接的通过 ‘name'来判断,null 会被转成 false.
再深入一点,既然总得返回'name',那在三目操作运算符中重复输入name两次就显得累赘了,可以将问号和冒号之间输入的重复变量移除,于是就成了elvis操作符,如下:
def result = name ?:"unknown" //如果判断name为 false 则取 "unknown",否则 取name之值<span></span>
捕捉任何异常
如果你真的不在乎在一个try代码块中抛出的异常,groovy中可以简单的catch所有这些异常,并忽略其异常类型. 所以以后像这种捕捉异常的代码:
try{ // ... }catch(throwable t) { // something bad happens }
可以写成捕捉任意异常 ('any' or 'all', 或者其他你认为是"任意"的单词):
try{ // ... }catch(any) { // something bad happens }
可选类型 建议
最后我将讨论一下何时和怎样使用 '可选类型' 这个特性.
groovy让你自己来决定是 显示使用强类型 还是 使用def 关键字 来申明你要的东西,那么怎么决定呢?
我有个相当简单的经验法则:
当你写的代码将会被作为公共api给别人使用时,你应当总是使用强类型的申明。
这将使得: 接口约定更加明确,避免可能的错误类型参数的传递,有利于提供更易读的文档,在编辑如:仅你能使用的私有方法时,强制类型 会有利于ide的代码自动完成功能,或使ide更容易推断对象的类型,然后你就能更加自如的决定是否使用明确的类型了
上一篇: java容器详细解析
推荐阅读
-
Groovy入门 博客分类: INFO groovy
-
Java网络编程基础教程之Socket入门实例
-
Java开发者结合Node.js编程入门教程
-
Java网络编程基础教程之Socket入门实例
-
Java开发者结合Node.js编程入门教程
-
常见编程入门实例,输出星号三角形python版
-
《Python编程从入门到实践》学习笔记详解-项目篇(API的使用)
-
《Python编程:从入门到实践》个人学习笔记/心得(菜鸟瞎扯淡) Chapter 1
-
《python编程从入门到实践》Django项目注意点和心得:第18章 Django入门其一
-
《python编程从入门到实践》Django项目注意点和心得:第18章 Django入门其二