三、Groovy 基础语法

Groovy 的基础语法主要可以分为以下 四个部分：

• 1）、Groovy 核心基础语法。
• 2）、Groovy 闭包。
• 3）、Groovy 数据结构。
• 4）、Groovy 面向对象

1、Groovy 核心基础语法

Groovy 中的变量

变量类型

Groovy 中的类型同 Java 一样，也是分为如下 两种：

• 1）、基本类型。
• 2）、对象类型。

但是，其实 Groovy 中并没有基本类型，Groovy 作为动态语言， 在它的世界中，所有事物都是对象，就如 Python、Kotlin 一样：所有的基本类型都是属于对象类型。为了验证这个 Case，我们可以新建一个 groovy 文件，创建一个 int 类型的变量并输出它，会得到输出结果为 'class java.lang.Integer'，因此可以验证我们的想法是正确的。实际上，Groovy 的编译器会将所有的基本类型都包装成对象类型。

变量定义

groovy 变量的定义与 Java 中的方式有比较大的差异，对于 groovy 来说，它有 两种定义方式，如下所示：

• 1）、强类型定义方式：groovy 像 Java 一样，可以进行强类型的定义，比如上面直接定义的 int 类型的 x，这种方式就称为强类型定义方式，即在声明变量的时候定义它的类型。
• 2）、弱类型定义方式：不需要像强类型定义方式一样需要提前指定类型，而是通过 def 关键字来定义我们任何的变量，因为编译器会根据值的类型来为它进行自动的赋值。

那么，这两种方式应该分别在什么样的场景中使用呢？

如果这个变量就是用于当前类或文件，而不会用于其它类或应用模块，那么，建议使用 def 类型，因为在这种场景下弱类型就足够了。

但是，如果你这个类或变量要用于其它模块的，建议不要使用 def，还是应该使用 Java 中的那种强类型定义方式，因为使用强类型的定义方式，它不能动态转换为其它类型，它能够保证外界传递进来的值一定是正确的。如果你这个变量要被外界使用，而你却使用了 def 类型来定义它，那外界需要传递给你什么才是正确的呢？这样会使调用方很疑惑。

如果此时我们在后面的代码中改变上图中 x1 的值为 String 类型，那么 x1 又会被编译器推断为 String 类型，于是我们可以猜测到，其实使用 def 关键字定义出来的变量就是 Obejct 类型。

Groovy 中的字符串

Groovy 中的字符串与 Java 中的字符串有比较大的不同，所以这里我们需要着重了解一下。

Groovy 中的字符串除了继承了 Java 中传统 String 的使用方式之前，还 新增 了一个 GString 类型，它的使用方式至少有七、八种，但是常用的有三种定义方式。此外，在 GString 中新增了一系列的操作符，这能够让我们对 String 类型的变量有 更便捷的操作。最后，在 GString 中还 新增 了一系列好用的 API，我们也需要着重学习一下。

Groovy 中常用的三种字符串定义方式

在 Groovy 中有 三种常用 的字符串定义方式，如下所示：

• 1）、单引号 '' 定义的字符串
• 2）、双引号 "" 定义的字符串
• 3）、三引号 '""' 定义的字符串

首先，需要说明的是，'不管是单引号、双引号还是三引号，它们的类型都是 java.lang.String'。

那么，单引号与三引号的区别是什么呢？

既生瑜何生亮，其实不然。当我们编写的单引号字符串中有转义字符的时候，需要添加 ''，并且，当字符串需要具备多行格式的时候，强行将单引号字符串分成多行格式会变成由 '+' 号组成的字符串拼接格式。

那么，双引号定义的变量又与单引号、三引号有什么区别呢？

双引号不同与单、三引号，它定义的是一个可扩展的变量。这里我们先看看两种双引号的使用方式，如下图所示：

在上图中，第一个定义的 name 字符串就是常规的 String 类型的字符串，而下面定义的 sayHello 字符串就是可扩展的字符串，因为它里面使用了 '${name}' 的方式引用了 name 变量的内容。而且，从其最后的类型输出可以看到，可扩展的类型就是 'org.codehaus.groovy.runtime.GStringImpl' 类型的。

需要注意的是，可扩展的字符串是可以扩展成为任意的表达式，例如数学运算，如上图中的 sum 变量。

有了 Groovy 的这种可扩展的字符串，我们就可以 避免 Java 中字符串的拼接操作,提升 Java 程序运行时的性能。

那么，既然有 String 和 GString 两种类型的字符串，它们在相互赋值的场景下需要不需要先强转再赋值呢？

不需要，编译器可以帮我们自动在 String 和 GString 之间相互转换，我们在编写的时候并不需要太过关注它们的区别。

2、Groovy 闭包（Closure）

闭包的本质其实就是一个代码块，闭包的核心内容可以归结为如下三点：

• 1)、闭包概念
  • 定义
  • 闭包的调用
• 2)、闭包参数
  • 普通参数
  • 隐式参数
• 3)、闭包返回值
  • 总是有返回值

闭包的调用

clouser.call()

clouser() 

def xxx = { paramters -> code } 

def xxx = { 纯 code }

复制

从 C/C++ 语言的角度看，闭包和函数指针很像，闭包可以通过 .call 方法来调用，也可以直接调用其构造函数，代码如下所示：

闭包对象.call(参数)

闭包对象(参数)

复制代码

如果闭包没定义参数的话，则隐含有一个参数，这个参数名字叫 it，和 this 的作用类似。it 代表闭包的参数。表示闭包中没有参数的示例代码：

def noParamClosure = { -> true }

复制代

注意点：省略圆括号

函数最后一个参数都是一个闭包，类似于回调函数的用法，代码如下所示：

task JsonChao {

    doLast ({

        println "love is peace~"

    }

})


// 似乎好像doLast会立即执行一样

task JsonChao {

    doLast {

        println "love is peace~"

    }

}

复制代码

闭包的用法

闭包的常见用法有如下 四种：

• 1）、与基本类型的结合使用。
• 2）、与 String 类的结合使用。
• 3）、与数据结构的结合使用。
• 4）、与文件等结合使用。

闭包进阶

• 1）、闭包的关键变量
  • this
  • owner
  • delegate
• 2）、闭包委托策略

闭包的关键变量

this 与 owner、delegate

其差异代码如下代码所示：

def scrpitClouser = {

   // 代表闭包定义处的类

   printlin "scriptClouser this:" + this 

   // 代表闭包定义处的类或者对象

   printlin "scriptClouser this:" + owner

   // 代表任意对象，默认与 ownner 一致

   printlin "scriptClouser this:" + delegate 

}


// 输出都是 scrpitClouse 对象

scrpitClouser.call()


def nestClouser = {

   def innnerClouser = {

       // 代表闭包定义处的类

       printlin "scriptClouser this:" + this 

       // 代表闭包定义处的类或者对象

       printlin "scriptClouser this:" + owner

       // 代表任意对象，默认与 ownner 一直

       printlin "scriptClouser this:" + delegate 

   }

   innnerClouser.call()

}


// this 输出的是 nestClouser 对象，而 owner 与 delegate 输出的都是 innnerClouser 对象

nestClouser.call()

复制

可以看到，如果我们直接在类、方法、变量中定义一个闭包，那么这三种关键变量的值都是一样的，但是，如果我们在闭包中又嵌套了一个闭包，那么，this 与 owner、delegate 的值就不再一样了。换言之，this 还会指向我们闭包定义处的类或者实例本身，而 owner、delegate 则会指向离它最近的那个闭包对象。

delegate 与 this、owner 的差异

其差异代码如下代码所示：

def nestClouser = {

   def innnerClouser = {

       // 代表闭包定义处的类

       printlin "scriptClouser this:" + this 

       // 代表闭包定义处的类或者对象

       printlin "scriptClouser this:" + owner

       // 代表任意对象，默认与 ownner 一致

       printlin "scriptClouser this:" + delegate 

   }


   // 修改默认的 delegate

   innnerClouser.delegate = p 

   innnerClouser.call()

}


nestClouser.call()

复制代

可以看到，delegate 的值是可以修改的，并且仅仅当我们修改 delegate 的值时，delegate 的值才会与 ownner 的值不一样。

闭包的委托策略

其示例代码如下所示：

def stu = new Student()

def tea = new Teacher()

stu.pretty.delegate = tea

// 要想使 pretty 闭包的 delegate 修改生效，必须选择其委托策略为 Closure.DELEGATE_ONLY，默认是 Closure.OWNER_FIRST。

stu.pretty.resolveStrategy = Closure.DELEGATE_ONLY

println stu.toString()

复制

需要注意的是，要想使上述 pretty 闭包的 delegate 修改生效，必须选择其委托策略为 Closure.DELEGATE_ONLY，默认是 Closure.OWNER_FIRST 的。

3、Groovy 数据结构

Groovy 常用的数据结构有如下 四种：

• 1）、数组
• 2）、List
• 3）、Map
• 4）、Range

数组的使用和 Java 语言类似，最大的区别可能就是定义方式的扩展，如下代码所示：

// 数组定义

def array = [1, 2, 3, 4, 5] as int[]

int[] array2 = [1, 2, 3, 4, 5]

复制代

下面，我们看看其它三种数据结构。

1、List

即链表，其底层对应 Java 中的 List 接口，一般用 ArrayList 作为真正的实现类，List 变量由[]定义，其元素可以是任何对象。

链表中的元素可以通过索引存取，而且 不用担心索引越界。如果索引超过当前链表长度，List 会自动往该索引添加元素。下面，我们看看 List 最常使用的几个操作。

1）、排序

def test = [100, "hello", true]

// 左移位表示向List中添加新元素

test << 200

// list 定义

def list = [1, 2, 3, 4, 5]

// 排序

list.sort()

// 使用自己的排序规则

sortList.sort { a, b -> 

   a == b ？0 : 

           Math.abs(a) < Math.abs(b) ? 1 : -1

} 

复制

2）、添加

// 添加

list.add(6)

list.leftShift(7)

list << 8

复制代码

3）、删除

// 删除

list.remove(7)

list.removeAt(7)

list.removeElement(6)

list.removeAll { return it % 2 == 0 }

复制代码

4）、查找

// 查找

int result = findList.find { return it % 2 == 0 }

def result2 = findList.findAll { return it % 2 != 0 }

def result3 = findList.any { return it % 2 != 0 }

def result4 = findList.every { return it % 2 == 0 }

5）、获取最小值、最大值

// 最小值、最大值

list.min()

list.max(return Math.abs(it))

复制代码

6）、统计满足条件的数量

// 统计满足条件的数量

def num = findList.count { return it >= 2 }

复制代

Map

表示键-值表，其 底层对应 Java 中的 LinkedHashMap。

Map 变量由[:]定义，冒号左边是 key，右边是 Value。key 必须是字符串，value 可以是任何对象。另外，key 可以用 '' 或 "" 包起来，也可以不用引号包起来。下面，我们看看 Map 最常使用的几个操作。

1）、存取

其示例代码如下所示：

aMap.keyName

aMap['keyName']

aMap.anotherkey = "i am map"

aMap.anotherkey = [a: 1, b: 2]

复制代码

2）、each 方法

如果我们传递的闭包是一个参数，那么它就把 entry 作为参数。如果我们传递的闭包是 2 个参数，那么它就把 key 和 value 作为参数。

def result = ""

[a:1, b:2].each { key, value -> 

   result += "$key$value" 

}


assert result == "a1b2"


def socre = ""

[a:1, b:2].each { entry -> 

   result += entry

}


assert result == "a=1b=2"

3）、eachWithIndex 方法

如果闭包采用两个参数，则将传递 Map.Entry 和项目的索引（从零开始的计数器）；否则，如果闭包采用三个参数，则将传递键，值和索引。

def result = ""

[a:1, b:3].eachWithIndex { key, value, index -> result += "$index($key$value)" }

assert result == "0(a1)1(b3)"


def result = ""

[a:1, b:3].eachWithIndex { entry, index -> result += "$index($entry)" }

assert result == "0(a=1)1(b=3)"

4）、groupBy 方法

按照闭包的条件进行分组，代码如下所示：

def group = students.groupBy { def student ->

   return student.value.score >= 60 ? '及格' : '不及格'

}

复制代

5）、findAll 方法

它有两个参数，findAll 会将 Key 和 Value 分别传进 去。并且，如果 Closure 返回 true，表示该元素是自己想要的，如果返回 false 则表示该元素不是自己要找的。

Range

表示范围，它其实是 List 的一种拓展。其由 begin 值 + 两个点 + end 值表示。如果不想包含最后一个元素，则 begin 值 + 两个点 + < + end 表示。我们可以通过 aRange.from 与 aRange.to 来获对应的边界元素。

如果需要了解更多的数据结构操作方法，我们可以直接查 Groovy API 详细文档 即可。

4、Groovy 面向对象

如果不声明 public/private 等访问权限的话，Groovy 中类及其变量默认都是 public 的。

1）、元编程（Groovy 运行时)

Groovy 运行时的逻辑处理流程图如下所示:

为了更好的讲解元编程的用法，我们先创建一个 Person 类并调用它的 cry 方法，代码如下所示：

// 第一个 groovy 文件中

def person = new Person(name: 'Qndroid', age: 26)

println person.cry()


// 第二个 groovy 文件中

class Person implements Serializable {


   String name


   Integer age


   def increaseAge(Integer years) {

       this.age += years

   }


    /**

     * 一个方法找不到时，调用它代替

     * @param name

     * @param args

     * @return

     */

    def invokeMethod(String name, Object args) {


       return "the method is ${name}, the params is ${args}"

   }



   def methodMissing(String name, Object args) {


       return "the method ${name} is missing"

   }

}

复制

为了实现元编程，我们需要使用 metaClass，具体的使用示例如下所示：

ExpandoMetaClass.enableGlobally()

//为类动态的添加一个属性

Person.metaClass.sex = 'male'

def person = new Person(name: 'Qndroid', age: 26)

println person.sex

person.sex = 'female'

println "the new sex is:" + person.sex

//为类动态的添加方法

Person.metaClass.sexUpperCase = { -> sex.toUpperCase() }

def person2 = new Person(name: 'Qndroid', age: 26)

println person2.sexUpperCase()

//为类动态的添加静态方法

Person.metaClass.static.createPerson = {

   String name, int age -> new Person(name: name, age: age)

}

def person3 = Person.createPerson('renzhiqiang', 26)

println person3.name + " and " + person3.age

复

需要注意的是通过类的 metaClass 来添加元素的这种方式每次使用时都需要重新添加，幸运的是，我们可以在注入前调用全局生效的处理，代码如下所示：

ExpandoMetaClass.enableGlobally()

// 在应用程序初始化的时候我们可以为第三方类添加方法

Person.metaClass.static.createPerson = { String name,

                                              int age ->

    new Person(name: name, age: age)

}

复制代码

2)、脚本中的变量和作用域

对于每一个 Groovy 脚本来说，它都会生成一个 static void main 函数，main 函数中会调用一个 run 函数，脚本中的所有代码则包含在 run 函数之中。我们可以通过如下的 groovyc 命令用于将编译得到的 class 文件拷贝到 classes 文件夹下：

// groovyc 是 groovy 的编译命令，-d classes 用于将编译得到的 class 文件拷贝到 classes 文件夹 下

groovyc -d classes test.groovy

复制代码

当我们在 Groovy 脚本中定义一个变量时，由于它实际上是在 run 函数中创建的，所以脚本中的其它方法或其他脚本是无法访问它的。这个时候，我们需要使用 @Field 将当前变量标记为成员变量，其示例代码如下所示：

import groovy.transform.Field; 


@Field author = JsonCh