Kotlin语言的继承与重载的open关键字学习

// KT所有的类，默认是final修饰的，不能被继承，和Java相反 // open：移除final修饰

open class Person(private val name: String) {

    private fun showName() = "父类 的姓名是【$name】"

    // KT所有的函数，默认是final修饰的，不能被重写，和Java相反
    open fun myPrintln() = println(showName())
}

class Student(private val subName: String) : Person(subName) {

    private fun showName() = "子类 的姓名是【${subName}】"

    override fun myPrintln() = println(showName())

}

// TODO 83.Kotlin语言的继承与重载的open关键字学习
// 1.父类 val name  showName()->String  myPrintln->Unit
// 2.子类 myPrintln->Unit
fun main() {
    val person: Person = Student("张三")
    person.myPrintln()
}

Kotlin语言的类型转换学习

open class Person2(private val name: String) {

    fun showName() = "父类 的姓名是【$name】"

    // KT所有的函数，默认是final修饰的，不能被重写，和Java相反
    open fun myPrintln() = println(showName())
}

class Student2(private val subName: String) : Person2(subName) {

    fun showName2() = "子类 的姓名是【${subName}】"

    override fun myPrintln() = println(showName2())

}

// TODO 84.Kotlin语言的类型转换学习
// 1.普通运行子类输出
// 2.is Person Student File
// 3.is + as 转换
fun main() {
    val p: Person2 = Student2("王五")
    p.myPrintln()

    println(p is Person2)
    println(p is Student2)
    println(p is File)

    // is + as = 一般是配合一起使用
    if (p is Student2) {
        (p as Student2).myPrintln()
    }

    if (p is Person2) {
        // (p as Person2).myPrintln() // 因为子类重写了父类
        println((p as Person2).showName())
    }
}

Kotlin语言的智能类型转换学习

open class Person3(val name: String) {
    private fun showName() = "父类显示:$name"

    open fun myPrintln() = println(showName())

    fun methodPerson() = println("我是父类的方法...") // 父类独有的函数
}

class Student3(val nameSub: String) : Person3 (nameSub) {
    override fun myPrintln() = println("子类显示:$nameSub")

    fun methodStudent() = println("我是子类的方法...") // 子类独有的函数
}

// TODO 85.Kotlin语言的智能类型转换学习
fun main() {
    val p : Person3 = Student3("李四")

    (p as Student3).methodStudent()

    p.methodStudent()

    p.methodStudent()

    p.methodStudent()

    // 智能类型转换：会根据上面 as 转成的类型，自动明白，你现在的类型就是上面的类型
}

Kotlin语言的Any超类学习

// 在KT中，所有的类，都隐士继承了 : Any() ,你不写，默认就有 // Any类在KT设计中：只提供标准，你看不到实现，实现在各个平台处理好了

class Obj1 : Any()
class Obj2 : Any()
class Obj3 : Any()
class Obj4 : Any()
class Obj5 : Any()
class Obj6 : Any()
// ..

// TODO 86.Kotlin语言的Any超类学习
// Any == java Object
fun main() {
    println(Obj1().toString())
}

Kotlin语言的对象声明学习

object KtBase87 {
    /* object 对象类背后做了什么事情

        public static final KtBase87 INSTANCE;

        private KtBase87() {} // 主构造废除一样的效果

        public final void show() {
            String var1 = "我是show函数...";
            ...
            System.out.println(var1);
        }

        // 这个区域是 object 不同点：
        static {
            KtBase87 var0 = new KtBase87();
            INSTANCE = var0;
            String var1 = "KtBase91 init...";
            ...
            System.out.println(var0);
        }

     */

    init {
        println("KtBase91 init...")
    }

    fun show() = println("我是show函数...")
}

// TODO 87.Kotlin语言的对象声明学习
fun main() {
    // object KtBase87 既是单例的实例，也是类名
    // 小结：既然是 单例的实例，又是类名，只有一个创建，这就是典型的单例
    println(KtBase87) // 背后代码：println(KtBase87.INSTANCE)
    println(KtBase87) // 背后代码：println(KtBase87.INSTANCE)
    println(KtBase87)
    println(KtBase87)
    println(KtBase87)
    println(KtBase87)

    // 背后代码：KtBase87.INSTANCE.show();
    println(KtBase87.show())
}