Kotlin语法-Day7

1.1 对象声明学习

//TODO Kotlin语言中的对象的声明
/*
*
* */
object KtBase59 {
    init {
        println("KtBase59 init......")
    }
    fun  show()= println("我是show函数")
}
fun main() {
    //object KtBase59 既是单例的实例， 也是类名
    //小结：既是单例的实例，又是类名，只有一个创建，这就是典型的单例
    println(KtBase59)
    println(KtBase59)
    println(KtBase59)
//    println(KtBase59)
//    println(KtBase59)
    println(KtBase59.show())

}

---

1.2 对象表达式

//TODO Kotlin语言中的对象表达式学习
/*
* 1.匿名对象表达式方式
* 2.具名实现方式
* 3.对Java的接口 用对象表达式方式
*
* */
open class KtBase58 {
    open fun add(info :String ){
        println("KtBase58 add:$info")
    }
    open fun del(info :String ){
        println("KtBase58 del:$info")
    }
}
fun main() {
    //匿名对象  表达式方式
    val p=object :KtBase58(){
        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 p1 = KTBase58Impl()
    p1.add("阿伟");
    p1.add("阿凉");


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

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

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

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

    }
}

---

1.3 伴生对象

//TODO Kotlin语言中的伴生对象学习
/*
*
* 伴生对象的由来：在KT中是没有Java这种static静态，伴生很大程度上和Java这种static静态 差不多的
* 无论KtBase60 调用多少次 我们的的伴生对象只初始化一次
* */
class KtBase60 {
    //伴生对象
    companion object{
        val info="XiaYuInfo"

        fun  showInfo()= println("显示：$info")
    }
    val testInto="这是测试信息"
    fun test(){
        println("这是测试函数")
    }
}
fun main() {
    println(KtBase60.info)
    KtBase60.showInfo()

    println()
    KtBase60().test()
    println(KtBase60().testInto)

    println()

    println(KtBase60())
    println(KtBase60())

    println()
    println(KtBase60)
    println(KtBase60)

}

---

1.4 内部类&嵌套类

//TODO Kotlin语言中的内部类和嵌套类

//内部类特点：
//        内部的类 能访问 外部的类（inner）
//        外部的类 能访问 内部的类
class Body(_bodyInfo:String){
    val bodyInfo=_bodyInfo

    fun show(){
        Heart().run()
    }
    //默认情况下：内部的类 不能直接访问外部的类，要增加修饰符号inner 成为内部类才可以访问外部类
    inner class Heart{
        fun run()= println("心脏访问身体信息：$bodyInfo")
    }
}

//嵌套类特点：
//默认情况下就是嵌套类
//        内部的类 不能能访问 外部的类成员
//        外部的类 能访问 内部的类
class Outer{
    val info:String="ok"

    fun show(){
        Nested().output()
    }

    class Nested{
        fun output()= println("嵌套类")
    }
}
fun main() {
    Body("isOk").Heart().run()

    Outer().show()
    Outer.Nested().output()
}

---

1.5 数据类

1.数据类至少必须有有一个参数的主构造函数
2.数据类必须有参数，var val 的参数
3.数据类不能使用 abstract，open，sealed，inner 等等 修饰
4.需求 比较，copy，toString，解构，等等这些丰富功能时，也可以用数据类

//TODO Kotlin语言中的数据类

// 普通类
class ResponseResultBean(var msg:String,var code:Int,var data:String){
//  set get 构造函数
}

// 数据类   一般是用于 JavaBean的形势下，用数据类
data class ResponseResultBean2(var msg:String,var code:Int,var data:String){
//  set get 构造函数  解构操作 copy toString hasCode equals
}
fun main() {
    println(ResponseResultBean("loginSuccess",200,"登录成功的数据...."))
//    com.example.kotlin_study.s2.ResponseResultBean@2d6e8792 
//    普通类 继承Any() toString没有重写

    println(ResponseResultBean2("loginSuccess",200,"登录成功的数据...."))
//    数据类 继承Any() toString重写了
}

---

1.6 copy函数

//主函数
data class KtBase63 (var name:String,var age:Int){

    var coreInfo:String=""
    init {
        println("主构造函数被调用")
    }
    //次函数
    constructor(name:String):this (name,23){
        println("次构造被调用")
        coreInfo="增加非常核心内容"
    }

    override fun toString(): String {
        return "toString name$name,age:$age,coreInfo:$coreInfo"
    }
}
//默认生成的toString copy hasCode equals 等等。。。主管主构造 不管次构造
fun main() {
    var p1=KtBase63("张三")
    println(p1)

//    不重写toString方法时输出：
    /*
         主构造函数被调用
         次构造被调用
         KtBase63(name=张三, age=23)
         主构造函数被调用
         KtBase63(name=李四, age=20)
    */
    //重写toString方法之后：
    /*
        主构造函数被调用
        次构造被调用
        toString name张三,age:23,coreInfo:增加非常核心内容
        主构造函数被调用
        toString name李四,age:20,coreInfo:
    */
    var p2= p1.copy("李四",20)
    println(p2)
}

---

1.7 解构声明

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

}
data class Student4(var name:String,var age:Int,var sex:Char)
fun main() {
    val(name,age,sex) = Student1("张三",20,'男')
    println("普通类 解构后： name：$name,age：$age,sex：$sex")

    val(name1,age1,sex1) = Student4("李四",22,'男')
    println("数据类 解构后： name：$name1,age：$age1,sex：$sex1")
}

---

1.8 运算符重载

//TODO Kotlin语言中的运算符重载学习
class Add(number1: Int,number2:Int)

data class Add2(var number1: Int,var number2:Int){
    operator fun plus(p1:Add2):Int{
        return (number1+p1.number1)+(number2+p1.number2)
    }
    //查看 整个KT可以用的 运算符重载 方式
//    operator fun Add2.
}

fun main() {
    println(Add2(1, 2) + Add2(2, 3))
}

---