10天学会kotlin DAY6 继承、类、重载

---

    val study = Study("tiger")

//    普通方法

//    study.myPrintln()



//    is + as 转换

//    is + as = 一般是配合在一起使用的

    println(study is Person)

    println(study is Study)



    if (study is Person){    // 在这里，子类也重写了父类，会输出一次子类的调用

        (study as Person).myPrintln()

    }

    if (study is Study){

        (study as Study).myPrintln()

    }



// kotlin 中所有的类，默认是 final 修饰的，是不能被继承的，和Java 相反

// open 移除final 修饰符

open class Person(private val name: String){

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



//    父类需要被子类继承的方法

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



}



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

    private fun showName() = "子类 的姓名是：$subName"

    override fun myPrintln() {

        super.myPrintln()



        println("我是继承自父类的方法: ${showName()}")

    }

}

3、Any 超类

---

// 在kotlin 中，所有的类都隐式继承了 ：Any() 你不写，默认就有

// Any 类在kotlin 设计中，只提供标准，你看不到实现，实现在各个平台实现就好了



class Person : Any()

4、对象声明

---

//    object 即是单例的实例， 也是类名。 只有一个会被创建，这就是经典的单例



    println(Person)

    println(Person)

    println(Person)

    

    Person.show()



object Person {

    init {

        println("我是init 。。。。")

    }



    fun show() = println("我是show 方法")

}

5、对象表达式

---

//    匿名对象， object : 表达式

  val p = object : Person(){

        override fun add(name: String) {

            super.add(name)

        }



        override fun del(name: String) {

            super.del(name)

        }

    }



    p.add("tiger")

    p.del("张三")



//    具名的实现方式

    val p2 = Person()

    p2.add("王五")

    p2.del("刘美丽")



open class Person(){



    open fun add(name: String) = println("新增： $name")

    open fun del(name: String) = println("删除： $name")

}

6、伴生对象

---

    println(Study.name)

    Study.showInfo()



class Study{

   

//    伴生对象

    companion object {

        val name = "张三"

        fun showInfo() = println("学生：$name")

    }

}

7、嵌套类和内部类

---

//    内部类的访问

    Person(18).Study("tiger").getName()



//    嵌套类的调用

    Body().showInfo()



// 内部类的特点：外部类，能访问内部类，内部类能访问外部类

class Person(val age: Int){



//    默认情况下，内部类不能访问外部类，要增加修饰符 inner 才能够访问外部内

   inner class Study(val name: String){

        fun getName() = println("这个学生叫：$name 年龄：$age")

    }

}



// 嵌套类: kotlin 默认情况下，就是一个嵌套类

// 外部的类，能访问嵌套的内部类，嵌套的内部类不能访问外部的类

class Body{



    val info = "tiger"



    fun showInfo() = Heart(info).showIfo()



    class Heart(val info: String){

        fun showIfo() = println("我就是个测试 $info")

    }

}

8、数据类

---

//  普通类

//  普通类只会生成 set get 构造函数

class ResponseResultBean(val name: String, val age: Int)



//  数据类

//  数据类 会生成 set get 构造函数 copy toString hashCode equals

data class ResponseResultBean1(val name: String, val age: Int)

9、copy 函数

---

//   这里只周主构造

  val p1 = Person("tiger")     // 输出结果 次构造返回了 name: tiger, age: 8, coreInfo: 很重要



//    这里走主构造和次构造

//    copy toString hashCode equals 等等， 主构造是不管次构造的，

//    使用copy的时候，由于内部代码只处理主构造，必须考虑次构造的内容

   val p2 = p1.copy("张三", 12)



    println(p2)    //  输出结果  Person(name=张三, age=12)



// data 数据类 主构造函数

data class Person(val name: String, val age: Int){



    var coreInfo = ""

    init {

        println("主构造函数走了： $name")

    }



    // 次构造函数

    constructor(name: String) : this(name, 8) {

        coreInfo = "很重要"

        println("次构造返回了 name: $name, age: $age, coreInfo: $coreInfo")

    }

}

10、运算符重载

---

    println(AddClass(3, 3) + AddClass(5, 4))



 class AddClass(val number1: Int, val number2: Int){



//      operator fun plus 运算符重载的方式，有多重方式，自行查看

    operator fun plus(addClass: AddClass): Int {

        return (addClass.number1 + number1) + (addClass.number2 + number2)

    }

     

}

11、枚举类定义函数

---

//    显示调用枚举值

    Limbs.LIFT_HAND.show()

    Limbs.RIGHT_HAND.show()

    Limbs.LIFT_FOOT.show()

    Limbs.RIGHT_FOOT.show()



class LimbsInfo(val limbsInfo: String, val length: Int)



enum class Limbs(private val limbsInfo: LimbsInfo){

    LIFT_HAND(LimbsInfo("左手", 100)),

    RIGHT_HAND(LimbsInfo("右手", 100)),

    LIFT_FOOT(LimbsInfo("左脚", 100)),

    RIGHT_FOOT(LimbsInfo("右脚", 100));



    fun show() = println("身体情况：${limbsInfo.limbsInfo} 的长度是：${limbsInfo.length}")

}

12、代数数据类型

---

    println(Teacher(Exam.FRACTION1).show())

    println(Teacher(Exam.FRACTION4).show())



enum class Exam{

    FRACTION1,

    FRACTION2,

    FRACTION3,

    FRACTION4,

}



class Teacher(private val exam: Exam){



    fun show() = when(exam){

        Exam.FRACTION1 -> "不及格的学生"

        Exam.FRACTION2 -> "及格的学生"

        Exam.FRACTION3 -> "良好的学生"

        Exam.FRACTION4 -> "优秀学生"



//        -> else  由于我的show 函数，是使用枚举类 类型来做判断处理的，这个就属于 代数类型，就不需要写else 了

//        因为 when 表达式非常明确了，在这里只有四种类型，不会出现 else 其他的类型，所以就不需要了

    }

}