Kotlin | 6.Kotlin 的类型系统

        /**-------------------- 6.1.1 可空类型 ? ----------------------*/
        // Kotlin和Java最重要的区别：对可空类型的显式的支持。

        /*java*/
//        int strLen(String s){
//            return s.length()
//        }

        fun strLen(s: String) = s.length
        // 在编译器会标记成错误（这个函数中的参数被声明成String类型，在Kotlin中这表示它必须包含一个String实例）
//        strLen(null)

        // 如果允许调用这个方法的时候传给它所有的可能的实参，包括null，需要显示地在类型名称后面加上问号来标记它：
        fun strLenSafe(s: String?) = {}
        // Type? = Type or null

        val e: String? = null
//        val f: String = null // 错误
//        strLen(e)// 错误

        // 代码清单6.1 使用if检查处理null
        fun strLenSafe2(s: String?): Int = if (s != null) s.length else 0
//        fun strLenSafe2(s: String?): Int = s?.length ?: 0
        strLenSafe2(e)// 0
        strLenSafe2("sss")// 3

        /**-------------------- 6.1.2 类型的含义 ----------------------*/
        /*
        * 类型就是数据的分类......决定了该类型可能的值，以及该类型的值上可以完成的操作
        * 可空和非可空的对象在运行时没有什么区别；
        * 可空类型并不是非空类型的包装。
        * 所有的检查都发生在编译期。这意味着使用Kotlin的可空类型并不会在运行时带来额外的开销
        */

        /**-------------------- 6.1.3 安全调用运算符: ?. ----------------------*/
        // ?. 它允许你把一次null检查和一次方法调用合并成一个操作
        val ok: String? = null
        println(ok?.toUpperCase())// null
        println(
                if (ok != null) {
                    ok.toUpperCase()
                } else null
        )
        // 这次调用的结果类型也是可空的。
        fun printAllCaps(s: String?) {
            // allCaps可能也是null
            val allCaps: String? = s?.toLowerCase()
            println(allCaps)
        }

        // 安全调用不光可以调用方法，也能访问属性。
        // 代码清单6.2 使用安全调用处理可空属性
        class Employee(val name: String, val manager: Employee?)

        fun managerName(employee: Employee): String? = employee.manager?.name
        val ceo = Employee("Da Boss", null)
        val developer = Employee("jingbin", ceo)
        managerName(ceo)// null
        managerName(developer)// Da Boss

        // 代码清单6.3 链接多个安全调用
        class Address(val streetAddress: String, val zipCode: Int, val city: String, val country: String)

        class Company(val name: String, val address: Address?)
        class Person(val name: String, val company: Company?)

        fun Person.countryName(): String {
            val country = this.company?.address?.country
            return if (country != null) country else "unKnow"
//            return country ?: "unKnow"
        }

        val person = Person("beijing", null)
        println(person.countryName())// unKnow

        /**-------------------- 6.1.4 Elvis运算符 ?: ----------------------*/
        // kotlin中有方便的运算符来提供null的默认值。
        fun foo(s: String?) {
            // 如果 s 为null，结果是一个空的字符串
            val t: String = s ?: ""
        }

        // 代码清单6.4 使用Elvis运算符处理null值
        fun strLenSafe3(s: String?): Int = s?.length ?: 0
        println(strLenSafe3("aaa"))// 3
        println(strLenSafe3(null))// 0

        // 代码清单6.5 同时使用throw和Elvis运算符
//        class Address(val streetAddress: String, val zipCode: Int, val city: String, val country: String)
        fun printShipping(person: Person) {
            // 缺少address就抛出异常
            val address = person.company?.address ?: throw IllegalArgumentException("No address")
            // 使用with函数避免在这一行中重复使用四次address
            with(address) {
                println(streetAddress)
                println("$zipCode $city $country")
            }
        }

        val address = Address("高新区", 1000, "武汉", "中国")
        val company = Company("keji", address)
        val person1 = Person("jingbin", company)
        printShipping(person1)
        printShipping(Person("jingbin", null))// java.lang.IllegalArgumentException:No address


        /**-------------------- 6.1.5 安全转换 as? ----------------------*/
        // as? 运算符尝试把值转换成指定的类型，如果值不是合适的类型就返回null
//        foo as? Type
//        foo is Type --- foo as Type
//        foo !is Type --- null

        // 代码清单6.6 使用安全转换实现equals
        class Person2(val firstName: String, val lastName: String) {
            override fun equals(o: Any?): Boolean {
                // 检查类型，如果不匹配就返回false
                val otherPerson = o as? Person2 ?: return false
                // 在安全转换后，变量otherPerson被智能转换为Person类型
                return otherPerson.firstName == o.firstName && otherPerson.lastName == o.lastName
            }

            override fun hashCode(): Int = firstName.hashCode() * 37 + lastName.hashCode()
        }

        val p1 = Person2("jing", "bin")
        val p2 = Person2("jing", "bin")
        // == 运算符会调用equals方法
        println(p1 == p2)// true
        println(p1.equals(12))// false


        /**-------------------- 6.1.6 非空断言 !! ----------------------*/
        // 有时候你并不需要Kotlin的这些支持来处理null值，你只需要直接告诉编译器这个值实际上并不是null。
        // 非空断言是Kotlin提供最简单直率的处理可空类型值的工具。
//        foo!!
//        foo != null  ---  foo
//        foo == null  ---  NullPointerException

        // 代码清单6.7 使用非空断言
        fun ignoreNulls(s: String?) {
            // 异常在这一行：告诉编译器 我知道这个值不为null，如果我错了我准备好了接收这个异常
            val sNotNull: String = s!!
            println(sNotNull.length)
        }
//        ignoreNulls(null)

        // 代码清单6.8 在Swing action中使用非空断言
//        class CopyRowAction(val list: JList<String>) : AbstractAction {
//            override fun isEnabled(): Boolean = list.selectedValue != null
        // 只会在isEnabled返回 true 时调用
//            override fun actionPerformed(e: ActionEvent) {
//                val selectedValue = list.selectedValue!!
//            }
//        }

        // 不要写这样的代码，因为不知道 跟踪信息只表明异常发生在哪一行代码
        person1.company!!.address!!.country


        /**-------------------- 6.1.7 let 函数 ----------------------*/
        /*
        * let函数让处理可空表达式变得更容易，和安全调用运算符一起，它允许你对表达式求值，检查求值结果是否为null，并把结果保存为一个变量。
        * 所有这些变动都在同一个简洁的表达式中。
        * let 函数做的所有事情就是把一个调用它的对象编程lambda表达式的参数。
        */
//        foo?.let {
//            ...it...
//        }
//        foo !=null // 在lambda内部it是非空的
//        foo ==null // 什么都不会发生

        // 代码清单6.9 使用let调用一个接受非空参数的函数
        fun sendEmailTo(email: String) {
            println("Sending email to $email")
        }

        val email: String? = "jingbin@qq.com"
        // let函数只在email的值非空时才会被调用
        email?.let { sendEmailTo(it) }

        val email2: String? = null
        // 不会被调用
        email2?.let { sendEmailTo(it) }

//        val person3 : Person? = getTheBestInWord()
//        if (person3!=null) sendEmailTo(person3.email)
        // 等同于
//        getTheBestInWord()?.let{sendEmailTo(it.email)}


        /**-------------------- 6.1.8 延迟初始化的属性 ----------------------*/

        //代码清单6.10 使用非空断言访问可空属性
//        open class MyService {
////            fun performAction(): String = "foo"
////        }
////        class MyTest {
////
////            // 声明一个可空类型的属性并初始化为null
////            private var myService: TypeSystem1Activity.MyService? = null
////
////            @Before
////            fun setUp() {
////                // 在setUp方法中提供真正的初始化器
////                myService = TypeSystem1Activity.MyService()
////            }
////
////            @Test
////            fun testAction() {
////                // 必须注意可空性：要么用!!，要么用?.
////                Assert.assertEquals("foo", myService!!.performAction())
////            }
////        }

        // 代码清单6.11 使用延迟初始化属性 lateinit
//        class MyTest2 {
//
//            // 声明一个不需要初始化器的非空类型的属性
//            private lateinit var myService: TypeSystem1Activity.MyService
//
//            @Before
//            fun setUp() {
//                // 像之前的例子一样在setUp方法中初始化属性
//                myService = TypeSystem1Activity.MyService()
//            }
//
//            @Test
//            fun testAction() {
//                // 不需要null检查直接访问属性
//                Assert.assertEquals("foo", myService.performAction())
//            }
//        }

        // 延迟初始化的属性都是var的。


        /**-------------------- 6.1.9 可空类性的扩展 ----------------------*/
        // isEmpty 是否是"" isBlank是否是Null或""

        //代码清单6.12 用可空接收者调用扩展函数
        fun verifyUserInput(input: String?) {
            // 这里不需要安全调用
            if (input.isNullOrBlank()) {
                println("isNullOrBlank....")
            }
        }
        // 接收者调用isNullOrBlank并不会导致任何异常
        verifyUserInput(null)

        /*
        * input 可空类型的值
        * isNullOrBlank() 可空类型的拓展
        * . 不需要安全调用
        */
        // 可空字符串的扩展
        fun String?.isNullOrBlank(): Boolean = this == null || this.isBlank()
        // 当你为一个可空类型(以?结尾)定义扩展函数时，这意味着你可以对可空的值调用这个函数；
        // 并且函数体中的this可能为null，所以你必须显示的检查。在可空类型的扩展函数中，this可能为null

        val person5: String? = null
        // 没有安全调用，所以 it 是可空类型
//        person5.let { sendEmailTo(it) }
        person5?.let { sendEmailTo(it) }

        /**-------------------- 6.1.10 类型参数的可空性 ----------------------*/
        // Kotlin中所有泛型类和泛型函数的类型参数默认都是可空的。

        // 代码清单6.13 处理可空的类型参数
        fun <T> printHashCode(t: T) {
            // 因为 t 可能为null，所以必须使用安全调用
            println(t?.hashCode())
        }
        // T 被推导成 Any?
        printHashCode(null)

        // 要是类型参数非空，必须要为它指定一个非空的上界，那样泛型会拒绝可空类型作为实参。
        // 代码清单6.14 为类型参数声明非空上界
        fun <T : Any> printHashCode2(t: T) {
            // T 不是可空的
            println(t.hashCode())
        }
//        printHashCode2(null)

        /**-------------------- 6.1.11 可空性和Java ----------------------*/

        // Java中的 @Nullable String 被Kotlin当做 String?，而@NotNull String就是String
        // @Nullable + Type = Type?
        // @NotNull + Type = Type

        /*
        * 平台类型
        * 平台类型本质上就是Kotlin不知道可空性信息的类型。
        * Type(Java) = Type? or Type  (Kotlin)
        */

        //代码清单6.15 没有可空性注解的 Java 类
        /*
         * public  class Person {

            private final String name;

            public Person(String name) {
                this.name = name;
            }

            public String getName() {
                return name;
            }
        }
         */
        // getName()能不能返回null? Kotlin编译器不知道可空性，需要自己处理它

        //代码清单6.16 不使用null检查访问Java类
        fun yellAt(person: JavaCode.PersonJava) {
            println(person.name.toUpperCase() + "!!!")
        }
//        yellAt(JavaCode.PersonJava(null)) // 会有异常

        // 代码清单6.17 使用null 检查来访问Java类
        fun yellAtSafe(person: JavaCode.PersonJava) {
            println((person.name ?: "Anyone").toUpperCase() + "!!!")
        }
        yellAtSafe(JavaCode.PersonJava(null))// Anyone!!!

        // 这两种都是可以的
        val person6 = JavaCode.PersonJava("222")
        val s: String? = person6.name
        val s1: String = person6.name


        /**继承*/
        // 代码清单6.18 使用String参数的Java接口
        /*Java*/
//        public  interface StringProcess {
//            void process(String value);
//        }

        // 代码清单6.19 实现Java接口时使用不同的参数可空性
        class StringPrint : JavaCode.StringProcess {
            override fun process(value: String) {

            }
        }

        class StringPrint2 : JavaCode.StringProcess {
            override fun process(value: String?) {
                if (value != null) {
                    println(value)
                }
            }
        }

        /**-------------------- 6.2.1 基本数据类型：Int、Boolean及其他 ----------------------*/

        // Kotlin并不区分基本数据类型和包装类型，使用的永远是同一类型：(如:Int)
        val i: Int = 1
        val listOf: List<Int> = listOf(1, 2, 3)

        fun showProgress(progress: Int) {
            val coerceIn = progress.coerceIn(0, 100)
            println("we are ${coerceIn}% done!")
        }
        // 只在泛型类的时候会被编译成Integer，如集合类，其他是int
        // 对应到Java基本数据类型的类型完整列表如下：
        /*
        * 整数类型：Byte、Short、Int、Long
        * 浮点型类型：Float、Double
        * 字符类型：Char
        * 布尔类型：Boolean
        */

        /**-------------------- 6.2.2 可空的基本数据类型：Int?、Boolean? 及其他 ----------------------*/
        data class Person(val name: String, val age: Int? = null) {
            fun isOlderThan(other: Person): Boolean? {
                if (age == null || other.age == null) {
                    return null
                }
                return age > other.age
            }
        }

        /**-------------------- 6.2.3 数字转换 ----------------------*/
        // Kotlin和Java之间一条重要的区别就是处理数字转换的方式。

        val i2 = 1
        // 必须显示的转换
        val l: Long = i2.toLong()

        println(i2.toLong() in listOf(1L, 2L, 3L))

        /*
        * 基本数据类型字面值
        * 使用后缀 L 表示Long  字面值：123L
        * 标准浮点数表示 Double  字面值：0.12 2.0 1.2e10
        * 后缀 F 表示Float类型 字面值：123.4f、.456f
        * 使用前缀 0x或0X 表示十六进制字面值：0xCAFEBABE 或者 0xbdcL
        * 使用前缀 0b或0B 表示二进制字面值：0b000000101
        *
        * */

        // 初始化一个类型已知和变量时，或者把字面值作为实参传给函数时，必要的转换会自动的发生。
        fun foo(l: Long) = println(l)
        foo(42)

        val b: Byte = 1
        val l2 = b + 1L


        /**-------------------- 6.2.4 Any 和 Any? 根类型 ----------------------*/
        /*
        * 和 Object作为Java类层级结构的根差不多，Any类型是Kotlin所有非空类型的超类型(非空类型的根)。
        */
        // Any是引用类型，所以值42会被装箱
        val answer: Any = 42


        /**-------------------- 6.2.5 Unit类型 Kotlin的 void ----------------------*/

        //  Kotlin中的Unit类型完成了Java中的void一样的功能。当函数没什么有意义的结果返回时，他可以用作函数的返回类型
        fun f(): Unit {}

        // 显式的Unit声明被省略了
        fun f2() {}


        class NoResultProcess : Processor2<Unit> {
            // 返回Unit，但可以省略类型说明
            override fun process(): Unit {
                // 这里不需要显示的return
//                return Unit
            }
        }

        /**-------------------- 6.2.6 Nothing类型: 这个函数永不返回 ----------------------*/
        // 对某些 Kotlin 函数来说，＂返回类型”的概念没有任何意义，因为它们从来不会成功地结束。
        fun fail(message: String): Nothing {
            throw IllegalStateException(message)
        }
        // 注意 返回Nothing的函数可以放在Elvis运算符的右边来做先决条件检查：
//        val address: String? = null
        val address: String? = "wuhan"
        val s = address ?: fail("No address")

        /**-------------------- 6.3.1 可空性和集合 ----------------------*/
        // 代码清单6.21 创建一个包含可空值的集合
        // 从一个文件中读取文本行的列表，并尝试把每一行文本解析成一个数字
        fun readNumbers(reader: BufferedReader): List<Int?> {
            // 创建包含可空Int值的列表
            val arrayList = ArrayList<Int?>()
            for (line in reader.readLine()) {
                try {
                    val toInt = line.toInt()
                    // 向列表添加整数（非空值）
                    arrayList.add(toInt)
                } catch (e: NumberFormatException) {
                    // 向列表添加null
                    arrayList.add(null)
                }
            }
            return arrayList
        }

        // 代码清单6.22 使用可空值的集合
        fun addValidNumbers(numbers: List<Int?>) {
            var sumOfValidNumbers = 0
            var invalidNumbers = 0
            for (number in numbers) {
                if (number != null) {
                    sumOfValidNumbers += number
                } else {
                    invalidNumbers++
                }
            }
            println("sumOfValidNumbers:  $sumOfValidNumbers")
            println("invalidNumbers:  $invalidNumbers")
        }

        val bufferedReader = BufferedReader(StringReader("1\nabc\n42"))
        // [1,null,42]
        val readNumbers = readNumbers(bufferedReader)
        addValidNumbers(readNumbers)
        // sumOfValidNumbers:  43
        // invalidNumbers:  1

        // 代码清单6.23 对包含可空值的集合使用 filterNotNull
        fun addValidNumbers2(numbers: List<Int?>) {
            // 类型为List<Int>，因为过滤保证了不会出现null
            val filterNotNull: List<Int> = numbers.filterNotNull()
            println("sum of valid numbers::  ${filterNotNull.sum()}")
            println("Invalid numbers:  ${numbers.size - filterNotNull.size}")
        }

        /**-------------------- 6.3.2 只读集合和可变集合 ----------------------*/
        /*
        * Kotlin的集合设计和Java不同的另一项重要特质是，它把访问集合数据的接口和修改集合数据的接口分开了。
        * 一般的规则是在代码的任何地方都应该使用只读接口，只在代码需要修改集合的地方使用可变接口的变体。
        *
        * Collection
        *  - size
        *  - iterator()
        *  - contains()
        * MutableCollection 继承Collection
        *  - add()
        *  - remove()
        *  - clear()
        */

        // 代码清单6.24 使用只读集合接口与可变集合接口
        fun <T> copyElements(source: Collection<T>, target: MutableCollection<T>) {
            // 在source集合中的所有元素中循环
            for (item in source) {
                // 想可变的target集合中添加元素
                target.add(item)
            }
        }

        val source: Collection<Int> = arrayListOf(3, 5, 7)
        val target: MutableCollection<Int> = arrayListOf(1)
        copyElements(source, target)
        println(target)// [1,3,5,7]

        // 只读集合不一定是不可变的，只读集合并不总是线程安全的。


        /**-------------------- 6.3.3 Kotlin集合和Java ----------------------*/
        /*
        * 集合创建函数
        * 集合类型    只读                可变
        * List      listOf          mutableListOf、arrayListOf
        * Set       setOf           mutableSetOf、hashSet、linkedSetOf、sortedSetOf
        * Map       mapOf           mutableMapOf、hashMapOf、linkedMapOf、sortMapOf
        *
        * Java并不会区分只读集合与可变集合，即使Kotlin中把集合声明成只读的，Java代码页能够修改这个集合。
        */

        /*Java*/
//        public static class CollectionUtils {
//            public static List<String> uppercaseAll(List<String> items) {
//                for (int i = 0; i < items.size(); i++) {
//                    items.set(i, items.get(i).toLowerCase());
//                }
//                return items;
//            }
//        }

        // 声明只读的参数
        fun printInUppercase(list: List<String>) {
            // 调用可以修改集合的Java函数
            println(JavaCode.CollectionUtils.uppercaseAll(list))
            // 打印被修改过的函数
            println(list.first())
        }

        val listOf = listOf("a", "b", "c")
        printInUppercase(listOf)// [A,B,C] A


        /**-------------------- 6.3.4 作为平台类型的集合 ----------------------*/
        /*
        * 集合是否可空？
        * 集合中的元素是否可空？
        * 你的方法会不会修改集合？
        */

        // 代码清单6.25 使用集合参数的Java接口r
//        public interface FileContentProcessor {
//            void processContents(File path, byte[] binaryContents, List<String> textContents);
//        }

        // 代码清单6.26 FileContentProcessor的kotlin实现
        class FileIndexer : JavaCode.FileContentProcessor {
            override fun processContents(path: File, binaryContents: ByteArray?, textContents: MutableList<String>?) {

            }
        }

        // 代码清单6.27 另一个使用集合参数的Java接口
//        public interface DataParser<T> {
//            void parseData(String input, List<T> output, List<String> errors);
//        }

        // 代码清单6.28 DataParser的kotlin实现
        class PersonParser : JavaCode.DataParser<Object4Activity.Person> {
            override fun parseData(input: String, output: MutableList<Object4Activity.Person>, errors: MutableList<String?>?) {
                // 默认是都会为空、集合元素不为空、方法会修改集合。
                // 需要根据具体场景配置设置
            }
        }


        /**-------------------- 6.3.5 对象和基本数据类型的数组 ----------------------*/
        fun main(args: Array<String>) {
            // 使扩展属性 array.indices 在下标的范围内迭代
            for (i in args.indices) {
                // 通过下标使用array[index]访问元素
                println("Argument $i is: ${args[i]}")
            }
        }

        // 代码清单6.30 创建字符数组
        val array = Array<String>(26) { i -> ('a' + i).toString() }
        println(array.joinToString(""))// abcd...

        // 代码清单6.31 向vararg方法传递集合
        val listOf1 = listOf("a", "b", "c")
        // 期望vararg参数时使用展开运算符 (*) 传递数组
        println("%s%s%s".format(*listOf1.toTypedArray()))

        // 创建存储了5个0的整型数组的两种选择：
        val fiveZeros = IntArray(5)
        val intArrayOf = intArrayOf(0, 0, 0, 0, 0)
        // 接收lambda的构造方法的例子
        val intArray = IntArray(5) { i -> (i + 1) * (i + 1) }
        println(intArray.joinToString())// 1,4,9,16,25

        // 代码清单6.32 对数组使用 forEachIndexed
        fun main2(args: Array<String>) {
            args.forEachIndexed { index, element -> println("Argument $index is: $element !!!!") }
        }