Kotlin | 4.类、对象和接口

        /*--------------- 4.1.1 kotlin 中的接口-------------*/

        // 代码清单 1 声明一个简单的接口
//        interface Clickable {
//            fun click()
//        }

        // 代码清单 2 实现一个简单的接口
        class Button : Clickable2 {
            override fun click() {
                println(" I was clicked")
                LogUtil.e(" I was clicked")
            }
        }
        Button().click()
        Button().showOff()
        /**
         * 说明：
         * Kotlin 在后面使用【冒号:】 来代替java中的 extends 和 implements 关键字。
         * 可实现多个接口继承一个类。
         */

        // 代码清单 3 在接口定义一个带方法体的方法

        // 代码清单 4 定义另一个实现了同样方法的接口

        /**
         * 可以在接口中定义一个带方法体的方法。
         * 如果你的类实现了两个接口，这两个接口都定义了相同的方法，则编译器会强制你实现那个方法。
         */

        // 代码清单 5 调用继承自接口方法的实现
        class Button2 : Clickable2, Focusable {
//            override fun click() {
//                LogUtil.e("I was clicked2")
//            }

            override fun click() = LogUtil.e("I was clicked2")


            // 必须提供显示实现
            override fun showOff() {
                /** 使用尖括号加上父类型名字的 "super" 表明了你想要调用哪一个父类的方法*/
                super<Clickable2>.showOff()
                super<Focusable>.showOff()
            }
        }

        // 验证所有继承的方法都能被调用到
        LogUtil.e("--------分割线--------")
        val button = Button()
        button.click()
        button.showOff()
        val button2 = Button2()
        button2.click()
        button2.showOff()
        button2.setFocus(true)


        /*--------------- 4.1.2 open、final和abstract修饰符: 默认为final -------------*/
        /**
         * 《Effective Java》："要么为继承做好设计并记录文档，要么禁止这么做。"
         * Java 的类和方法默认是open的，而 Kotlin 中默认都是final的。
         * 如果你想允许创建一个类的子类，需要使用 open 修饰符来标识这个类。
         * 此外需要给每一个可以被重写的属性或方法添加 open 修饰符。
         */

        // 代码清单 6 声明一个带一个 open 方法的open类
        open class RichButton : Clickable {

            // 这个函数重写了一个open函数并且它本身同样是open的
            override fun click() {}

            // 这个函数是final的：不能在子类中重写它
            fun disable() {}

            // 这个函数使open的：可以在子类中重写它
            open fun animate() {}
        }

        /**
         * 注意：如果你重写了一个基类或者接口的成员，重写了的成员同样默认是open的。
         * 如果你想改变这一行为，阻止子类的操作，可以显示将重写的成员变量设置为final。
         */

        // 代码清单 7 禁止重写
        open class RichButton2 : Clickable {

            // 没有final的override 意味着是open的
            final override fun click() {}
        }

        /**
         * open 类和智能转换
         * 属性默认是final的，可以在大多数属性上不加思考的使用智能转换，这提高了你的代码表现力。
         * if (e is Sum) {
         * // 变量 e 被智能转换了类型
         * return eval(e.left) + eval(e.right)
         * }
         */

        // 代码清单 8 声明一个抽象类
        // 这个类是抽象的，不能直接创建它的实例
        abstract class Animated {

            // 这个函数是抽象的：它没有实现必须被子类重写
            abstract fun animate()

            // 抽象类的抽象函数并不是默认open的，但是可以被标注为open的
            open fun stopAnimating() {}

            fun animateTwice() {}
        }

        // 测试
        class Button3 : Animated() {
            // 一定实现
            override fun animate() {

            }

            // 可以选择实现
            override fun stopAnimating() {
                super.stopAnimating()
            }
            // 不能实现
//            animateTeice()
        }
        /*--------------- 4.1.3 可见性修饰符：默认为 public -------------*/
        /**
         * 修饰符      相关成员                评注
         * final      不能被重写              类中成员默认使用
         * open       可以被重写              需要明确地表明
         * abstract   必须被重写              只能在抽象类中使用：抽象成员不能实现
         * override   重写父类或接口中的成员    如果没有使用final表明，重写的成员默认是开放的
         */

        /**
         * open : 控制继承修饰符。
         * 要被继承的类必须是open修饰的，因为类默认是final的。
         * 同理，要被重写的属性和方法也必须被open修饰。
         */


        /*--------------- 4.1.4 内部类和嵌套类：默认是嵌套类 -------------*/
        // Kotlin 的嵌套类不能访问外部类的实例，除非你特别地做出了要求。
        // 代码清单 9 声明一个包含可序列化状态的视图
//        interface State : Serializable
//        interface View {
//            fun getCurrentState(): ObjectActivity.State
//            fun restoreState(state: ObjectActivity.State) {}
//        }
        // 代码清单 4.10 用带内部类的 Java 代码来实现 View
//    public class Button implements ObjectActivity.View {
//
//        @NotNull
//        @Override
//        public ObjectActivity.State getCurrentState() {
//            return new ButtonState();
//        }
//
//        @Override
//        public void restoreState(@NotNull ObjectActivity.State state) {
//
//        }
//
//        public class ButtonState implements ObjectActivity.State {
//        }
//    }
        /**
         * 问题：
         * 这个代码有什么问题？为什么你会得到一个 java io NotSerializable Exception : Button 异常，如果你试图序列化声明的按钮的状态？
         * 这最开始可能会看起来奇怪：你序列化的变量是 ButtonState 类型的 state ，并不是 Button类型。
         * 当你想起来这是在 Java 中时所有的事情都清楚了，当你在另个类中声明一个类时，它会默认变成内部类。这个例子中的 ButtonState 类隐式地存储了它的外
         * 部Button 类的引用。这就解释了为什么 ButtonState 不能被序列化： Button不是可序列化的，并且它的引用破坏了 ButtonState 的序列化
         * 要修复这个问题，你需要声明 ButtonState 类是 static 的。将一个嵌套类声明为 static 会从这个类中删除包围它的类的隐式引用。
         */
        // Kotlin 中，内部类的默认行为与我们刚刚描述的是相反的
        // 代码清单4.11 在Kotlin中使用嵌套类实现View
//        class Button4 : View {
//            override fun getCurrentState(): State = ButtonState2()
//            override fun restoreState(state: State) {}
//
//            // 这个类与Java中的静态嵌套类类似
//            class ButtonState2 : State {}
//
//        }
        /**
         * 嵌套类和内部类在Java与Kotlin中的对应关系
         * 类A在另一个类B中声明        在Java中           在Kotlin中
         * 嵌套类(不存储外部类的引用)   static class A    class A
         * 内部类(存储外部类的引用)     class A           inner class A
         */

        /*--------------- 4.1.5 密封类：定义受限的类继承结构 -------------*/
        // 代码清单4.1.2 作为接口实现的表达试
//        interface Expr
//        class Num(val value: Int) : ObjectActivity.Expr
//        class Sum(val left: ObjectActivity.Expr, val right: ObjectActivity.Expr) : ObjectActivity.Expr
//
//        fun eval(e: ObjectActivity.Expr): Int =
//                when (e) {
//                    is Num -> e.value
//                    is Sum -> eval(e.right) + eval(e.left)
//                    // 必须检查“else”分支
//                    else -> throw IllegalArgumentException("Unknown expression")
//                }

        // 为解决else的情况，增加sealed类修饰符，对可能创建的子类做出了严格的限制。所有的直接子类必须嵌套在父类中。
        // 代码清单4.1.3 作为密封类的表达式
//        sealed class ExprS {
//            // 将基类标记为密封的..
//            class Num(val value: Int) : ObjectActivity.ExprS()
//
//            // 将所有可能的类作为嵌套类列出
//            class sum(val left: ObjectActivity.ExprS, val right: ObjectActivity.ExprS) : ObjectActivity.ExprS()
//        }
//
//        fun evalS(e: ObjectActivity.ExprS): Int =
//                when (e) {
//                    is ObjectActivity.ExprS.Num -> e.value
//                    is ObjectActivity.ExprS.sum -> evalS(e.left) + evalS(e.right)
//                }

        /**------------------------- 4.2.1初始化类：主构造方法和初始化语句块 -------------------------*/
        // 被括号围起来的叫主构造方法。目的：1表明构造方法的参数 2定义使用这些参数初始化属性
        class User(val nickName: String)

        // 1.明确的写法：
        /**
         * 关键字：
         * 1、constructor:用来开始一个构造方法或从构造方法的声明
         * 2、init:用来引入一个初始化语句块。主构造方法有语法限制，不能包含初始化代码。
         */
        class User1 constructor(_nickName: String) {
            val nickName: String

            init {
                nickName = _nickName
            }
        }

        // 2.用参数来初始化属性
        class User2 constructor(_nickName: String) {
            val nickName = _nickName
        }

        // 3.val 意味着相应的属性会用构造方法的参数来初始化
        open class User3(val nickName: String)

        // 为构造方法声明一个默认值：
        class User4(val nickName: String, val isSuc: Boolean = true)
        // 创作构造方法时不需要new
        val user4 = User4("jingbin")
        val user42 = User4("jingbin", false)
        val user43 = User4("jingbin", isSuc = false)
        println(user4.isSuc)// true
        println(user42.isSuc)// false
        println(user43.isSuc)// false

        // 如果所有的参数都有默认值，会生成一个额外不带参数的构造方法来使用所有的默认值
        class User5(val nickName: String = "jingbin", val isSuc: Boolean = true)
        // 使用不带参数的，但是默认值是声明的默认值
        val user5 = User5()

        // 如果你的类具有一个父类，主构造方法同样需要初始化父类
        class TwitterUser(nickName: String) : User3(nickName) {

        }

        // 将会生成一个不带任何参数的构造方法
        open class Button

        // 必须显示的调用父类的构造方法，即使没有任何参数，空括号表示没有参数的构造方法
        class RadioButton : Button()

        // 包装自己的类不被其他的类实例化，有一个private构造方法
        class Secretive private constructor() {}

        /**------------------------- 4.2.2 构造方法：用不同的方式来初始化父类 -------------------------*/
        // 大部分的情况不需要声明多个构造方法，因为可以在构造方法中写默认值来规避
        class User6(val nickName: String, val isSuc: Boolean = true)

        // 比较常见到的是一个View
        open class View {
            // 从构造方法
            constructor(ctx: Context) {

            }

            constructor(ctx: Context, attr: Attributes?) {

            }
        }

        // 如果想扩展这个类的，可以声明同样的构造方法
        class MyButton : View {
            // 调用父类的构造方法
            constructor(context: Context) : super(context) {

            }

            constructor(context: Context, attributes: Attributes) : super(context, attributes) {

            }
        }

        // 也可以使用this关键字调用自己的另一个构造方法
        class MyButton1 : View {
            // 委托给这个类的另一个构造方法
            constructor(context: Context) : this(context, null) {

            }

            constructor(context: Context, attributes: Attributes?) : super(context, attributes) {

            }
        }

        /**------------------------- 4.2.3 实现在接口中声明的属性 -------------------------*/
        // Kotlin中接口可以包含抽象属性的声明，Java貌似不行,实际上就是一个getName()的方法
//        interface User8 {
//            val name: String
//        }
        // 代码清单 4.14 实现一个接口属性
        // 主构造方法属性
        class PrivateUser(override val name: String) : User8

        // 每次访问时都会调用substringBefore
        class SubScribingUser(val email: String) : User8 {
            override val name: String
                // 在@之前的字符串
                get() = email.substringBefore("@")
        }

        // 只会调用一次id.toString()
        class FaceBookUser(val id: Int) : User8 {
            // 初始化属性
            override val name = id.toString()
        }

        // 接口中还可以包含getter和setter的属性
//        interface User9 {
//            val email: String
//            val name: String get() = email.substringBefore("@")
//        }

        /**------------------------- 4.2.4 通过getter或setter访问支持字段 -------------------------*/
        class User10(val name: String) {
            var address: String = "unspecified"
                set(value: String) {
                    // 在set中访问支持字段
                    println("$field --> $value")
                    // field 是原来的值，value是设置的值
                    field = value
                }
        }

        val user10 = User10("jingbin")
        // 将 jingbin 重新设置为 jinbeen "jingbin --> jinbeen"
        user10.address = "jinbeen"

        /**------------------------- 4.2.5 修改访问器的可见性 -------------------------*/
        // 代码清单 4.16 声明一个具有private setter的属性
        class LengthCounter {
            var counter: Int = 0
                // 不能在类外部修改这个属性
                private set

            fun addWord(word: String) {
                counter += word.length
            }
        }
        LengthCounter().addWord("jingbin")

        /**------------------------- 4.3.1 通用对象方法 -------------------------*/
        // 处理 toString equals hashCode等
        // 代码清单 4.17 Client类的最初声明
        class Client(val name: String, val postalCode: Int)

        /**toString()*/
        // 代码清单 4.18 为Client实现 toString()
        class Client2(val name: String, val postalCode: Int) {
            override fun toString(): String = "Client(name=$name,postalCode=$postalCode)"
        }
        println(Client2("jingbin", 333))

        /**equals()*/
        // 在Kotlin中，==检查对象是否相等，而不是比较引用。===与java中的 ==比较对象引用的效果一模一样
        // 代码清单 4.19 为Client类实现 equals()
        class Client3(val name: String, val postalCode: Int) {
            // "Any"是java.lang.Object的模拟:Kotlin中所有类的父类。可空类型"Any?"意味着"other"是可以为空的
            override fun equals(other: Any?): Boolean {
                if (other == null || other !is Client) {
                    return false
                }
                return name == other.name && postalCode == other.postalCode
            }

            override fun toString(): String = "Client(name=$name,postalCode=$postalCode)"
        }

        /**hashCode()*/
        val hashSetOf = hashSetOf(Client3("jingbin", 123456))
        println(hashSetOf.contains(Client3("jingbin", 123456)))// false
        // 因为Client缺少了hashCode方法。因此它违反了通用的hashCode契约：如果两个对象相等，它们必须有着相同的hash值。
        // 代码清单 4.20 为Client实现hashCode()
        class Client4(val name: String, val postalCode: Int) {
            override fun hashCode(): Int = name.hashCode() * 31 + postalCode
        }

        /**------------------------- 4.3.2 数据类：自动生成通用方法的实现 -------------------------*/
        // 给你的类添加 data修饰符上述的方法就会自动添加好，而且还会有其他的方法
        // 代码清单4.21 数据类 Client
        // equals 和 hashCode 会将所有主构造方法里的值一起处理，不在主构造方法里的不会处理！
        data class Client5(val name: String, val postalCode: Int)

        // 数据类和不可变性:Copy()方法
        class Client6(val name: String, val postalCode: Int) {
            fun copy(name: String = this.name, postalCode: Int = this.postalCode) = Client6(name, postalCode)
        }

        val client6 = Client6("jingbin", 123)
        println(client6.copy(postalCode = 345))
        // 为避免上述的模板代码，使用Kotlin -> by 类委托

        /**------------------------- 4.3.3 类委托：使用“by”关键字 -------------------------*/
        // 无论什么时候实现一个接口，你都可以使用by关键字将接口的实现 委托 到另一个对象。
        class DetegatingCollention<T>(innerList: Collection<T> = ArrayList<T>()) : Collection<T> by innerList {}

        // 代码清单4.22 使用类委托
        class CountingSet<T>(val innerSet: MutableCollection<T> = HashSet<T>()) : MutableCollection<T> by innerSet {
            // 将MutableCollection的实现委托给innerSet
            var objectAdded = 0

            override fun add(element: T): Boolean {
                objectAdded++
                return innerSet.add(element)
            }

            override fun addAll(c: Collection<T>): Boolean {
                objectAdded += c.size
                return innerSet.addAll(c)
            }
        }

        val countingSet = CountingSet<Int>()
        countingSet.addAll(listOf(1, 2, 3))
        // 3 objects were added,2 remain
        println("${countingSet.objectAdded} objects were added,${countingSet.size} remain ")

        // 使用的核心理念：定义一个类并同时创建一个对象

        /**------------------------- 4.4.1 对象声明：创建单例易如反掌 -------------------------*/
        // 对象声明将 类声明与该类的 单一实例 声明结合到了一起
        // 表示一个组织的工资单
//        object Payroll {
//            val allEmployees = arrayListOf<Person>()
//            fun calculateSalary() {
//                for (person in allEmployees) {
////                person.name
//                }
//            }
//        }

        // 对象声明不允许有构造方法，且定义的时候就创建了，不需要调用构造方法!
//        Payroll.allEmployees.add()

        // 代码清单4.23 使用对象来实现 Comparator
//        object CaseInsensitiveFileComparator : Comparator<File> {
//            override fun compare(o1: File, o2: File): Int {
//                return o1.parent.compareTo(o2.path, ignoreCase = true)
//            }
//        }

        CaseInsensitiveFileComparator.compare(File("2"), File("1"))
        // 可以在任何可以使用普通对象的地方使用单例对象
        val listOf = listOf(File(""), File("2"))
        // sortedWith 返回一个可以根据特定的比较器排序过的列表
        println(listOf.sortedWith(CaseInsensitiveFileComparator))

        // 代码清单4.24 使用嵌套类实现Comparator
//        data class Person(val name: String) {
//            object NameComparator : Comparator<Person> {
//                override fun compare(o1: Person, o2: Person): Int {
//                    return o1.name.compareTo(o2.name)
//                }
//
//            }
//        }


        /**------------------------- 4.4.2 伴生对象：工厂方法和静态成员的地盘 -------------------------*/
        // companion 获得了直接通过容器类名称来访问这个对象的方法和属性的能力
//        class A{
//            companion object {
//                fun bar{
//                    println("companion object called")
//                }
//            }
//        }

        // 代码清单 4.25 定义一个拥有多个从构造方法的类
//        class User {
//            val nickName: String
//
//            constructor(email: String) {
//                nickName = email.substringBefore("@")
//            }
//
//            constructor(id: Int) {
//                nickName = id.toString()
//            }
//        }
        // 代码清单4.26 使用工厂方法
//        class User2 private constructor(val nickName: String) {
//            companion object {
//                fun newSubUser(email: String) = User2(email.substringBefore("@"))
//                fun newFBUser(id: Int) = User2(id.toString())
//            }
//        }
        User2.newFBUser(123)
        User2.newSubUser("jingbin127@gmail.com")

        /**------------------------- 4.4.3 作为普通对象使用的伴生对象 -------------------------*/
        // 代码清单4.27 声明一个命名伴生对象
//        class Person2(val name: String) {
//            companion object Loader {
//                fun fromJSON(jsonText: String): Object4Activity.Person2 = Person2(jsonText)
//            }
//        }
        Person2.Loader.fromJSON("{name:jingbin}")
        Person2.fromJSON("{name:jingbin}")

        // 代码清单4.28 在伴生对象中实现接口
//        interface JSONFactory<T> {
//            fun fromJSON(jsonText: String): T
//        }
//
//        class Person3 {
//            companion object : Object4Activity.JSONFactory<Person3> {
//                // 实现接口的伴生对象
//                override fun fromJSON(jsonText: String): Person3 = fromJSON(jsonText + "哈哈")
//            }
//        }

        // 4.29 为伴生对象定一个扩展函数
//        class Person4(val firstName: String, val lastName: String) {
//            // 声明一个空的伴生对象
//            companion object {}
//        }
//
//        // 声明一个扩展函数 默认Companion
//        fun Object4Activity.Person4.Companion.fromJSON(jsonText: String): Object4Activity.Person4 = Person4(jsonText, "bin")

        /**------------------------- 4.4.4 对象表达式：改变写法的匿名内部类 -------------------------*/
        // 代码清单 4.30 使用匿名对象来实现事件监听器
//        window.addMouseListener(
//                // 声明一个继承MouseAdapter的匿名对象
//                object : MouseAdapter() {
//                    override fun mouseClicked(e: MouseEvent) {}
//                    override fun mouseEntered(e: MouseEvent) {}
//                })
        // 与对象声明不同，匿名对象不是单例的。每次执行都会创建一个新的对象实例。

        //代码清单4.31 从匿名对象访问局部变量
//        fun countClicks(window: Window) {
//            // 局部变量
//            var clickCount = 0
//            window.addMouseListener(object : MouseAdapter() {
//                override fun mouseClicked(e: MouseEvent) {
//                    // 更新变量的值
//                    clickCount++
//                }
//            })
//        }