Kotlin基础学习 11

目录

1.Kotlin语言的Any超类学习

2.Kotlin语言的对象声明学习

3.Kotlin语言的对象表达式学习

4.Kotlin语言的伴生对象学习

5.Kotlin语言的嵌套类学习

6.Kotlin语言的数据类学习

7.Kotlin语言的copy函数学习

8.Kotlin语言的解构声明学习

9.Kotlin语言的运算符重载学习

10.Kotlin语言的枚举类学习

---

1.Kotlin语言的Any超类学习

//在KT中，所有的类，都隐式继承了 ：Any() ,你不写，默认就有
// Any类在KT设计中：只提供标准，你看不到实现，实现在各个平台处理就好
class Obj1 : Any()
class Obj2 : Any()
class Obj3 : Any()
// TODO 85.Kotlin语言的Any超类学习
// Any == java Object
fun main(){
    println(Obj1().toString())
}

2.Kotlin语言的对象声明学习

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

3.Kotlin语言的对象表达式学习

interface RunnableKT {
    fun run()
}

open class KtBase87 {
    open fun add(info: String) = println("KtBase87 add:$info")
    open fun del(info: String) = println("KtBase87 del:$info")
}

// TODO 87.Kotlin语言的对象表达式学习
fun main() {
    //匿名对象 表达式方式
    val p : KtBase87 = object : KtBase87(){
        override fun add(info: String) {
            //super.add(info)
            println("我是匿名对象 add:$info")
        }

        override fun del(info: String) {
            //super.del(info)
            println("我是匿名对象 del:$info")
        }
    }
    p.add("张三")
    p.del("李四")
    //具名实现方式
    val p2 = KtBase87Impl()
    p2.add("赵六")
    p2.del("赵七")

    //对java的接口 用 KT[对象表达式]  方式一
    val p3 = object : Runnable{
        override fun run() {
            println("Runnable run...")
        }
    }
    p3.run()

    //对java的接口 用 java 最简洁的方式 方式二
    val p4 = Runnable {
        println("Runnable run2...")
    }
    p4.run()

    //对KT的接口 用 KT[对象表达式]   方式一
    object : RunnableKT {
        override fun run() {
            println("RunnableKT 方式一 run ...")
        }
    }.run()

}

//小结：Java接口，有两种方式 1（object ： 对象表达式）2 简洁版
//     KT接口     只有一种方式 1（object : 对象表达式）

//具名实现 具体名字 == KtBase87Impl
class KtBase87Impl : KtBase87() {
    override fun add(info: String) {
        //super.add(info)
        println("我是具名对象 add:$info")
    }

    override fun del(info: String) {
        //super.del(info)
        println("我是具名对象 del:$info")
    }
}

4.Kotlin语言的伴生对象学习

class KtBase88 {
    //伴生对象
    companion object {
        val info = "BxbInfo"
        fun showInfo() = println("显示info:$info")
        val name = "Bxb"
    }
}

// TODO 88.Kotlin语言的伴生对象学习
//伴生对象的由来：在KT中是没有java这种static静态，半生很大程度和java这种static静态差不多
// 无论KtBase88() 构建对象多少次，我们的伴生对象，只有一次加载
// 无论KtBase88.showInfo() 调用多少次，我们的伴生对象，只有一次加载
// 伴生对象只会初始化一次
fun main() {
    println(KtBase88.info)
    println(KtBase88.name)
    KtBase88.showInfo()
}

5.Kotlin语言的嵌套类学习

// TODO 内部类
// 内部类的特点：内部的类 能访问 外部的类
//              外部的类 能访问 内部的类
class Body(_bodyInfo: String){ //身体类
    val bodyInfo = _bodyInfo
    fun show(){
        Heart().run()
    }
    // 默认情况下：内部的类 不能访问 外部的类，要增加inner成为内部类才可以访问外部类
    inner class Heart{ //心脏类
        fun run() = println("心脏访问身体信息:$bodyInfo")
    }
    inner class Kidney{ //肾脏
        fun work() = println("肾脏访问身体信息:$bodyInfo")
    }
    inner class Hand{ //手
        inner class LeftHand{
            fun run() = println("左手访问身体信息:$bodyInfo")
        }
        inner class RightHand{
            fun run() = println("右手访问身体信息:$bodyInfo")
        }
    }
}
//TODO 嵌套类
// 默认情况下：都是嵌套关系
// 嵌套类特点：外部的类 能访问 内部的嵌套类
//            内部的类 不能访问 外部类的成员
class Outer{
    val info : String = "OK"
    fun show(){
        Nested().output()
    }
    class Nested{
        fun output() = println(" 嵌套类")
    }
}
// TODO 89.Kotlin语言的嵌套类学习
fun main() {
    //内部类：
    Body("isOK").Heart().run()
    Body("isOK").show()
    Body("isOK").Kidney().work()
    Body("isOK").Hand().LeftHand().run()
    Body("isOK").Hand().RightHand().run()
    //嵌套类
    Outer.Nested().output()
    Outer().show()
}

6.Kotlin语言的数据类学习

//普通类
class ResponseResultBean1(var msg:String,var code:Int,var data:String):Any()
//set get 构造函数
//数据类 ---- 一般用于Javabean的形式下，用数据类
data class ResponseResultBean2(var msg:String,var code:Int,var data:String):Any()
// set get构造函数 解构操作 copy toString hashCode equals 数据类 生成更丰富
// TODO 90.Kotlin语言的数据类学习
// 1.普通类与数据类的 toString 背后原理
// 2.前面学习过的 == 与 ===
// 3.普通类的 == 背后原理
// 4.数据类的 == 背后原理
fun main() {
    // val(v1,v2,v3) = list 这个是list集合之前的 解构操作
    println(ResponseResultBean1("loginSuccess",200,"登录成功的数据..."))
    //普通类：Any() toString Windows实现打印了   com.bxb.s5.ResponseResultBean1@266474c2
    println(ResponseResultBean2("loginSuccess",200,"登录成功的数据..."))
    //数据类：Any() 默认重写了父类的 toString 打印子类的toString详情   ResponseResultBean2(msg=loginSuccess, code=200, data=登录成功的数据...)
    println()

    //前面我们学习 == 值的比较 相当于java的equals   === 引用对象比较
    println(
        ResponseResultBean2("loginSuccess",200,"登录成功的数据...") ==
                ResponseResultBean2("loginSuccess",200,"登录成功的数据...")
    )
    //Any父类的 equals被数据类 重写了 equals 会调用子类的 equals函数（对值的比较）

    println(
        ResponseResultBean1("loginSuccess",200,"登录成功的数据...") ==
                ResponseResultBean1("loginSuccess",200,"登录成功的数据...")
    )
    //Any父类 的equals 实现 (ResponseResultBean1对象引用 比较 ResponseResultBean1对象引用)
}

7.Kotlin语言的copy函数学习

data class KtBase91(var name : String,var age : Int) //主构造
{
    var coreInfo : String = "123"
    init {
        println("主构造被调用了")
    }
    //次构造
    constructor(name : String) : this(name,99){
        println("次构造被调用")
        coreInfo = "增加非常核心的内容信息"
    }

    override fun toString(): String {
        return "toString name:$name,age:$age,coreInfo:$coreInfo"
    }
}
/*
*   生成的toString为什么只有两个参数？
*   答：默认生成的toString 或者 hashcode equals 等等 只管主构造，不管次构造
* */
// TODO 91.Kotlin语言的copy函数学习
fun main() {
    val p1 = KtBase91("张三三") //调用次构造初始化对象
    println(p1)

    val newP2 = p1.copy("李四四",66)
    println(newP2)

    //copy toString hashcode equals 等等 只管主构造，不管次构造
    //注意事项：使用copy 的时候，由于内部代码只处理主构造，所以必须考虑次构造的内容
}

8.Kotlin语言的解构声明学习

//普通类
class Student1(var name : String,var age : Int,var sex:Char)
{   //注意事项：component0 顺序必须是 component1 component2 component3 和成员一一对应，顺序下来的
    operator fun component1() = name
    operator fun component2() = age
    operator fun component3() = sex
}
// 数据类
data class Student2Data(var name:String,var age : Int,var sex:Char )

// TODO 92.Kotlin语言的解构声明学习
fun main() {
    val(name,age,sex) = Student1("张三",66,'男')
    println("普通类解构后：name：$name,age:$age,sex:$sex")

    val(name1,age1,sex1) = Student2Data("张三",66,'男')
    println("数据类解构后：name：$name1,age:$age1,sex:$sex1")

    val(_,age2,_) = Student2Data("张三",66,'男')
    println("数据类解构后：age:$age2")
}

9.Kotlin语言的运算符重载学习

class AddClass(number: Int,number2: Int)

//写一个数据类，就是为了，toString打印方便而已哦
data class AddClass2(var number1:Int,var number2: Int){
    operator fun plus(p1:AddClass2) : Int{
        return (number1 + p1.number1) + (number2 + p1.number2)
    }
    //查看整个 KT可以用的 运算符重载方式
    //operator fun AddClass2.
}
// TODO 93.Kotlin语言的运算符重载学习
fun main() {
    //C++语言 +运算符重载就行了  -运算符重载就行了
    //KT语言 plus代表+运算符重载
    println(AddClass2(1,1)+AddClass2(2,2))
}

10.Kotlin语言的枚举类学习

//KT想表达 ：枚举其实也是一个class
enum class Week{
    星期一,
    星期二,
    星期三,
    星期四,
    星期五,
    星期六,
    星期日
}
// TODO 94.Kotlin语言的枚举类学习
fun main() {
    println(Week.星期一)
    println(Week.星期日)

    //枚举的值等价于枚举本身
    println(Week.星期六 is Week)
}