Groovy 快速入门

Groovy 是在java 基础上改造的脚本风格的语言，运行与JVM平台，可与java 无缝集成。

环境安装：

1，JDK 1.8

2，在 Groovy 官网下载压缩包 http://www.groovy-lang.org/download.html，解压到磁盘目录，将根路径加入到环境变量，和jdk的安装方法类似

3，在cmd 中运行命令 ： groovy -version

出现类似这种信息：Groovy Version: 2.5.1 JVM: 1.8.0_45 Vendor: Oracle Corporation OS: Windows 7

说明安装成功。

 

基本语法：

1，代码注释与java 一样

2，语句结尾可不用分号

3，单引字符串号只是一个简单的字符串

4，双引号字符串，可以插入变量

def a = 'tom'
def str = 'hello $a'
println(str)
def str1 = "hello $a"
println(str1)

输出：

hello $a
hello tom

5，三引号字符串会保留格式

def str2 = """ hi!
                    tom """

println(str2)　

输出：

 hi!
                    tom 

6，变量定义，Groovy 支持动态类型，可以使用def 关键字定义变量，而不用给出具体类型，def 可以省略。

 

7，函数定义，无返回的函数必须指定返回类型为def ，函数最后一句作为返回值，函数调用可以省略括号()

//无参函数
def fun1(){
    2
}

println(fun1())
println fun1()
//有参函数 , 无需指定参数类型
def fun2( def1 , def2 ){

}

输出：

2
2

8，断言 Assert

str2 = """ hi!
                    tom """

assert str2 == null

输出：

Caught: Assertion failed: 

assert str2 == null
       |    |
       |    false
       ' hi!\n                    tom '

断言失败程序将会终止

9，for 循环

第一种，和java 类似

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

输出：

0
1
2
3
4

第二种：

for (i in 0..5){
    println("hello world"+i)
}

输出：

hello world0
hello world1
hello world2
hello world3
hello world4
hello world5

注意此处会包含上界

10，time 循环

5.times{
    println("time"+it)
}

输出：

time0
time1
time2
time3
time4

不包含上界，it 相当于java 中的this

11，三木运算

a = 1==1?:"no"
println(a)

a = 1==2?:"no"
println(a)

输出：

true
no

12，异常捕获

try{
    a = 1/0
}catch (Exception e){
    println(e)
}

try{
    a = 1/0
}catch (e){
    println(e)
}
println("运行")

输出：

java.lang.ArithmeticException: Division by zero
java.lang.ArithmeticException: Division by zero
运行

 13，switch 结构

a = 5
switch(a){
    case 1:
        println(1)
        break
    case 1..5:
        println("1 ~ 5")
        break
    case 5..<10:
        println("a > 5")
        break
    default:
        println("大于 9 或 不是数字")
}

输出：

1 ~ 5

14，判断非空的便捷方式

class Person {
    String name
    Person child
}
p1 = new Person()
p1.child = new Person()
p1.child.name = 'tom'
p2 = new Person()
p2.child = null

println p1?.child?.name
println p2?.child?.name

输出：

tom
null

15，类型转换 asType

s1 = 1
//String 转成 int
def s2 = s1 as int

//String 转成 int
def s3 = s1.asType(Integer)
println(s2.class)
println(s3.class)

输出：

class java.lang.Integer
class java.lang.Integer

Groovy 没有typeof 关键字

16，Groovy 数据类型：

groovy　中的数据类型分两种，

一种是java 中的基本数据类型，

一种是groovy 中的容器类，还有闭包

java基本数据类型：

def boolean s1 = true

def int s2 = 100

def String s3 = "hello world"

if (s1) {
    println("hello world")
}

Groovy 容器类型：

List:列表，内部是java 的 ArrayList

//列表由[]定义
def list = [1,2,3,"tom"]
println(list)
println(list.size())
println(list[1])

//添加加元素
list << true

println(list)

//下标超过返回Null
println(list[5])

输出：

[1, 2, 3, tom]
4
2
[1, 2, 3, tom, true]
null

Map:K-V序列，内部是LinkHashMap 实现，有序的

//定义map
def map = [name:"tom",age:12,score:100,isMale:false]
println(map)
//获取长度
println(map.size())
//获取key set
println(map.keySet())
//获取值
println(map.name)
println(map.get("name"))

// 添加，修改 元素
map.put("name","bob")
println(map.name)
Iterator it = map.iterator()
while (it.hasNext()) {
    println "遍历map: " + it.next()
}

map.containsKey("name")

map.containsValue("tom")

//删除元素
map.remove("name")
println(map)

输出：

[name:tom, age:12, score:100, isMale:false]
4
[name, age, score, isMale]
tom
tom
bob
遍历map: name=bob
遍历map: age=12
遍历map: score=100
遍历map: isMale=false
[age:12, score:100, isMale:false]

 

 Range:范围

def range = 1..5
println(range)

//两种遍历方法
for(i in range){
    println(">>"+i)
}

iter = range.iterator()
while(iter.hasNext()){
    println(iter.next())
}

//长度
printf("长度 ： %s \n",range.size())

//获取指定下标元素
printf("下标1的元素是： %s \n",range.get(1))

//最后一个元素
printf("最后一个元素是： %s \n",range.last())

//是否包含某个元素
printf("是否包含 7 , %s  \n",range.contains(7))


//以下两个方法必须重写，否者会抛异常
//按下标删除元素
//range.remove(1)
//println(range)

//清空列表
//range.clear()
//println(range.size())

输出：

1..5
>>1
>>2
>>3
>>4
>>5
1
2
3
4
5
长度 ： 5 
下标1的元素是： 2 
最后一个元素是： 5 
是否包含 7 , false  

17，闭包

闭包就是能够读取其他函数内部变量的函数。

//有参数
def sayHi = {
    sb -> printf("hi , %s \n", sb)
}

// 无参数
def myname = {
    println("my name is bob")
}

sayHi.call("tom")
sayHi("tom")
sayHi "tom"
myname()

def say = {
    name, fun, age ->
        printf("name: %s \n" ,name)
        fun()
        printf("age: %s \n" ,age)

}

// 函数调用可以省略圆括号()
say "tom", {
    println("hehe")
}, 12


def list = [1,2,3]
// 闭包会默认传入一个参数 it 和 java 的this 一样，代表当前对象
list.each {
    println(it)
}

输出：

hi , tom 
hi , tom 
hi , tom 
my name is bob
name: tom 
age: 12 
1
2
3

 

End