kotlin - 高级特性

kotlin 上手很简单，因为可以完美支持 java ，和 java 比较像的缘故，我们熟悉下 kotlin 的语法，1-2天就能写出 java 语法式的 kotlin 代码了，但是我们绝对不能只不如此，kotlin 本身的高级特性代表着语言的发展趋势，本身也是很简单，高效的，我们必须真正熟悉 kotlin 自身的写法，不要抗拒，拥抱 kotlin，零碎东西不少，但是我们总结一下，平时多用用，也就熟悉了

本文包含以下内容：

委托
- Lazy / lateinit 延迟加载器
- Delegates 属性观察者
- map / MutableMap 委托构造函数
智能转换类型
this 表达式
typealias 类型别名
let / apply / run / with 这几个 kotlin 特有的扩展函数
in / out
return / break / continue

Lazy / lateinit

kotlin 对于 null 有着严格的使用限制，处处可见？不是，非 null 判断一直是代码的痛点，kotlin 只是把这种痛点变得对 coder 来说更有好了，但是凡事总有一利一弊不是

kotlin 为了准确定义是不是 null ，要求我们在定义全局变量，时必须显示的赋值

传统 java 中我们这样定义全局变量

public class Car {
    
    public String name ;
    
}

kotlin 中我们必须赋值，否则会报错

这里 kotlin 提供了2个选择，Lazy / lateinit ，都是延迟加载，但是有区别:

Lazy 只能修饰 val 不可变参数，等同于 java 的 final ，其次 Lazy 后跟一个 {} 复制表达式，本质是在一个工厂函数，只有在第一次调用时生效(既首席创建对象时)，常用于单例模式

val lazyValue: String by lazy {

    // println 是对象创建时初始化操作
    println("computed!")
    
    // Hello 是返回的对象
    "Hello"
}

//调用两次
println(lazyValue)
println(lazyValue)

// 第一次
computed!
Hello

// 第二次
Hello

lazy 方法本质是个 lamber 表达式，在 lazy() 中我们可以传入线程类型参数：

LazyThreadSafetyMode.SYNCHRONIZED：初始化属性时会有双重锁检查，保证该值只在一个线程中计算，并且所有线程会得到相同的值
LazyThreadSafetyMode.PUBLICATION：多个线程会同时执行，初始化属性的函数会被多次调用，但是只有第一个返回的值被当做委托属性的值
LazyThreadSafetyMode.NONE：没有双重锁检查，不应该用在多线程下

lateinit 我们可以在可以修饰任意参数，可以是 var 、 val 的，我们在声明成员变量时可以不指定具体数值，但是 lateinit 修饰的参数必须在合适的地方初始化，否则编译不会通过

我们看个例子，下面我们声明 lateinit 的参数，但是不初始化直接使用

open class News(var room: String) {

    lateinit var name: String
    lateinit var book: Book

    fun speak() {
        println(name)
    }

    fun price() {
        println(book)
        print(room)
    }
}

使用

        btn_name.setOnClickListener(View.OnClickListener {
            val news = News("book")
            news.speak()
            news.price()
        })

编译会报 UninitializedPropertyAccessException 异常，未初始化的参数不可达

这就是 Lazy 和 lateinit 的区别，lateinit 我们在使用前必须初始化才行，而 Lazy 在我们首席使用的时候才会创建对象，很像 java 中的懒汉式，饿汉式。上面的代码我们即使对 lateinit 的参数加了 !null 的判断也没用

如果在我们的代码场景中会有像 java 那样，成员变量依靠外接传递，那么 kotlin 也提供了相关写法，核心就是抛弃 kotlin 关于 null 的操作，完全还原 java 的环境，还是上面的代码

open class News(var room: String) {

    var name: String? = null
    var book: Book? = null

    fun speak() {

        if (name != null) {
            println(name!!)
        }
    }

    fun price() {
        if (book != null && room != null) {
            println(book!!)
            print(room!!)
        }
    }
}

我们就不用 lateinit 来修饰啦，在使用这个参数时添加 !! 后缀表示按照 java 语法进行，注意我们现在得进行 !null 判断啦，要不会报错的哦~

Delegates 属性观察者

Delegates 我是愿意称为属性观察者的，Delegates 下面包含一些列函数，这是 kotlin 独有的特性，允许我们在属性赋值时添加观察者，拦截器操作

我们常用的是 observable / vetoable 这2个函数

observable 可以观察参数的变化
vetoable 相当于参数拦截器，可以拦截不符合条件的复制操作
但是在这2个函数内我们都不能主动的修改参数值，代码检查会提示我们

我们来看看代码：

open class News(var room: String) {

    var title: String by Delegates.observable("title_default") { property, oldValue, newValue ->
        Log.d("AAA", "属性变化：属性名：$property  旧值：$oldValue  新值：$newValue")
    }

    var price: Int by Delegates.vetoable(100, { property, oldValue, newValue ->
        if (newValue > 100) {
            Log.d("AAA", "属性变化：属性名：$property  旧值：$newValue > 100 不符合需求不能更改数据")
            return@vetoable false
        }
        return@vetoable true
    })
}

Delegates 下属函数会提供给我们3个参数，property(参数名) / oldValue(旧值) / newValue(新值)，接收2个参数，前一个是默认值，赋值时注意数据类型；后一个接受一个对象函数用来包裹我们的代码

observable 函数没有返回值，vetoable 函数有返回值，true 表示允许参数修改，false 反之不允许，数据不会变更。这里注意我们要显式的使用 return@vetoable 退出函数，否则会出现代码穿透的问题

下面来试一下，我们给 title 和 price 赋值看看:

val news = News("book")
news.title = "AAA"
news.price = 200
Log.d("AA", "重新对 news 赋值后，news 的值：${news.price}")

属性变化：属性名：property title (Kotlin reflection is not available)  旧值：title_default  新值：AAA
属性变化：属性名：property price (Kotlin reflection is not available)  旧值：200 > 100 不符合需求不能更改数据
重新对 news 赋值后，news 的值：100

map 构造函数委托

kotlin 的这个 map 委托是用与构造函数的，生成数据的，用于 json 解析，我觉得用这个 map 做 json 解析不是好，不如 gson

map：

// map 用在类声明处，传参用
class BookData(map: Map<String, Any>) {

    val name: String by map
    val price: Int by map

    fun speak() {
        Log.d("AAA", "BookData: name = $name , price = $price")
    }
}

// 使用：
var bookData = BookData(mapOf("name" to "", "price" to 88))
bookData.speak()

map 只能修饰 val 不可变参数，那么相应的就有 MutableMap ，注意 Mutable 可变早 kotlin 已经出现在好几个地方了

MutableMap :

class BookData(map: MutableMap<String, Any>) {

    var name: String by map
    var price: Int by map

    fun speak() {
        Log.d("AAA", "BookData: name = $name , price = $price")
    }
}

MutableMap 可以操作 var 可变参数了，和 map 就是这点差距

需要注意的是，使用 map 赋值生成数据对象时，比如传入所有的属性值，没有值的也要给，要不会抛出 error，参数类型给错了也会报错

错误赋值，缺少一个属性值：

var bookData = BookData(mapOf("name" to "android"))
bookData.speak()

前面说到有人推荐使用 map 来进行 json 操作，这里我推行各位必须找资料看明白再决定是不是使用 map 这个特性

智能转换类型

kotlin 是弱类型语言，通过 var 大家都了解吧，这点和 java 不同， java 这种强类型设计早早就被时代慢慢淘汰了，到现在 var / val 这种弱类型设计已经是行业准则了，java 在 jdk 10 时也开始支持 var 了

var 的好处是语言可以自定判断数据类型，从而进行无痕式的类型转换，这点对于我们来说体验是很 nice 的，代码少了，也不会打算思路写讨厌重复的代码了，逻辑直接一气呵成，连贯舒服我婆觉得是语言进行的特点

kotlin 强制类型转换

var kkk:Any = "123"
var mmm:String = kkk as String

类型判断

var kkk:Any = "123"
var mmm:String = kkk as String
            
mmm is String

智能自动转换类型

var kkk:Any = "123"

// 不用我们自己手动写转换了吧，这是因为我们已经做了类型判断了，所以编译器认为类型安全默认给我们转了
if (kkk is String) {
    kkk.length
}

当然智能转换不是万能的，机器毕竟不是人不是，适用以下规则：

val 局部变量——总是可以，局部委托属性除外
val 属性——如果属性是 private 或 internal，或者该检查在声明属性的同一模块中执行。智能转换不适用于 open 的属性或者具有自定义 getter 的属性
var 局部变量——如果变量在检查和使用之间没有修改、没有在会修改它的 lambda 中捕获、并且不是局部委托属性
var 属性——决不可能（因为该变量可以随时被其他代码修改）

this表达式

Koltin 在作用域这块有更宽泛的使用，这点在 this 关键字的使用上可以看的很明白，比 java 的 this 使用更灵活，Kotlin 的 this 关键字可以 + @label 标签来指定 this 具体的代表对象

class A { // 隐式标签 @A
    inner class B { // 隐式标签 @B
        fun Int.foo() { // 隐式标签 @foo
            val a = this@A // A 的 this
            val b = this@B // B 的 this

            val c = this // foo() 的接收者，一个 Int
            val c1 = this@foo // foo() 的接收者，一个 Int

            val funLit = lambda@ fun String.() {
                val d = this // funLit 的接收者
            }

            val funLit2 = { s: String ->
                // foo() 的接收者，因为它包含的 lambda 表达式
                // 没有任何接收者
                val d1 = this
            }
        }
    }
}

typealias

看名字可以猜测带有别名的作用，是的，typealias 我们可以成为类型别名，听起来怪怪的，说起来其实很好理解，可以代理 interface 声明一个单方法类型的接口，不能写在 class 内，打击理解一下，写在 class 内不就成了内部类了，typealias 的有点在于可以非常省事的声明一个类似接口出来

// 在 class 外声明，作用域和平常类一样
typealias Click = (String, String) -> Int

class BookData(map: MutableMap<String, Any>) {

    fun my(click: Click) {
        click("GG", "AA")
    }

    fun test2() {
        // typealias 填参数时和函数式对象一样
        my { name, age ->
            Log.d("AA", "my 方法参数传入")
            return@my 10
        }
    }
}

let / apply / run / with

let 函数 - 可以对指定对象提供一段代码的执行，返回最后一行的对象，可以不是操作的对象

比如下面这段代码，let 接收我们新建的这个 book 对象，然后对 book 对象进行了操作，最后一行返回数据，这里可以不写 return

        var book: Book = Book("88").let {
            it.name = "-77"
            it.sex = "99"
            return@let it
        }

返回不一样的数据类型，我们接受 Book 类型的数据，最后返回 String 类型的数据

        var name: String = Book("88").let {
            it.name = "-77"
            it.sex = "99"
            return@let it.name
        }

我么你还可以结合？进行对 null 数据的操作

        Book("88")?.let {
            it.name = "-77"
            it.sex = "99"
            return@let it.name
        }

apply 函数 - 可以对指定对象进行代码扩展，然后返回这个对象，注意是这个对象，意味着不能改变对象类型，然后再配合 let 获取这个对象再进行操作

比如下面这段代码，apply 内的代码好比就是写在 Book 类型里面的，所有属性刚和方法直接掉，不像 let 还得写 let ，这是本质的不同

        var book: Book = Book("88")
                .apply {
                    name = "-77"
                    sex = "99"
                }
                .let {
                    it.name = "-77"
                    it.sex = "99"
                    return@let it
                }

let 好比 rxjava 的 map ，apple 好比 flatmap

run 函数 - run 和 apple 差不多，区别的是 run 返回的不是这个对象，而是最后一行的对象

        var name: String = Book("88")
                .run {
                    name = "-77"
                    sex = "99"
                    return@run this
                }.let {
                    it.name = "ABB"
                    return@let it.name
                }

with 函数 - 和 run 一样，区别是写法不一样

        var name: String = with(Book("88"))
        {
            name = "-77"
            sex = "99"
            return@with this
        }.let {
            it.name = "ABB"
            return@let it.name
        }

in / out

JAVA 里 List<Object> 是不能转换为 List<String> 的，但是在 koltin 中借助 in / out 就能实现

Kotlin 中的 out A 类似于 Java 中的 ? extends A，即泛型参数类型必须是 A或者 A 的子类，用来确定类型的上限
Kotlin 中的 in A 类似于 Java 中的 ? super A，即泛型参数类型必须是 B 或者 B 的父类，用来确定类型的下限

fun copy(from: List<out A>, to: List<in A>) {
    for (i in from.indices) {
        to[i] = from[i]
    }
}

return/break/continue

kotlin 的 return/break/continue 和 java 含义一样，但是比 java 扩展的是可以用 @ 标价返回的位置，直接看例子，比说强

    // 1. 和Java不同的是，这些表达式都可作为更大表达式的一部分
    val s = person.name ?: return

    //2. 和Java不同的是，在 Kotlin 中任何表达式都可以用 标签@ 来标记
    loop@ for (i in 1..100) {
        for (j in 1..100) {
            if (……) break@loop // 终止loop标记的循环
            if (……) continue@loop // 跳出loop标记的循环，继续下一次loop标记的循环
        }
    }

    // 3. 从外层函数返回
    fun foo() {
        ints.forEach {
            if (it == 0) return // 默认从foo(){}返回
            print(it)
        }
    }

    //4. 用显式标签从lambda表达式中返回
    fun foo() {
        ints.forEach lit@ {
            if (it == 0) return@lit // 标记从forEach{}返回
            print(it)
        }
    }

    // 5. 用隐式标签(与接收lambda的函数同名)从lambda表达式中返回
    fun foo() {
        ints.forEach {
            if (it == 0) return@forEach // 隐式标签forEach，从forEach{}返回
            print(it)
        }
    }

    // 6. 用匿名函数替代lambda表达式:
    fun foo() {
        ints.forEach(fun(value: Int) {
            if (value == 0) return // 从该匿名函数fun返回
            print(value)
        })
    }