Kotlin基础（拓展函数，委托，Object）

适合有java基础的，获取kotlin基础知识/语法等，Kotlin精讲-黑马程序员（原创）的学习笔记。

1. 拓展函数

// 拓展函数的写法
fun AnyClass.funName(params): returnType {
    // method body
}

如果kotlin里面，子类和父类拥有同名的拓展方法会是怎样呢？
==>Kotlin的拓展函数则不存在子类优先（多态）的原则。Kotlin的拓展函数是静态解析的，完全由当前变量的类型决定（不使用多态特性！）。

如果kotlin里面，类本身的成员函数和拓展函数同名会怎样呢？
==>遵循成员函数优先的原则。

2. 拓展属性

// 拓展属性的写法
val/var AnyClass.propertyName: PropertyType
getter
setter

ps: IDE小技巧，拓展函数/属性 输入 exfun, exvar, exval 会列出相应框架待填充。

3. 委托

委托模式也叫代理模式，是最常用的设计模式的一种。在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。委托模式已证明是实现继承的一个很好的替代方式。
Kotlin 通过关键字 by 实现委托。
Kotlin中委托分为 （委托类） 和 （委托属性），Kotlin官方库也封装了一些常用的委托。

3.1 委托类

// （委托类）
interface IWash {
    fun wash()
}

class BigSon : IWash {
    override fun wash() {
        println("bigSon wash...")
    }
}

// 代理模式/委托模式 （委托类）
class SmallFather(private val iWash: IWash): IWash by iWash

fun main(args: Array<String>) {
    val bigSon = BigSon()
    val smallFather = SmallFather(bigSon)
    // 围裙妈妈让小头爸爸洗碗
    println("叮嘱大头儿子洗碗认真点")
    smallFather.wash()
    println("检查大头儿子洗碗是否干净")
}

3.2 委托属性

val/var propertyName: propertyType by <expression>

class BigSon {
    // IDE会提示生成SmallFather的成员函数
    var luckyMoney: Int by SmallFather()
}

class SmallFather {
    var sonLuckyMoney: Int = 0

    // getValue方法，在BigSon中IDE会提示生成SmallFather的成员函数
    operator fun getValue(bigSon: BigSon, property: KProperty<*>): Int {
        println("SmallFather#getValue, ${property.name}")
        return sonLuckyMoney
    }

    // setValue方法，在BigSon中IDE会提示生成SmallFather的成员函数
    operator fun setValue(bigSon: BigSon, property: KProperty<*>, value: Int) {
        println("SmallFather#setValue, ${property.name} => $value")
        sonLuckyMoney = value
    }
}

fun main(args: Array<String>) {
    val bigSon = BigSon()
    bigSon.luckyMoney = 100
    bigSon.luckyMoney -= 50

    println("son's luckyMoney is ${bigSon.luckyMoney}")
}

==>
SmallFather#setValue, luckyMoney => 100
SmallFather#getValue, luckyMoney
SmallFather#setValue, luckyMoney => 50
SmallFather#getValue, luckyMoney
son's luckyMoney is 50

3.3 五大内置委托

3.3.1 延迟加载（Lazy）

lazy()是一个函数, 接受一个Lambda表达式作为参数, 返回一个Lazy类型的实例,这个实例可以作为一个委托, 实现延迟加载属性(lazy property):

val normalValue = "normal value"
// lazy变量的声明(var也可以)
// 第一次调用 get() 时, 将会执行 lazy() 函数的Lambda 表达式，以后调用直接返回结果（最后一行）
val lazyValue: String by lazy {
    println("init lazyValue only once")
    "Hello lazy"
}

fun main(args: Array<String>) {
    println(normalValue)
    println(lazyValue)
    println(lazyValue)
}

3.3.2可观察属性（Observable）

// 语法结构
var 变量: 变量类型 by Delegates.observable(变量初始化值) {
    propety, oldValue, newValue ->
        doSth..（可以多行）
}

3.3.3 Vetoable（veto:否决）

// 语法结构
var 变量: 变量类型 by Delegates.vetoable(变量初始化值) {
    propety, oldValue, newValue ->
        doSth..（可以多行）
        // true，变量会被修改；false，变量不会被修改
        true/false 
}

3.3.4 notNull

对于一个不可为“non-null”的变量，我们需要保证它被正确的赋值。赋值操作可以在变量定义的时候，也可以后续代码里面进行赋值。我们只需要在变量后面使用notNull属性委托，编译器就允许我们后续进行赋值。

// 语法结构
var 变量: 变量类型 by Delegates.notNull<变量类型>()
// 或者lateinit， #lateinit不能修饰可空变量类型，且不能修饰基本类型（将变量值置null）
lateinit var 变量: 变量类型

class User {
    // property must be initialized
    // 因为我们使用了notNull的属性委托，所以编译器允许“name”后续进行赋值。
    var name: String by notNull<String>()
}

fun main(args: Array<String>) {
    val user = User()
    // user.name并没有进行赋值，运行时会报错！
    // Exception in thread "main" java.lang.IllegalStateException: Property name should be initialized before get.
    println(user.name)
}

3.3.5 将多个属性保存在一个map内

Kotlin的map委托，提供了map和对象一一绑定关系，就是map的值可以决定对象的值，修改map的值也可以影响对象的值。但是这一切需要满足，map的key和属性的名称保证一致。

// 语法结构
val/var 变量: 变量类型 by 实现集合类Map接口的对象

class User(map: MutableMap<String, Any>) {
    var name: String by map
    var age: Int by map
}

fun main(args: Array<String>) {
    val map = mutableMapOf(
            "name" to "jerry",
            "age" to 4
    )
    val user = User(map)
    println(user.name)
    map["name"] = "Jerry"
    println(user.name)
    println(user.age)
}

4. Object关键字（单例，创建匿名对象，创建伴生对象）

4.1 单例

在Kotlin中，只要通过object关键字就能实现单例，简洁高效。

object Dog {
    var name: String = ""
    var age: Int = 1
}

fun main(args: Array<String>) {
    // ^^^不是 Dog()^^^
    val dog1 = Dog
    val dog2 = Dog
    // dog1, dog2 同一个对象
    println(dog1)
    println(dog2)
}

4.2 创建匿名类对象

interface OnClickListener {
    fun onClick()
}

class ImageButton {
    private var listener: OnClickListener? = null
    fun setOnClickListener(listener: OnClickListener) {
        this.listener = listener
    }
}

fun main(args: Array<String>) {
    val button = ImageButton()
    // object创建匿名类对象（实现接口，也可以继承类）
    button.setOnClickListener(object : OnClickListener {
        override fun onClick() {
            println("...#onClick...")
        }
    })
}

object声明的对象，除了实现某一个接口、继承某一个类，还可以既不实现接口，也不继承类。

fun main(args: Array<String>) {
    // 直接声明一个匿名类
    val person = object {
        var name: String = "Jerry"
        var age: Int = 4
    }
    println("person's name is ${person.name}")
    println("person's age is ${person.age}")
}

4.3 创建伴生对象

interface ITest

open class C

class A {
    var a: String = ""
    // 伴生对象可以继承类，实现接口； 
    // B 可以省略
    companion object B: C(), ITest {
        var b: String = "Jerry"
        fun bFun() {
            println("..#bFun()..")
        }
    }
}

fun main(args: Array<String>) {
    // 访问伴生对象的属性的2种方式
    println(A.b)
    println(A.B.b)
    // 访问伴生对象的方法的2种方式
    println(A.bFun())
    println(A.B.bFun())
}

参考：
Kotlin精讲-黑马程序员（原创）