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 : Function {
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)
}
}
......
}