【Groovy】函数、闭包、泛型

1 函数

1.1 无参函数

1)常规调用

Groovy 复制代码
void myFun() {
    println("myFun")
}

myFun() // 打印: myFun

2)字符串声明函数

Groovy 复制代码
void "myFun"() {
    println("myFun")
}

myFun() // 打印: myFun

3)字符串调用函数

Groovy 复制代码
void myFun() {
    println("myFun")
}

"myFun"() // 打印: myFun

1.2 有参函数

1)常规调用

Groovy 复制代码
void myFun(Integer num, String str) {
    println("$num, $str")
}

myFun(5, "abc") // 打印: 5, abc

​ 在不引起歧义的情况下,可以省去小括号,如下。

Groovy 复制代码
void myFun(Integer num, String str) {
    println("$num, $str")
}

myFun 5, "abc" // 打印: 5, abc

2)入参指定默认值

Groovy 复制代码
void myFun(String str = "abc") {
    println(str)
}

myFun() // 打印: abc

1.3 有返回值函数

Groovy 复制代码
def add(int a, int b) {
    return a + b
}

def c = add(3, 5)
println(c) // 打印: 8

1.4 可变长参数函数

1)常规调用

Groovy 复制代码
void myFun(String... params) {
    for (str in params) {
        println(str)
    }
}

myFun("aa", "bb", "cc") // 打印: aa、bb、cc

​ 说明:函数的可变长参数个数最多为 1 个。

2)使用数组接收可变长参数

Groovy 复制代码
void myFun(String... params) {
    String[] arr = params
    println(arr.size())
}

myFun("aa", "bb", "cc") // 打印: 3

3)将数组传给可变长参数函数

Groovy 复制代码
void myFun(String... params) {
    println(params.size())
}

String[] arr = ["aa", "bb", "cc"]
myFun(*arr)  // 打印: 3
myFun("xx", *arr, "yy")  // 打印: 5

2 闭包

​ Groovy 中的闭包与 Java 中匿名函数(即没有名字的函数)有些类似,并且也提供了类似 Lambda 表达式的写法(详见 → Java 中 Lambda 表达式总结Kotlin 中 Lambda 表达式)。

2.1 闭包的创建

2.1.1 通过 new 创建闭包

Groovy 复制代码
Closure myFun = new Closure(null) {
    int call(int a, int b) {
        return a + b
    }
}

def res = myFun(3, 5)
println(res) // 打印: 8

2.1.2 通过 {} 创建闭包

1)无参闭包

Groovy 复制代码
def myFun = {
    println("myFun")
}

myFun() // 打印: myFun

2)有参闭包

Groovy 复制代码
def myFun = { String str ->
    println("myFun, $str")
}

myFun("abc") // 打印: myFun, abc

​ 闭包的入参类型可以省去,如下。

Groovy 复制代码
def myFun = { str ->
    println("myFun, $str")
}

myFun("abc") // 打印: myFun, abc

​ 当闭包入参个数只有一个时,可以省去,引用时使用 it 替代,如下。

Groovy 复制代码
def myFun = {
    println("myFun, $it")
}

myFun("abc") // 打印: myFun, abc

3)有返回值闭包

Groovy 复制代码
def myFun = { a, b ->
    return a + b
}

def res = myFun(3, 5)
println(res) // 打印: 8

2.2 闭包对象封装函数

​ 本节主要介绍使用闭包对象封装一个函数。

2.2.1 使用 {} 封装函数

Groovy 复制代码
void test() {
    println("test")
}

def myFun = { test() }
myFun() // 打印: test

2.2.2 使用 this.& 封装函数

1)无参函数

Groovy 复制代码
void test() {
    println("test")
}

def myFun = this.&test
myFun() // 打印: test

2)有参函数

Groovy 复制代码
void test(int a, String b) {
    println("test, $a, $b")
}

def myFun = this.&test
myFun(123, "abc") // 打印: test, 123, abc

3)有返回值函数

Groovy 复制代码
def test(int a, int b) {
    return a + b
}

def myFun = this.&test
def res = myFun(3, 5)
println(res) // 打印: 8

2.3 函数参数是闭包

1)闭包无参

Groovy 复制代码
void outFun(Closure closure) {
    closure()
}

outFun({
    println("inFun") // 打印: inFun
})

​ 当函数入参的最后一个参数是闭包时,可以将 {} 移到 () 外面(该方式称为尾随 Lambda 表达式);在不引起歧义的情况下,可以省去 (),如下。

Groovy 复制代码
void outFun(Closure closure) {
    closure()
}

outFun {
    println("inFun") // 打印: inFun
}

2)闭包有参

Groovy 复制代码
void outFun(Closure closure) {
    closure("abc")
}

outFun { a ->
    println(a) // 打印: abc
}

​ 当闭包入参个数只有一个时,可以省去,引用时使用 it 替代,如下。

Groovy 复制代码
void outFun(Closure closure) {
    closure("abc")
}

outFun {
    println(it) // 打印: abc
}

3)闭包有返回值

Groovy 复制代码
void outFun(Closure closure) {
    def res = closure(3, 5)
    println(res)
}

outFun { a, b ->
    a + b // 打印: 8
}

2.4 通过字符串调用对应函数

Groovy 复制代码
void myFun(String str, int num) {
    println("myFun, $str, $num")
}

void test(String funName, String str, int num) {
    def method = this.&"$funName"
    method(str, num)
}

test("myFun", "abc", 3) // 打印: myFun, abc, 3

3 泛型函数

​ 泛型的类型检查只存在于编译阶段,在源代码编译之后,不会保留任何关于泛型类型的内容,即类型擦除。

3.1 简单泛型函数

1)单泛型参数

Groovy 复制代码
<T> void myFun(T param) {
    println(param)
}

myFun(123)  // 打印: 123
myFun("abc")  // 打印: abc
myFun(true)  // 打印: true
myFun(null)  // 打印: null

2)多泛型参数

Groovy 复制代码
<R, T, S> R myFun(T a, S b, R c) {
    println("$a, $b")
    return c
}

def res = myFun("abc", 123, true) // 打印: abc, 123
println(res) // 打印: true

3.2 类中泛型函数

Groovy 复制代码
class MyClass<T> {
    void myFun(T a) {
        println(a)
    }
}

def c1 = new MyClass<String>()
c1.myFun("abc") // 打印: abc
def c2 = new MyClass<Integer>()
c2.myFun(123) // 打印: 123

3.3 抗变、协变和逆变

​ Groovy 中不存在 Java 和 Kotlin 中的抗变、协变和逆变现象(详见 → 【Kotlin】函数)。

​ 如下,Integer 是 Number 的子类,Number 引用可以指向 Integer 对象,并且 Data 引用可以指向 Data 对象,Data 引用也可以指向 Data 对象,还可以访问、修改对象的泛型变量,这在 Java 和 Kotlin 中是不允许的。

Groovy 复制代码
class Data<T> {
    T value

    Data(T value) {
        this.value = value
    }
}

Data<Integer> data1 = new Data<Integer>(1)
Data<Number> data2 = data1
data2.value = 10f
println(data2.value) // 打印: 10.0

Data<Number> data3 = new Data<Number>(1.5f)
Data<Integer> data4 = data3
data4.value = 15
println(data4.value) // 打印: 15

3.4 泛型的界

​ Groovy 泛型中,可以为其指定上界。

1)单上界

Groovy 复制代码
class Data<T extends Number> {
    T value

    Data(T value) {
        this.value = value
    }
}

Data<Integer> data1 = new Data<Integer>(1)
Data<String> data2 = new Data<String>("abc") // 运行错误, 指定了上界为Number

2)多上界

Groovy 复制代码
class A {}
interface B {}

class C extends A implements B {}

class Data<T extends A & B> {
    T value

    Data(T value) {
        this.value = value
    }
}

def data = new Data(new C())

3.5 运行时检查泛型类型

​ Kotlin 中可以通过 inline 和 reified 关键字实现泛型类型检查(详见 → 【Kotlin】函数),它在编译阶段实现。

​ Groovy 是动态类型语言,类型检查在运行时进行,可以通过反射来实现类似的功能,如下。

Groovy 复制代码
<T> boolean isType(Class<T> type, value) {
    return type.isInstance(value)
}

println(isType(Integer, "abc")) // 打印: false
println(isType(String, "abc"))  // 打印: true

​ 声明:本文转自【Groovy】函数、闭包、泛型

相关推荐
little_fat_sheep7 小时前
【Groovy】流程控制
groovy
little_fat_sheep20 小时前
【Groovy】变量和基本数据类型
groovy
邵皮皮4 个月前
Groovy 入门
groovy
不穿铠甲的穿山甲5 个月前
gradle-tasks.register(‘classesJar‘, Jar)解析
android·java·gradle·groovy
小吴先生6666 个月前
Groovy 规则执行器,加载到缓存
java·开发语言·缓存·groovy
fananchong28 个月前
Jenkinsfile共享库介绍
jenkins·groovy·jenkinsfile·cicd·共享库
慧集通-让软件连接更简单!9 个月前
开发培训-慧集通(iPaaS)集成平台脚本开发Groovy基础培训视频
低代码·api·groovy·ipaas·系统集成·慧集通
命运之手1 年前
【Gradle】Build Multiple Android Variants in Groovy
android·groovy·package·multi-channel·multi-variant
超低空MC1 年前
Android Gradle —— 从 Groovy 快速迁移到 Kotlin DSL
android·java·开发语言·kotlin·gradle·groovy