Groovy 教程

Groovy 概述

Groovy是一种基于JVM（Java虚拟机）的敏捷开发语言，它结合了Python、Ruby和Smalltalk的许多强大的特性，Groovy 代码能够与 Java 代码很好地结合，也能用于扩展现有代码。由于其运行在 JVM 上的特性，Groovy 可以使用其他 Java 语言编写的库。

Groovy 1.0于2007年1月2日发布，其中Groovy 2.4是当前的主要版本。 Groovy通过Apache License v 2.0发布。

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

Groovy 的特点

1. 同时支持静态和动态类型。
2. 支持运算符重载。
3. 本地语法列表和关联数组。
4. 对正则表达式的本地支持。
5. 各种标记语言，如XML和HTML原生支持。
6. Groovy对于Java开发人员来说很简单，因为Java和Groovy的语法非常相似。
7. 您可以使用现有的Java库。
8. Groovy扩展了java.lang.Object。

Groovy 环境搭建

下载和安装 -进入该链接Groovy安装软件获得Windows安装程序部分。需要注意的是它依赖的JDK版本最好是1.8版本,否则会报警告.

启动Groovy安装程序，然后依次执行即可。值得注意的是,该软件会帮我们自动配置PATH和GROOVY_HOME.如下图所示,不要取消勾选.系统安全软件也会拦截,记得允许哟!!


一旦上述步骤之后，你就可以开始使用Groovy shell，有助于测试我们的Groovy，而不需要为Groovy提供一个完整的集成开发环境。可以通过在命令提示符下命令groovysh来完成。
如果你想包含groovy二进制文件作为maven或gradle构建的一部分，你可以添加以下行
Gradle

'org.codehaus.groovy:groovy:2.4.5'

Maven

<groupId>org.codehaus.groovy</groupId> 
<artifactId>groovy</artifactId>  
<version>2.4.5</version>

Groovy 基本语法

没有类型的JAV

作为动态语言，groovy中所有的变量都是对象(类似于.net framework，所有对象继承自java.lang.Object)，在声明一个变量时，groovy不要求强制类型声明，仅仅要求变量名前使用关键字def。

不需要的public

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

不需要的语句结束符

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

字符串连接符

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

def var="hello "+
       "world"+
       ",groovy!"
//当然更groovy的写法是：
def var="""hello
		   world
		   groovy!"""
//三个双引号或单引号之间不在需要+号进行连接（不过字符串中的格式符都会被保留，包括回车和tab）

一切皆对象

听起来象是“众生平等”的味道，事实上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。

循环

// 删除整个源文件内容，用以下代码替代：
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)
// 这样的结果是一样的。 

String 和 Gstring

类似于ES的模板字符串,变量用${} EL表达式来引用,还可以做相应的算术运算.

def name="Tom"   //可选的类型定义，系统会根据值进行自动识别类型，类似于js的var
println 'my name is tom' //单引号只能输出字符串
println "Myname is ${"John"+name}"  //双引号可以插入变量
println "Myname is ${"Tom"==name}"  //双引号可以进行简单的逻辑判断
println ''' 
		Myname 
		is 
		tom 
'''   //三个单引号可以保留格式，完成见到那拼接

//输出：
Myname is JohnTom
Myname is true

范围

在前面的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循环中使用。

默认参数值

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

def repeat(val,repeat=3){
   for(i in 0..<repeat){
      println "This is ${i}:${val}"
   }
}

可以看到，repeat方法增加了一个参数repeat（并且给了一个默认值3），用于指定循环次数。
当我们不指定第2个参数调用repeat方法时，repeat参数取默认值3。

集合

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

Collection 集合

groovy:000> c=[1,2,3,4,5,6,7]
===> [1, 2, 3, 4, 5, 6, 7]
groovy:000> c.add(1)  //添加元素
===> true
groovy:000> c
===> [1, 2, 3, 4, 5, 6, 7, 1]
groovy:000> c<<b   //添加其它类型的元素
Unknown property: b
groovy:000> c<<6   //添加元素
===> [1, 2, 3, 4, 5, 6, 7, 1, 6]
groovy:000> c+0   //添加元素
===> [1, 2, 3, 4, 5, 6, 7, 1, 6, 0]
groovy:000> c=c-6  //删除所有相同的元素
===> [1, 2, 3, 4, 5, 7, 1]
groovy:000> c=c-c[0..2]  //删除指定范围的元素
===> [4, 5, 7]
groovy:000>

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

//定义一个buildYear
def buildYear = ['ant':2000,'maven':2004]
buildYear.gradle = 2008

println buildYear.gradle
println buildYear['gradle']
println buildYear.getClass() //class java.util.LinkedHashMap

闭包

闭包是Groovy中非常重要的一个数据类型或者说一种概念。闭包是一种数据类型，它代表了一段可执行的代码,一般被当作参数来使用。

// （1）有参数：
def 闭包名={
	parameters->code
}
//（2）无参数（不需要->符号）
def 闭包名={code}
//如果闭包没有定义参数的话，则隐含有一个参数，这个参数名字叫it，和this的作用类似。it代表闭包的参数
def 闭包名={
	it->code
}
//方法调用：
（1）闭包名.call（参数）
（2）闭包名（参数）

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

def map=['name':'john','age':14,'sex':'boy']
map.each({key,value->    //key,value两个参数用于接受每个元素的键/值
    println "$key:$value"
})
map.each{println it}     //it是一个关键字，代表map集合的每个元素
map.each({ 
	println it.getKey()+"-->"+it.getValue()
})

//定义一个包含参数的闭包
def c1 = { //闭包是一个代码块
	v->println v
}
//定义一个不包含参数的闭包
def c2 = {
  println 'hello'
}

//定义两个个方法使用闭包作为参数传递，并调用
def method1(Closure closure){ //记住这里不导入包
	closure('param')
}

def method2(Closure closure){
	closure()
}

//执行方法
method1(c1)  //param
method2(c2)  //hello

类

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

• 不需要public修饰符
  如前面所言，groovy的默认访问修饰符就是public，如果你的groovy类成员需要public修饰，则你根本不用写它。
• 不需要类型说明
  同样前面也说过，groovy也不关心变量和方法参数的具体类型。
• 不需要getter/setter方法
  不要奇怪，在很多ide（如eclipse）早就可以为序员自动产生getter/setter方法了。在groovy中，则彻底不需要getter/setter方法——所有类成员（如果是默认的public）根本不用通过getter/setter方法引用它们（当然，如果你一定要通过get/set方法访问成员属性，groovy也提供了它们）。
• 不需要构造函数
  不在需要程序员声明任何构造函数，因为groovy自动提供了足够你使用的构造函数。不用担心构造函数不够多，因为实际上只需要两个构造函数（1个不带参数的默认构造函数，1个只带一个map参数的构造函数—由于是map类型，通过这个参数你可以在构造对象时任意初始化它的成员变量）。
• 不需要return
  Groovy中，方法不需要return来返回值吗？这个似乎很难理解。看后面的代码吧。
  因此，groovy风格的类是这样的：
• 不需要()号
  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 默认返回方法的最后一行的值。

断言(assert)

	def version = 1
	println(version) 
	println version  //括号可选
	assert version == 2  //和junit中的测试一制，给一个期待值和真实值比较

构建脚本(build.gradle 重要)

//构建脚本中默认都是有一个Project实例的  
plugins {//声明一个应用插件
    id 'java'   
}

group 'cn.itcast.gradle'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8   //源码编译器版本

repositories {  //指定仓库地址，是一个方法，使用闭包作为参数，调用了一个方法
    mavenCentral()
}

dependencies {  //依赖版本信息 --> 坐标地址
    testCompile group: 'junit', name: 'junit', version: '4.12'
    //compile  runtime testCompile testRuntime
}

def createDir = {  //创建一个执行方法
    path->
        File dir = new File(path)
        if(!dir.exists()){
            dir.mkdirs()
        }
}

//////////////自定义任务动作交给构建工具去完成/////////////////////////////
task makeJavaDir(){  //创建一个任务
    def paths = ['src/main/java','src/main/resources','src/test/java','src/test/resources']
    doFirst { //开始处添加一个动作
        paths.forEach(createDir)
    }
}

task markeWebJavaDir(){
    dependsOn 'makeJavaDir' //添加依赖动作
    def paths = ['src/main/webapp','src/test/webapp'];
    doLast {  //结尾处添加一个动作
        paths.forEach(createDir)
    }
}