Groovy函数调用

函数声明

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]