Koltin第七讲---函数定义

内容简介

个人认为 Kotlin 函数的设计属于改动最多，也最为惊艳的。尤其是函数可以以参数形式传递，为后续带来了更多的发挥空间。以及巧妙的运用 Lambda （其实就是个对象）表达式，将 Java 中的很多不可能变成了可能。接下来我们来揭开函数的面纱。

函数定义

我们要如何定义函数呢？在 Kotlin 中函数定义，不再和 Java 一样。而是通过 fun 修饰符修饰。并且定义过程中有很多的新的功能。

简单的定义函数&调用

/**	
 * 定义函数	
 */	
fun function(){	
    println("调用")	
}	
fun main() {	
    // 函数调用	
    function()	
}

函数定义行参&返回值

定义一个函数，若需要行参使用 fun函数昵称(行参1:类型,行参2:类型) 声明即可。若需要返回值要在函数后方增加 :返回类型 即可。

/**	
 * 定义一个 call 方法,接收 value 行参. 返回 int 类型	
 */	
fun call(value: String): Int {	
    return value.toInt()	
}

函数默认参数

记得类的定义讲过的默认值功能吗？我们定义的主构造方法的时候，可以为成员变量添加默认值。 Kotlin 中也可以为函数的行参增加默认值。

/**	
 * 定义一个 call 方法 参数默认值为 100,若不传值默认值为 100	
 */	
fun call(value: String = "100"): Int {	
    return value.toInt()	
}

补充一点，函数默认值功能只能在 Kotlin 中使用，若 Java 调用 Kotlin是无效的（老老实实传参吧）。

可变参数

在 Java 中也具有可变参数，只需要在定义行参的时候，使用 类型...变量昵称 定义即可（本质是数组）。在 Kotlin 也具有可变参数，只需要对行参通过 vararg 修饰即可。

/**	
 * 定义一个可变参数 args	
 */	
fun call(name: String, vararg args: String) {	
}

接下来我们看看 Kotlin 中可变参数的本质是什么东东。我尝试传入数组能成功吗？经过本人尝试，我分别传了数组&集合都在编译器就直接报错了，奇怪难道 Kotlin 的可变参数本质难道不是数组？

我尝试用 Java 的代码调用 Kotlin 的可变参数方法，发现可以调用成功，并且查看了反编译后的代码，发现本质还是数组。

public class Demo {	
    public static void main(String[] args) {	
        String[] arrays = {"1", "2", "3"};	
        // 没有报错	
        KotKt.call("阿文",arrays);	
    }	
}

上面的问题一直困扰我很久，由于这个可变参数用处不多，我也就没有在意。直到有一天我用 Kotlin 编写动态代理的时候，遇到了这样的问题。

请看下方代码：

/**	
 * 定义接口	
 */	
interface CallI {	
    fun call(value: String): Int	
}	
fun main() {	
    // 动态代理	
    val call =	
        Proxy.newProxyInstance(	
            ClassLoader.getSystemClassLoader()	
            , arrayOf(CallI::class.java)	
            , object : InvocationHandler {	
                override fun invoke(proxy: Any?, method: Method?, args: Array?): Any? {	
                    // 拦截 call 方法,定义代码.其它方法都调用 InvocationHandler 的方法	
                    return if (method?.name == "call") {	
                        (args!![0] as String).toInt()	
                    } else method?.invoke(this, args)	
                }	
            }) as CallI	
    // 我调用 toString 方法	
    call.toString()	
}

报错内容：

Exception in thread "main" java.lang.IllegalArgumentException: wrong number of arguments

我尝试看了下 method?.invoke(this,args) 的 invoke 方法第二个参数的确是可变参数，我传入的是 Kotlin 的数组类型，最终报错了。最终找到了问题 Kotlin 中对可变数组的类型限制还是挺严格的，虽然本质上它是数组，但是 Kotlin 就是不让你直接传递数组（应该是为了代码上的歧义吧）。我们只需要在数组的前面加入一个 * 即可，将数组变成可变数组。

/**	
 * 定义一个可变参数 args	
 */	
fun call(name: String, vararg args: String) {	
}	
fun main() {	
    val array = arrayOf("1", "2")	
    // 注意我前面加了一个 * 哦,理解为：将数组变成一个可变数组吧	
    call("阿文", *array)	
}

具名参数

前面讲了 可变参数 与 函数默认参数 ，其实也是为具名参数做了铺垫。Java 中的可变参数，有一个硬性规定可变参数只能定义在最后一个（想想也是，不然怎么区分哪些参数属于可变的）。在 Kotlin 中也有这种问题，并且默认函数默认值也会出现这种问题，例如我将函数的中间的一个参数定义成有默认值的，当使用中间函数的默认值功能，就不知道该如何传值了。Kotlin 提供了一种具名参数的功能，我们只需要在传参的时候，使用 参数昵称=参数值 即可。

/**	
 * 可以看到我第一个参数具有默认值,我们如何调用呢?	
 */	
fun call(str: String = "", msg: String): Int {	
    return str.toInt()	
}	
/**	
 * 可变参数和java的概念一致,本质也是数组,但是java中可变参数只能放在形参末尾	
 * 由于kotlin有具名参数的概念,kotlin的可变参数就没必要放在末尾了	
 */	
fun call2(vararg values: Int, msg: String) {	
    println("values:${values.size}  msg")	
}	
fun main() {	
    // 通过指定名字进行赋值	
    call(msg = "啊哈哈")	
    call2(1, 2, 3, msg = "msg消息")	
}

函数嵌套

看完上面的内容，我想大家应该可以定义一些 Kotlin 的函数了吧。接下来我们来看看 Kotlin 比较重要的特性以及原理。在 Kotlin 中可以函数中嵌套定义函数，在 Java 中这是不可能实现的。

/**	
 * 定义函数嵌套	
 */	
fun test(n: Int) {	
    fun print(value: String) {	
        println(value)	
    }	
    // 调用嵌套函数	
    print(n.toString())	
}	
fun main() {	
    test(18)	
}

啥原理呢？其实在编译器编译的时候，会将函数的内部函数。编译生成一个实现 FunctionN 类，并且有一个重写了 invoke 方法，创建了一个静态对象，然后 invoke 方法就是嵌套函数的实现。别小看这一改动，这一改动是 Kotlin 中函数的精髓， Kotlin 的 Lambda 表达式丶函数式编程丶函数以参数传递，以及后续的 DSL 都和这个有一定关系。

反编译源码：

public static final void test(int n) {	
    // 看到没 内部的嵌套的函数编译成了一个 DemoKt$test$1 类	
    DemoKt$test$1.INSTANCE.invoke(String.valueOf(n));	
}	
public static final void main() {	
    test(18);	
}

DemoKt$test$1源码：

// 只有这里为啥是 Function1 这个 1 又是什么含义。在 Lambda 篇章中会详细讲解	
final class DemoKt$test$1 extends Lambda implements Function1 {	
    。。。。不重要的删除掉了	
    // 创建了一个静态对象	
    public static final DemoKt$test$1 INSTANCE = new DemoKt$test$1();	
    // 嵌套方法的函数体	
    public final void invoke(@NotNull String value) {	
        Intrinsics.checkParameterIsNotNull(value, "value");	
        System.out.println(value);	
    }	
}

这里讲到一个 FunctionN，当且大家就需要知道是一个接口，接口中定义了一个方法 invoke。后续的 Lambda 会详细讲解

函数当参数传递

在 C & C++ 中有函数指针的概念，由于 Java 中去除了复杂的指针的概念，因此 Java 中我们的定义的函数不可以以参数传递的，只能出传递对象（所有的 CallBack 回调都是这样的形式）。

Kotlin 中没有这种约束，如果要传递一个定义好的 fun 函数，可以通过 :: 关键词，就能取 fun 函数的函数指针（函数指针，我是这么叫的啦，嘿嘿！），这个其实在高阶函数中经常使用。

/**	
 * 定义一个函数	
 * 这里用类一个缩写,只要函数只有执行一句代码,就可以这样写	
 */	
fun funPrint(msg: String) = println(msg)	
/**	
 * 高潮部分,函数传递	
 * (这里说了提前预备了下Lambda的知识,先不要考虑Function1是个什么东东,只管是个函数类型的对象吧)	
 *	
 */	
fun funCall(tag: String, funParameter: Function1) {	
    // 调用传入的函数	
    funParameter("tag:$tag")	
}	
fun main() {	
    /**	
     * 通过::获取函数的指针	
     */	
    val f = ::funPrint	
    /**	
     * 传递函数	
     */	
    funCall("阿文", f)	
}

接下来我们用 Java 的角度分析下，是如何实现的呢？funCall 方法的第二个参数类型是 Function1 它本质是一个接口，在后续的 Lambda 中会详细讲解这里接口。我们先来看看 main 方法。

public static final void main() {	
    // 第二个参数 DemoKt$main$f$1.INSTANCE 他是一个什么呢？	
    funCall("阿文", DemoKt$main$f$1.INSTANCE);	
}	
public static final void funCall(@NotNull String tag, @NotNull Function1 funParameter) {	
    sb.append("tag:");	
    sb.append(tag);	
    // 调用了 funCall invoke 方法	
    funParameter.invoke(sb.toString());	
}

final /* synthetic */ class DemoKt$main$f$1 extends FunctionReference implements Function1 {	
    ...我删除了部分源码	
    // 是个静态单例	
    public static final DemoKt$main$f$1 INSTANCE = new DemoKt$main$f$1();	
    // 对应的执行方法，	
    public final void invoke(@NotNull String p1) {	
        Intrinsics.checkParameterIsNotNull(p1, "p1");	
        // 注意这里就是传入的需要调用的函数	
        DemoKt.funPrint(p1);	
    }	
}

通过上面分析可知，其实将函数变为参数传递，本质是新生成了一个实现 FunctionN 的类，并且重写了 invoke 方法。而 invoke 的函数体做的就是传入函数的函数调用。（是不是和函数嵌套有一些类似啊？只是函数体不同） 所以本质上函数嵌套与函数参数传递，都是传递了一个实现 FunctionN 对象（后续的 Lambda）也是一样的哦。

推荐阅读

--END--

识别二维码，关注我们