Groovy函数调用

桃扇骨 2023-03-13 02:38 18阅读 0赞

### 函数声明 ###

def \[返回值类型\] 函数名：  
其中`[返回值类型]`可以省略,那么返回类型为任意对象

def int fun1() {
        println "fun1"
        return 1
    }
    
    
    def  fun2() {
        println "fun2"
        return 1
    }

*  函数不需要显示`return`  
    当一个函数返回时，默认以最后一行的对象作为返回值

def fun3() {
        println "fun3"
        //函数最后一行作为返回值
        1
    }
    
    def fun4() {
        println "fun4"
        //函数最后一行作为返回值
        "hello"
    }

### 函数的调用 ###

函数可以省略括号。

def fun5(x, y, z) {
        println "$x $y $z"
    
    }
    
    fun5 "hello", " jack", "!"

### 函数式接口和非函数式接口 ###

> 函数接口简单理解是单方法接口。

当一个`函数`需要传递一个`函数式接口`作为`参数`时，可以使用`lambda`表达式直接创建一个匿名内部类实现

interface ICallBack {
        def callback()
    }
    
    def fun7(ICallBack callBack) {
        callBack.callback()
    }
    
    
    //lambda表达式调用
    fun7 {
        println "你好啊"
    }
    //常规的构建匿名实例调用
    fun7(new ICallBack() {
        @Override
        def callback() {
            println "你好朋友们"
        }
    })

如果非函数式接口呢？  
请看如下例子:

interface ICallBack {
        def callback()
        def callback2()
        def callback3(str,str2)
        def callback4(str,str2)
    }

上面的接口有四个函数，其中`callback`和`callback2`相同参数，`callback3`和`callback4`相同参数.

在`groovy`中拥有如下语法糖，可以让你只关心相同类型函数的实现，比如我们只关心`callback`函数和`callback2`，那么我们只需要在`lambda`表达式中如下声明即可：

def fun7(ICallBack callBack) {
        callBack.callback()
        callBack.callback2()
    }
    
    //lambda表达式调用
    fun7  ({it->
        println "hello world $it"
    } as ICallBack)

输出：

hello world null
    hello world null

但是你无法只单独关心`callback`函数，因为`callback`和`callback2`相同参数执行器无法确定到底lambda表达式实现的是哪一个具体函数。

我们如果只关心`callback3`和`callback4` 可以使用如下语法：

def fun7(ICallBack callBack) {
        callBack.callback3("hello","world")
        callBack.callback4("hello","world")
    }
    
    ICallBack iCallBack = {p1,p2->
        println "hello world $p1 $p2"
    } as ICallBack
    //lambda表达式调用
    fun7 iCallBack

输出：

hello world hello world
    hello world hello world

### 默认参数 ###

在`groovy`可以使用默认参数减轻重载代码负担。

def myfun(x = 1, y = 2, c) {
        println "$x $y $c"
    }
    //这里x="a" y="b" c="c"
    myfun("a", "b", "c")
    //这里x="a" y="2" c="c"
    myfun("a", "c")
    //x=1 y=2 c="c"
    myfun("c")

### 参数map问题 ###

def myfun(x, y, c) {
        println "x= $x  y= $y c= $c"
    }
    
    myfun("a", age: "2", name: "小明", "c")

我们看到有一串特殊的参数 `age: "2", name: "小明"` 这个不是`map`吗？是不是把`map`赋值给`y`？  
我们运行查看结果:

x= [age:2, name:小明]  y= a c= c

很显然不符合预期，这个也是`groovy`比较诡异的地方。  
这个仅仅是一个硬性语法：当函数参数存在如下写法 `xxx:yyy,zzz:dddd`时，函数第一个参数必须为`map`类型，且 `xxx:yyy,zzz:dddd`无论写在函数何处位置都会强制赋值给第一个形参。

再看一个例子

def myfun( x, y, c) {
        println "x= $x  y= $y c= $c"
    }
    
    //我们把map 放最后
    myfun("a", "c",age: "2", name: "小明")

输出：

x= [age:2, name:小明]  y= a c= c

当然这里有同学要问了，如果我第三个参数就要`map`类型怎么办?请在map外面加`[]`  
如下：

def myfun( x, y, c) {
        println "x= $x  y= $y c= $c"
    }
    
    //我们把map 放最后，且外面加了[ ] 
    myfun("a", "c",[age: "2", name: "小明"])

输出：  
`x= a y= c c= [age:2, name:小明]`

这里不需要深究为什么是这样，语法罢了。

### 可变参数： ###

def test(String name, ... arg) {
        println(arg)
    }
    
    def test2(String name, Object[] arg) {
        println(arg)
    }
    
    test("a", 1, 23)
    test2("a", 1, 23)

当元素的最后一个是数组时自动转化为可变参数类型

以上输出：

[1, 23]
    [1, 23]