Groovy笔记-第一天

 上午看完了ruby 刚刚又从ibm那看完groovy,写惯了java代码再看groovy果然是很有亲切感,不仅看起来舒服,写起来也更顺手.下面先从hello world开始

 

■Hello World

println "Hello World"

 

--------------------------------------------------------------------------------------------------------

■定义变量 默认情况下 Groovy 编译的类属性是私有的

def message="hello world"
println message  //输出message 
println message.class //输出message的类型 string

 

--------------------------------------------------------------------------------------------------------

■定义方法

def repeat(val){
 for(i = 0; i < 5; i++){
  println val;
 }
}

repeat("Hello World")

 

 

无需为i声明类型 语句结束处 ';' 可选

-----------------------------------------------------------------------------------------------
■范围
0..4 //0-4  0,1,2,3,4
0..<4 //0-3 0,1,2,3
a..d //a-d a,b,c,d
a..<d //a-c a,b,vc
 
知道了这个上面的例子可以改的更简单

def repeat(val){
 for(i in 0..4){  	//注意,是从0开始的 输出5次应该是0-4 或者写成1..5 或者 0..<5
  println(val)
 } 
}

repeat("Hello World")

 

不论采用哪种方法，都会得到原来的效果 — 输出 “Hello World” 五次。

 

改进形式

def repeat(val,num=5){	//设置num默认值为5
	for(i in 0..<num){		
		println(val)
	}	
}

repeat("Hello World",3)	//输出3次
repeat("hello")		//输出5次

 ------------------------------------------------------------------------------------------------------------------------------

■关于集合

每个 Groovy 集合都是 java.util.Collection 或 java.util.Map 的实例。

def range=0..4		//定义一个集合
println range.class		//打印类型
println range instanceof List	//打印判断是否是List类的实例

def range=["ruby","java","groovy"]
println range.class		//class java.util.ArrayList	
println range instanceof List	//true

你将会注意到，coll 对象看起来很像 Java 语言中的数组。实际上，它是一个

Collection。要在普通的 Java 代码中得到集合的相同实例，必须执行以下操作：

Collection<String> coll = new ArrayList<String>();
coll.add("Groovy");
coll.add("Java");
coll.add("Ruby");
 

 在 Java 代码中，必须使用 add() 方法向 ArrayList 实例添加项。

 

添加项-groovy提供了多种添加方法

coll.add("Python")	//同样可以使用add()方法添加
coll << "Smalltalk"	//这个和ruby是相同的
coll[5] = "Perl"	//将元素添加到指定位置 由于只有三个元素所以会添加到最后

//可以遍历一下看看结果
for(i in 0..<range.size()){ 
 println(range[i])
}

 和ruby一样可以对集合进行操作

def numbers = [1,2,3,4]
assert numbers + 5 == [1,2,3,4,5]	//如果不熟悉assert命令可以换成println
assert numbers - [2,3] == [1,4]

 

 魔法方法

Groovy 还为集合添加了其他一些方便的功能。例如，可以在集合实例上调用特殊的方法，如下所示：

def numbers = [1,2,3,4]
assert numbers.join(",") == "1,2,3,4" 
assert [1,2,3,4,3].count(3) == 2

  

join() 和 count() 只是在任何项列表上都可以调用的众多方便方法中的两个。分布操作符（spread operator） 是个特别方便的工具，使用这个工具不用在集合上迭代，就能够调用集合的每个项上的方法。

假设有一个 String 列表，现在想将列表中的项目全部变成大写，可以编写以下代码：

 

assert ["JAVA", "GROOVY"] ==   ["Java", "Groovy"]*.toUpperCase()

请注意 *. 标记。对于以上列表中的每个值，都会调用 toUpperCase()，生成的集合中每个 String 实例都是大写的。

------------------------------------------------------------------------------------------------------------------

 ■Groovy映射
Java 语言中的映射

Map<String, String>map = new HashMap<String, String>();
map.put("name", "Andy");
map.put("VPN-#","45");

 

通过 Groovy 进行映射

def hash = [name:"Andy", "VPN-#":45]
println hash.get("name")             //Andy

 请注意，Groovy 映射中的键不必是 String。在这个示例中，name 看起来像一个变量，但是在幕后，Groovy 会将它变成 String。

   既然这里用到了put那么同样的和java一样也可以使用put()

hash.put("id", 23)
println hash.get("id")		//23

当然groovy也有自己特色的语句

hash.dob = "01/29/76"	 //相当于put
println hash.dob   		//相当于get

hash["dob"]		
println hash["dob"]

 两种写法作用都是相同的,感觉下面的方式更类似于jstl中的方式

------------------------------------------------------------------------------------------------------------------------------

■闭包

闭包是可执行的代码块。它们不需要名称，可以在定义之后执行

遍历一个iterator

def acoll = ["Groovy", "Java", "Ruby"]
		
for(Iterator iter = acoll.iterator(); iter.hasNext();){
 println iter.next()
}

  上面的代码中iter的类型声明是可以省略的,下面采用一种更简洁的方式遍历

def acoll = ["Groovy", "Java", "Ruby"]		
acoll.each{
 println it
}

 这段代码得到的效果和第一段是一样的 但却简洁了很多,由 {} 包围起来的代码块就是闭包。

闭包中的 it 变量是一个关键字，指向被调用的外部集合的每个值 — 它是默认值，可以用传递给闭包的参数覆盖它。下面的代码执行同样的操作，但使用自己的项变量：

def acoll = ["Groovy", "Java", "Ruby"]
  
acoll.each{ value ->
 println value
}

 在这个示例中，用 value 代替了 Groovy 的默认 it。

遍历hash对象,如果使用java代码遍历将会麻烦很多,凡是集合一类的都可以使用 O.each{println it}进行遍历

def hash = [name:"Andy", "VPN-#":45]
hash.each{ key, value ->
 println "${key} : ${value}"
}

 更多使用方式

def excite = { word ->
 return "${word}!!"
}
println excite("hello world ")		//hello world !!
println excite.call("hello world ")	//hello world !!

  

 这段代码是名为 excite 的闭包。这个闭包接受一个参数（名为 word），返回的 String 是 word 变量加两个感叹号。请注意在 String 实例中替换 的用法。在 String 中使用 ${value}语法将告诉 Groovy 替换 String 中的某个变量的值。可以将这个语法当成 return word + "!!" 的快捷方式。

 

-+---------------------------------------------------------------------------------------------------------
■关于类

def sng3 = new Song()
sng3.name = "Funkytown"
sng3.artist = "Lipps Inc."
sng3.setGenre("Disco")

 Groovy 自动提供一个构造函数，构造函数接受一个名称-值对的映射，这些名称-值对与类的属性相对应。这是 Groovy 的一项开箱即用的功能 — 用于类中定义的任何属性，Groovy 允许将存储了大量值的映射传给构造函数。映射的这种用法很有意义，例如，您不用初始化对象的每个属性。
也可以像下面这样直接操纵类的属性：

def sng3 = new Song()
sng3.name = "Funkytown"
sng3.artist = "Lipps Inc."
sng3.setGenre("Disco")
  
println sng3.getArtist()

从这个代码中明显可以看出，Groovy 不仅创建了一个构造函数，允许传入属性及其值的映射，还可以通过 . 语法间接地访问属性。而且，Groovy 还生成了标准的 setter 和 getter 方法。

还可以使用更灵活的方法来操作

	def son=new Song(name:"leon",artist:"wood",genre:16);
	println son.getName()
	son.name=16
	println son.name
	son.setName "Wood"
	println son.getName()
	//在 Groovy 中，对于接受参数的方法，可以省略括号

 方法的覆盖

println son	//打印默认输出son的toString()实现son的hashcode 

String toString(){	//覆盖系统的toString()方法 返回类型String
 "${name}, ${artist}, ${genre}"
}

 

在Groovy 中可以省略 return 语句。Groovy 默认返回方法的最后一行。

可恶的Null

假设需要覆盖 Song 类中 getGenre() 方法，让返回的 String 全部为大写形式。

提供这个新行为很容易，只要定义 getGenre() 方法即可。可以让方法的声明返回 String，也可以完全省略它（如果愿意）。下面的方式可能是最简单的

def getGenre(){
 genre.toUpperCase()
}

sn=new Song()
println sn.getGenre()	//报错 因为没有给genre赋值

 解决办法就是在方法调用前面添加一个 ? 就相当于在调用前面放了一个条件，可以防止在 null 对象上调用方法。可以写成如下形式

def getGenre(){
 genre?.toUpperCase()
}

 虽然预期可能有异常，但是上面的代码没有生成异常。? 操作符时刻都非常有用，可以极大地减少条件语句。
 

 Groovy 就是 Java，只是缺少了您过去使用的许多语法规则。Groovy 是没有类型、没有修改符、没有 return、没有 Iterator、不需要导入集合的 Java。简而言之，Groovy 就是丢掉了许多包袱的 Java，这些包袱可能会压垮 Java 项目。

 

p.s:以上内容整理自IBM developerWorks 中国 精通 Groovy