Kotlin 第六站

//kotlin 继承
//Kotlin 中所有的类都继承自Any类，他是所有类的超类，对于没有超类声明的类是默认超类
// Any 类有三个函数equals() hasCode() toString()

fun main(args:Array<String>){
    var s = Student(12,"green","s1234",88)
    println("姓名是：${s.name}")
    println("年龄是： ${s.age}")
    println("学号是:${s.no}")
    println("分数：${s.score}")
    var ss = Student2(11,"Game","s2345",99)
    var sss = Student2(1111,"Game Over")
    var person = Person4()
    person.study()
    var ss2 = Student3()
    ss2.study()
    var c = C()
    c.f()
    c.a()
    c.b()

}
class Empty // 空类
// 如果一个类被继承可以使用open关键字，因为kotlin中类默认是final的，不允许继承
open class Base2(p:Int){
    val p:Int?
    init {
        this.p = p
    }
}
class Derived2(p:Int):Base2(p)
//构造函数
//子类有主构造函数

open class Person3(age:Int,name:String){

    var name:String? = null
    var age:Int? = 0
    init {
        this.name = name
        this.age = age
    }
    constructor(name: String):this(12,name)
}
//如果子类中有主构造函数，则基类必须在主构造函数中进行初始化
class Student(age:Int,name:String,var no:String,var score:Int) :Person3(age,name)
//如果子类中没有主构造函数，则必须在每个二级构造函数中用super关键字初始化基类，或者在代理另一个构造函数。
//初始化基类时，可以调用基类不同的构造方法
class Student2 :Person3{
    constructor(age: Int,name: String,no: String,score: Int):super(age,name){
        println("姓名是：${name}")
        println("年龄是： ${age}")
        println("学号是:${no}")
        println("分数：${score}")
    }
    constructor(age: Int,name: String):super(name){
        println("姓名是：${name}")
        println("年龄是： ${this.age}")
    }
}
//重写
//在基类中，使用fun声明函数时，函数默认是final类型的，不能被重写，
// 如果想让子类重写需要手动添加open关键字修饰他，子类重写方法使用override关键字
open class Person4{
    open fun study(){
        println("我毕业了")
    }
}
class Student3 : Person4(){
    override fun study() {
        println("我有上学了")
    }
}
//如果有多个相同的方法（继承或者实现自其它类如A类和B类），则必须要重写该方法，使用super泛型去选择性的调用父类的实现
open class A{
    open fun f(){
        println("A")
    }
    fun a(){
        println("a")
    }
}
interface B{
    fun f(){println("B")}
    fun b(){println("b")}
}
//C类继承自A类和B类，C不仅可以在A类或B类中继承函数，而且可以继承A类、B类中的公共的函数
//此时函数在类中只有一个实现，为了消除歧义，该函数必须调用A类或B类该函数的实现，并提供自己的实现
class C() : A(), B{
    override fun f() {
        super<A>.f()
        super<B>.f()
    }
}
// 属性重写
//属性重写使用override关键字，必须具有兼容类型，每一个声明的属性都可以通过初始化程序或者getter方法被重写
open class foo2{
    open val count:Int = 2
    get() = field
}
class Bar1 : foo2(){
    override val count: Int
        get() = 3
}
//可以使用一个var属性重写一个val属性，但是反过来就不行。
//因为val属性本身定义了getter方法，重写var属性会在衍生类中额外声明一个setter方法
//可以在主构造函数中使用override关键字作为属性的一部分
interface foo3{
    val count :Int?
}
class Bar2(override val count : Int) :foo3
class Bar3 : foo3{
    override var count: Int? = 0
}