Kotlin 小细节记录（5）

83.Kotlin语言的继承与重载的open关键字
84.Kotlin语言的类型转换
85.Kotlin语言的智能类型转换
86.Kotlin语言的Any超类
87.Kotlin语言的对象声明
88.Kotlin语言的对象表达式
89.Kotlin语言的伴生对象
90.Kotlin语言的嵌套类
91.Kotlin语言的数据类
92.Kotlin语言的copy函数
93.Kotlin语言的解构声明
94-Kotlin语言的运算符重载
95-Kotlin语言的枚举类
96-Kotlin语言的枚举类定义函数
97-Kotlin语言的代数数据类型
98-Kotlin语言的密封类
99-数据类使用条件

open 声明class, is 和 as 关键字 作为检查和转换操作

kotlin 默认创建一个Class情况的class是底层：public final class 拒绝继承
如果想要可以后续继承使用，需要在前面添加open 关键字

open class Parent(var name:String){
   fun show() = println("$name")
}


class Children(var childName:String):Parent(childName){
    fun show2() {
        println("parent:$name,child:$childName")
    }
}

fun main() {
    val p:Parent = Children("zcwfeng")
    println(p.name)
    val c = Children("david")
    if(c is Parent){
        val c2:Parent = c as Parent
        println(c2.show())
    }
}

is 和 as 关键字

安全非空操作

val x: String? = y as? String

Kotlin 在编译时确保涉及泛型的操作的类型安全，而在运行时，泛型类型的实例不保存有关其实际类型参数的信息。
List<Foo> 被删除为 List<*>。 通常，无法在运行时检查实例是否属于具有某些类型参数的泛型类型。
因此，编译器禁止由于类型擦除而无法在运行时执行的 is-check，例如 ints is List<Int> 或 list is T（类型参数）。 可以根据星形投影类型检查实例：【Any?】
koltlin 类型推断，进行了只能转换 【handleStrings】

if (something is List<*>) {
    something.forEach { println(it) } // The items are typed as `Any?`
}

val something = listOf("a","b")
    if(something is List<*>){
        println(something)
    }


fun handleStrings(list: List<String>) {
        if (list is ArrayList) {
            // `list` is smart-cast to `ArrayList<String>`
        }
    }

Reified 需要和inline 内联函数一起用

上面说到open，和类型转换提到了泛型转换

【 Reified 允许您在使用泛型来进行编程的同时，还能够在运行时获取到泛型所代表的类型信息，这在之前是无法做到的。当您需要在内联函数中使用到类型信息，或者需要重载泛型返回值时，您可以使用 reified。使用 reified 不会带来任何性能上的损失，但是如果被内联的函数过于复杂则，还是可能会导致性能问题。因为 reified 必须使用内联函数，所以要保证内联函数的简短，并且遵循使用内联函数的最佳实践，以免让性能受到损失。】

inline fun <reified A, reified B> Pair<*, *>.asPairOf(): Pair<A, B>? {
    if (first !is A || second !is B) return null
    return first as A to second as B
}


    val somePair: Pair<Any?, Any?> = "items" to listOf(1, 2, 3)
    val stringToSomething = somePair.asPairOf<String, Any>()
    val stringToInt = somePair.asPairOf<String, Int>()
    val stringToList = somePair.asPairOf<String, List<*>>()
    val stringToStringList = somePair.asPairOf<String, List<String>>()
    println("somePair -> ${somePair}")
    println("stringToSomething -> ${stringToSomething}")
    println("stringToInt -> ${stringToInt}")
    println("stringToList -> ${stringToList}")
    println("stringToStringList -> ${stringToStringList}")