Kotlin函数和对象

1.高阶函数

如果一个函数的参数是函数类型或者返回值是函数类型，那么这个函数就是高阶函数。
在kotlin中函数也是有类型的，跟整型、字符串类型是同样的性质，函数类型就是将函数的“输入参数类型”和“返回值类型”的抽象表达，如（Int，Int）-> Int

2.扩展函数

kotlin允许为现有的类添加新方法，这就叫拓展函数。扩展函数在语法上看起来就像是类的原生方法一样，但实际上是在类的外部定义，因此，它不能访问类的私有或受保护的成员，同时也不能在类的内部调用。拓展函数可以搭配高阶函数一起使用，组成拓展高阶函数。如下是给SharedPreferences拓展了一个edit高阶函数：

    // 定义扩展高阶函数
    // 并且函数接收类型是SharedPreferences.Editor，即高阶函数内部自带SharedPreferences.Editor的上下文
    //扩展函数可以在其他类中被调用，允许导包的方式，把这个函数导入到其他类中；并且可以使用as来做重命名，如：import com.coolweather.coolweatherjetpack.data.db.WeatherDao.edit as customEdit
    fun SharedPreferences.edit(action: SharedPreferences.Editor.() -> Unit) {
        var editor = edit()
        action(editor)
        editor.apply()
    }

3.内联函数

当函数被标记为inline时，表示这是一个内联函数，编译器会尝试在调用该函数的地方直接插入函数的实现代码，而不是生成调用函数的代码，从而消除函数调用的开销。这种优化在小型、频繁被调用的函数特别有用，提到执行的效率。
但是内联函数并不一定总是被内联，编译器会根据函数的体积、被调用的频率来决定是否直接生成函数代码。同时，内联函数也会导致代码膨胀，导致代码体积变大，因此需要谨慎使用。
例如如下函数：

inline fun maxOf(a: Int, b: Int): Int {
    return if (a > b) a else b
}

当maxOf被调用的时候，编译器会选择直接在调用点插入if (a > b) a else b这段代码。
又例如高阶函数：

// 使用inline的高阶函数
inline fun fooInline(block: () -> Unit) {
    block()
}
// 假如多次调用
fun testInlined() {
    var i = 0
    fooInline {
        fooInline {
            fooInline {
                fooInline {                   
                     i++                         
                }
            }
        }
    }
}

根据内联函数的原理，上面的函数在编译后等价于：

fun testInlined() {
	var i = 0
	i++
}

4.闭包

在kotlin中，闭包就是能够读取其他函数内部变量的函数。闭包可以理解为定义在一个函数内部的函数，是将函数内部和函数外部链接起来的桥梁。
在kotlin中，闭包和Lambda表达式和匿名函数紧密相关，这些概念在kotlin中是相同的。由于闭包的存在，让函数成为了kotlin的一等公民，拥有了变量所拥有的特权，如：可以在函数内部定义函数、函数可以作为参数传递、函数可以作为函数的返回值等。
例如，我们有一个函数，它接受一个函数作为参数，并在函数内部调用这个传递进来的参数函数。这个被传递的参数函数就是一个闭包，它可以访问外部函数的变量：

/**
     * 闭包示例，返回类型为一个函数
     */
    fun testMethod1() : () -> Int {
        var a = 20
        var b = 30
        // 返回一个匿名函数
        return {
            a ++  //修改作用域外的变量
            a + b
        }
    }

    fun testMethod2() {
        var m = testMethod1()
        println(m())
    }

5.伴生对象

伴生对象在kotlin中使用companion object关键字定义，它允许在不创建类的实例的情况下访问类的属性和方法。kotlin中没有静态成员的概念，为了弥补这一功能的缺失，kotlin中引入了伴生对象的概念。

class MyClass {
    companion object {
        // 伴生对象的属性和方法
        const val CONSTANT = "Constant Value"
        
        fun printConstant() {
            println(CONSTANT)
        }
    }
    
    // 类的其他属性和方法
    fun doSomething() {
        // ...
    }
}

// 使用伴生对象
MyClass.CONSTANT // 访问伴生对象的属性
MyClass.printConstant() // 调用伴生对象的方法

6.单例模式

使用object ClassName的方式，可以实现饿汉式单例模式；
通过私有化构造器，使用伴生对象的方式，可以实现懒汉式单例模式，同时允许在获取单例对象的时候传入参数

参考文章《Kotlin 高阶函数详解》，链接：https://zhuanlan.zhihu.com/p/495402574