kotlin invoke操作符重载妙用

kotlin支持操作符重载，例如我们经常用到的 + 、- 操作符，最近看一些知名三方库用 kotlin 写的源码，发现代码非常看简洁，用了很多 Lambda 表达式，发现里面好多地方都用到了 invoke 操作符的重载功能。

1. invoke 的作用

重载某个类的 invoke 操作符，可以让对象像函数一样调用方法，举个例子：

class Student(var age: Int, var name: String) {

    constructor(): this(0, "")

    operator fun invoke(msg: String): String {
        println("I am ${name}, my age is ${age}, say something: ${msg}")
        return name
    }

}

在 Student 类中，重载了 invoke 方法，该方法有 1 个参数以及 1 个返回值，我们可以这样来使用：

val student = Student(20, "Jack")
//1.可以直接调用该对象的 invoke() 方法
var name = student.invoke("Nice to meet you!")
//2.也可以直接把该对象当做一个函数来调用，代码上就非常简洁了
name = student("Nice to meet you!")

2. 函数作为参数

在 kotlin 中我们可以经常看到把函数当做参数的方式，例如：

fun test(source: Int, map: (Int) -> Int): Int

该方法体内，为了调用 map 函数，我们可以有 2 种写法：

//直接调用 map.invoke 方法
fun test(source: Int, map: (Int) -> Int): Int {
    return map.invoke(source)
}

//直接通过 map 名称来调用
fun test(source: Int, map: (Int) -> Int): Int {
    return map(source)
}

看到这里，是不是与前面重载 invoke 操作符的类很像，但是这里 map 并不是一个类，那么它是怎么实现的呢。

通过查看 class 字节码文件，编译的时候，map被编译成实现接口 Function1 的匿名内部类，对 map 方法的调用实际上变成了 Function1 接口的 invoke 调用。Function1 接口的源码如下：

public interface Function1<in P1, out R> : Function<R> {
    public operator fun invoke(p1: P1): R
}

有心的同学会注意到 kotlin 内置了 Function0、Function1、Function2、......、Function22、FunctionN 等若干个接口，其实就是对应了参数的个数，所有的这种参数都会被编译成对应 Function 接口的匿名内部类。

3. 通过重载 companion object 的 invoke 方法简化接口对象生成

kotlin 中有个 companion object (俗称伴生对象) 的概念，类似 Java 中的单例，例如：

class Teacher(var age: Int, var name: String) {

    companion object {

        fun sayHello() {
            println("say hello")
        }

    }
}

Teacher 类中定义了一个 companion object，也就是说伴随着 Teacher 类的创建，同时创建了一个单例的对象(注意该对象并不是 Teacher 类的实例对象)，按照 kotlin 的约定，类名直接表示该 companion object，我们可以这样使用：

//这里 Teacher 表示 Teacher 类中定义的 companion object
Teacher.sayHello()
//这里 teacher 才是 Teacher 类的实例对象
var teacher = Teacher(40, "Jim")

明白了 companion object 的意义之后，我们再来看 invoke 有何妙用。假设有一个简单的 callback 类：

interface OnClickListener {
    fun onClick()
}
//通常我们要生成一个实现某接口的对象一般得这样写
var listener = object : OnClickListener {
    override fun onClick() {
    }
}

那么有没什么简便的方法呢，答案是肯定的，这里就用到 companion object 了：

interface OnClickListener {

    fun onClick()

    companion object {
        operator fun invoke(callback: () -> Unit): OnClickListener {
            return object : OnClickListener {
                override fun onClick() {
                    callback()
                }
            }
        }
    }

}

//这样可以直接采用 lambda 表达式的方式创建实现该接口的对象，写法十分简洁方便
var listener = OnClickListener {
    println("click callback....")
}

这里说明下原理，OnClickListener 表示 OnClickListener 类的 campanion object，我们重载了 invoke 方法，也就是说可以把他当做方法一样调用，调用该方法等同于调用其内部的 invoke 方法了，该 invoke 方法会生成一个实现 OnClickListener 接口的对象。

下面是 OkHttp 中 Interceptor 的定义：

interface Interceptor {
  @Throws(IOException::class)
  fun intercept(chain: Chain): Response

  companion object {
    /**
     * Constructs an interceptor for a lambda. This compact syntax is most useful for inline
     * interceptors.
     *
     * ```
     * val interceptor = Interceptor { chain: Interceptor.Chain ->
     *     chain.proceed(chain.request())
     * }
     * ```
     */
    inline operator fun invoke(crossinline block: (chain: Chain) -> Response): Interceptor =
        object : Interceptor {
          override fun intercept(chain: Chain) = block(chain)
        }
  }
  ......
}