groovy 的特点：

  • groovy 继承了 java 所有的语法，即当忘了 groovy 的语法时可以写成 java 代码，groovy 和 java 代码混合在一起也能执行
  • groovy 和 java 一样，都运行在 JVM 上，源码都是先编译成 class 字节码
  • groovy 默认会导入以下常用包，因此在使用如下包中的类时不需要导包
    • java.lang
    • java.util
    • java.io
    • java.net
    • java.math.BigDecimal
    • java.math.BigInteger
    • groovy.lang
    • groovy.util

注释

groovy 注释和 java 注释一样，支持行注释和块注释：

  1. // 单行注释
  2. println "Hello"
  4. /**
  5.  * 块注释
  6.  */
  7. println "Hello"

定义变量、方法

groovy 为弱类型语言，会自动推断类型
1、使用 def 定义变量（def 关键字可以省略），且变量不用指定类型，数据类型可以随意更换

  1. def str = "世界"
  2. str = "世界"

2、groovy 方法：

  • 定义：使用 def 关键字，该关键字可以省略不写
  • 方法参数：方法参数类型可写可不写
    • 写了参数类型则必须传入相应类型的参数
    • 不写参数类型可以传入任意类型的参数
  • 返回值：groovy 所有方法都有返回类型
    • 如果没有返回值，则会返回 null（groovy 没有 void 类型）
    • 返回类型可以省略不写，不写的话返回类型取决于最后一行的代码的类型
    • 返回类型可以省略不写，如果返回类型省略不写，则该方法必须加上 def 关键字
    • return 关键字可以省略不写 ```groovy / 无返回值函数：返回null / def out(String msg) { println msg }

print out(‘世界’) // 输出：世界 null

/ 省略return关键字 / def multi(x, y) { x * y }

println multi(“世界”,3) // 输出：世界世界世界

  2. 3、groovy 的类、方法的默认修饰符都是 public，且可以省略不写
  4. <a name="OENlV"></a>
  5. #### 字符串
  7. 字符串分为三种：单引号、双引号、三引号
  9. - 单引号：不会进行转义，按文本输出
  10. - 双引号：会进行转义，可以使用 ${} 引用变量的值
  11. - 三引号：输出一段文本，可以直接加空格和换行
  12. ```groovy
  13. name = '李四'
  15. println 'name is ${name}'
  16. println "name is ${name}"
  17. println '''name is ${name}
  18. 换行输出
  19. '''
  21. 结果：
  22. name is ${name}
  23. name is 李四
  24. name is ${name}
  25. 换行输出

基本数据类型

groovy 是纯面向对象的语言，没有 java 中的 8 种基本值类型，只有如下几种包装类：

  • 整数默认：Integer
  • 浮点数默认：BigDecimal
  • 布尔类型默认：Boolean

如果需要显示指定 Long 类型，在字面量后面加 L，显示指定 Double 类型，在字面量后面加 D

  1. x = 15
  2. y = 12.8
  3. z = false
  4. m = 12L
  5. n = 12.5D
  7. println x.class  // class java.lang.Integer
  8. println y.class  // class java.math.BigDecimal
  9. println z.class  // class java.lang.Boolean
  10. println m.class  // class java.lang.Long
  11. println n.class  // class java.lang.Double

容器类

分 List、Map 和 Range

1、List：使用 [ ] 定义，元素之间使用逗号 , 隔开

  1. list = [121, 2.3, 'Hello', false, null] // 定义
  2. println list.size() // 获取集合大小
  3. println list[2] // 获取index为2的元素
  4. // 在结尾添加元素的两种写法
  5. list.add(100)
  6. list << 100
  7. // 在指定位置添加元素，原本index大于等于3的元素后退一位
  8. list.add(3, 89)
  9. // 删除指定index的元素
  10. list.remove(0)
  11. // 删除某集合的元素
  12. list -= [2.3, null]
  13. // 清空集合
  14. list.clear()
  15. // 使用集合的.each方法遍历
  16. list.each {
  17.     println it // it是遍历过程中的每一个元素
  18. }

2、Map：

  • 使用[key : value]定义，元素之间使用逗号 , 隔开
  • key 必须是 String，也可以不使用引号自动转为 String
    1. def demoMap = ['name' : '风神', 'age' : 18, 'isGay' : false]
    2. println demoMap.size() // 获取map大小
    3. println demoMap.name // 通过key获取值
    4. demoMap << ['hehe' : '777'] // 添加元素
    5. // 遍历map
    6. demoMap.each {
    7.   println it.key
    8.   println it.value
    9. }

3、Range：

  1. // 范围从1到10
  2. def demoRange = 1..10
  3. // 范围从1到9
  4. def demoRange2 = 1..<10
  5. println(demoRange2.from) // 获取起始值
  6. println(demoRange2.to) // 获取最大值

闭包

闭包是一段代码块，注意闭包也是数据类型，所以可以把闭包作为方法的参数或者返回类型。
如果我们要筛选指定数n范围内的奇数，普通写法如下：

  1. def getOdd(Integer integer) {
  2.     for (i in 1..integer) {
  3.         if ((i & 1) == 1) {
  4.             println i
  5.         }
  6.     }
  7. }
  9. getOdd 12

如果需要获取偶数，则需要再写一方法：

  1. def getOdd(Integer integer) {
  2.     for (i in 1..integer) {
  3.         if ((i & 1) == 0) {
  4.             println i
  5.         }
  6.     }
  7. }
  9. getOdd 12

使用闭包：

  1. def get(Integer integer, Closure closure) {
  2.     for (i in 0..integer) {
  3.         closure(i)
  4.     }
  5. }
  7. // 输出奇数
  8. get(12, {
  9.     if ((it & 1) == 1) {
  10.         println(it)
  11.     }
  12. })
  14. // 输出偶数
  15. get(12, {
  16.     if ((it & 1) == 0) {
  17.         println it
  18.     }
  19. })

闭包接受参数问题：

  • 闭包只有一个参数时，默认生成隐式变量 it
  • 闭包不需要接受参数时，也会生成隐式变量 it，只不过值为 null
  • 多个参数，使用 -> 将参数列表和行为隔开 ```groovy // 0个参数 closure = { println it }

closure.run() // 输出：null

// 1个参数 def test(Closure c){ c(“世界”) }

closure = { println it }

test closure

// 2个参数 def test(Closure c) { c(“世界”, 12) }

closure = { x, y -> println x println y }

test closure ```