适合有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())
}
