kotlin支持操作符重載，例如我們經常用到的 + 、- 操作符，最近看一些知名三方庫用 kotlin 寫的源碼，發(fā)現代碼非常看簡潔，用了很多 Lambda 表達式，發(fā)現里面好多地方都用到了 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 字節(jié)碼文件，編譯的時候，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 類的創(chuàng)建，同時創(chuàng)建了一個單例的對象(注意該對象并不是 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 表達式的方式創(chuàng)建實現該接口的對象，寫法十分簡潔方便
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)
        }
  }
  ......
}