Kotlin Vererbung

In Kotlin erben alle Klassen von der Klasse Any. Sie ist die Oberklasse aller Klassen und die Standard-Oberklasse für Klassen ohne explizite Deklaration eines Supertyps:

class Example // 从 Any 隐式继承

Any bietet standardmäßig drei Funktionen:

equals()

hashCode()

toString()

Hinweis: Any ist nicht java.lang.Object.

Wenn eine Klasse vererbt werden soll, kann sie mit dem Schlüsselwort open modifiziert werden.

open class Base(p: Int)           // 定义基类

class Derived(p: Int) : Base(p)

Konstruktoren

Unterklasse mit einem primären Konstruktor

Wenn die Unterklasse einen primären Konstruktor hat, muss die Basisklasse sofort im primären Konstruktor initialisiert werden.

open class Person(var name : String, var age : Int){// 基类

}

class Student(name : String, age : Int, var no : String, var score : Int) : Person(name, age) {

}

// 测试
fun main(args: Array<String>) {
    val s =  Student("Example", 18, "S12346", 89)
    println("学生名： ${s.name}")
    println("年龄： ${s.age}")
    println("学生号： ${s.no}")
    println("成绩： ${s.score}")
}

Ausgabe:

学生名： Example
年龄： 18
学生号： S12346
成绩： 89

Unterklasse ohne primären Konstruktor

Wenn die Unterklasse keinen primären Konstruktor hat, muss die Basisklasse in jedem sekundären Konstruktor mit dem Schlüsselwort super initialisiert werden, oder sie muss an einen anderen Konstruktor delegieren. Beim Initialisieren der Basisklasse können unterschiedliche Konstruktoren der Basisklasse aufgerufen werden.

class Student : Person {

    constructor(ctx: Context) : super(ctx) {
    } 

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {
    }
}

Beispiel

/**用户基类**/
open class Person(name:String){
    /**次级构造函数**/
    constructor(name:String,age:Int):this(name){
        //初始化
        println("-------基类次级构造函数---------")
    }
}

/**子类继承 Person 类**/
class Student:Person{

    /**次级构造函数**/
    constructor(name:String,age:Int,no:String,score:Int):super(name,age){
        println("-------继承类次级构造函数---------")
        println("学生名： ${name}")
        println("年龄： ${age}")
        println("学生号： ${no}")
        println("成绩： ${score}")
    }
}

fun main(args: Array<String>) {
    var s =  Student("Example", 18, "S12345", 89)
}

Ausgabe:

-------基类次级构造函数---------
-------继承类次级构造函数---------
学生名： Example
年龄： 18
学生号： S12345
成绩： 89

Überschreiben

In einer Basisklasse wird eine Funktion, wenn sie mit fun deklariert wird, standardmäßig als final gekennzeichnet und kann nicht von Unterklassen überschrieben werden. Wenn Sie zulassen möchten, dass Unterklassen die Funktion überschreiben, müssen Sie manuell open hinzufügen, um sie zu modifizieren. Unterklassen überschreiben Methoden mit dem Schlüsselwort override:

/**用户基类**/
open class Person{
    open fun study(){       // 允许子类重写
        println("我毕业了")
    }
}

/**子类继承 Person 类**/
class Student : Person() {

    override fun study(){    // 重写方法
        println("我在读大学")
    }
}

fun main(args: Array<String>) {
    val s =  Student()
    s.study();

}

Die Ausgabe ist:

I am in college.

Wenn mehrere identische Methoden vorhanden sind (von anderen Klassen geerbt oder implementiert, wie den Klassen A und B), muss die Methode überschrieben werden, und super generic kann verwendet werden, um selektiv die Implementierung der Elternklasse aufzurufen.

open class A {
    open fun f () { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") } //接口的成员变量默认是 open 的
    fun b() { print("b") }
}

class C() : A() , B{
    override fun f() {
        super<A>.f()//调用 A.f()
        super<B>.f()//调用 B.f()
    }
}

fun main(args: Array<String>) {
    val c =  C()
    c.f();

}

C erbt von a() oder b(). C kann nicht nur Funktionen von A oder B erben, sondern C kann auch Funktionen erben, die A() und B() gemeinsam haben. An diesem Punkt hat die Funktion nur eine Implementierung in C. Um Mehrdeutigkeit zu beseitigen, muss die Funktion die Implementierungen dieser Funktion in A() und B() aufrufen und eine eigene Implementierung bereitstellen.

Die Ausgabe ist:

AB

Überschreiben von Eigenschaften

Das Überschreiben von Eigenschaften verwendet das Schlüsselwort override. Eigenschaften müssen kompatible Typen haben. Jede deklarierte Eigenschaft kann durch einen Initialisierer oder eine Getter-Methode überschrieben werden:

open class Foo {
    open val x: Int get { …… }
}

class Bar1 : Foo() {
    override val x: Int = ……
}

Sie können eine val-Eigenschaft mit einer var-Eigenschaft überschreiben, aber nicht umgekehrt. Da eine val-Eigenschaft selbst eine Getter-Methode definiert, wird durch das Überschreiben als var-Eigenschaft zusätzlich eine Setter-Methode in der abgeleiteten Klasse deklariert.

Du kannst das Schlüsselwort override im Primärkonstruktor als Teil der Eigenschaftsdeklaration verwenden:

interface Foo {
    val count: Int
}

class Bar1(override val count: Int) : Foo

class Bar2 : Foo {
    override var count: Int = 0
}