Swift-Vererbung

Vererbung kann man sich so vorstellen, dass eine Klasse die Methoden und Eigenschaften einer anderen Klasse übernimmt.

Wenn eine Klasse von einer anderen Klasse erbt, wird die erbende Klasse als Unterklasse und die vererbte Klasse als Oberklasse (oder Elternklasse) bezeichnet.

In Swift kann eine Klasse die Methoden, Eigenschaften und Subscripts der Oberklasse aufrufen und auf sie zugreifen sowie sie überschreiben.

Wir können auch Eigenschaftsbeobachter zu Eigenschaften hinzufügen, die von einer Klasse geerbt werden.


Basisklasse

Eine Klasse, die nicht von einer anderen Klasse erbt, wird als Basisklasse bezeichnet.

Im folgenden Beispiel definieren wir eine Basisklasse StudDetails, die eine Studentin bzw. einen Studenten (stname) und ihre bzw. seine Punktzahlen in verschiedenen Fächern (mark1, mark2, mark3) beschreibt:

class StudDetails {
    var stname: String!
    var mark1: Int!
    var mark2: Int!
    var mark3: Int!
    init(stname: String, mark1: Int, mark2: Int, mark3: Int) {
        self.stname = stname
        self.mark1 = mark1
        self.mark2 = mark2
        self.mark3 = mark3
    }
}
let stname = "swift"
let mark1 = 98
let mark2 = 89
let mark3 = 76

let sds = StudDetails(stname:stname, mark1:mark1, mark2:mark2, mark3:mark3);

print(sds.stname)
print(sds.mark1)
print(sds.mark2)
print(sds.mark3)

Die Ausgabe der obigen Programmausführung ist:

swift
98
89
76

Unterklasse

Eine Unterklasse bezieht sich auf das Erstellen einer neuen Klasse auf Grundlage einer vorhandenen Klasse.

Um die Oberklasse einer Klasse anzugeben, schreiben Sie den Namen der Oberklasse nach dem Namen der Unterklasse, getrennt durch einen Doppelpunkt (:). Das Syntaxformat ist wie folgt:

class SomeClass: SomeSuperclass {
    // 类的定义
}

Beispiele

Im folgenden Beispiel definieren wir eine Oberklasse StudDetails und verwenden dann eine Unterklasse Tom, um von ihr zu erben:

class StudDetails
{
    var mark1: Int;
    var mark2: Int;
    
    init(stm1:Int, results stm2:Int)
    {
        mark1 = stm1;
        mark2 = stm2;
    }
    
    func show()
    {
        print("Mark1:\(self.mark1), Mark2:\(self.mark2)")
    }
}

class Tom : StudDetails
{
    init()
    {
        super.init(stm1: 93, results: 89)
    }
}

let tom = Tom()
tom.show()

Die Ausgabe der obigen Programmausführung ist:

Mark1:93, Mark2:89

Überschreiben

Eine Unterklasse kann ihre eigene angepasste Funktionalität durch geerbte Instanzmethoden, Klassenmethoden, Instanzeigenschaften oder Subscripts implementieren. Dieses Verhalten nennen wir Überschreiben.

Wir können das Schlüsselwort override verwenden, um das Überschreiben zu implementieren.

Zugriff auf Methoden, Eigenschaften und Subskripte der Oberklasse

Sie können mithilfe des Präfixes super auf die Methoden, Eigenschaften oder Subskripte der Oberklasse zugreifen.

Überschreiben Zugriff auf Methoden, Eigenschaften und Subskripte
Methoden super.somemethod()
Eigenschaften super.someProperty()
Subscripts super[someIndex]

Überschreiben von Methoden und Eigenschaften

Überschreiben von Methoden

In unserer Unterklasse können wir das Schlüsselwort override verwenden, um die Methoden der Oberklasse zu überschreiben.

Im folgenden Beispiel überschreiben wir die Methode show():

class SuperClass {
    func show() {
        print("这是超类 SuperClass")
    }
}

class SubClass: SuperClass  {
    override func show() {
        print("这是子类 SubClass")
    }
}

let superClass = SuperClass()
superClass.show()

let subClass = SubClass()
subClass.show()

Die Ausgabe der obigen Programmausführung ist:

这是超类 SuperClass
这是子类 SubClass

Überschreiben von Eigenschaften

Sie können einen benutzerdefinierten Getter (oder Setter) bereitstellen, um jede geerbte Eigenschaft zu überschreiben, unabhängig davon, ob die geerbte Eigenschaft eine gespeicherte oder berechnete Eigenschaft ist.

Die Unterklasse weiß nicht, ob die geerbte Eigenschaft gespeichert oder berechnet ist; sie kennt nur den Namen und den Typ der geerbten Eigenschaft. Wenn du also eine Eigenschaft überschreibst, musst du sowohl ihren Namen als auch ihren Typ angeben.

Notizen:

  • Wenn du in der überschriebenen Eigenschaft einen Setter bereitstellst, musst du auch einen Getter bereitstellen.

  • Wenn du den Wert der geerbten Eigenschaft im Getter der überschreibenden Version nicht ändern möchtest, kannst du den geerbten Wert direkt über super.someProperty zurückgeben, wobei someProperty der Name der Eigenschaft ist, die du überschreibst.

Im folgenden Beispiel definieren wir eine Oberklasse Circle und eine Unterklasse Rectangle. In der Klasse Rectangle überschreiben wir die Eigenschaft area:

class Circle {
    var radius = 12.5
    var area: String {
        return "矩形半径 \(radius) "
    }
}

// 继承超类 Circle
class Rectangle: Circle {
    var print = 7
    override var area: String {
        return super.area + " ,但现在被重写为 \(print)"
    }
}

let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("Radius \(rect.area)")

Die Ausgabe der obigen Programmausführung ist:

Radius 矩形半径 25.0  ,但现在被重写为 3

Überschreiben von Eigenschaftsbeobachtern

Du kannst in einer Eigenschaftsüberschreibung Eigenschaftsbeobachter zu einer geerbten Eigenschaft hinzufügen. Auf diese Weise kannst du überwachen, wann sich der Wert der geerbten Eigenschaft ändert.

Hinweis:Du kannst keine Eigenschaftsbeobachter zu geerbten gespeicherten Konstanteneigenschaften oder geerbten schreibgeschützten berechneten Eigenschaften hinzufügen.

class Circle {
    var radius = 12.5
    var area: String {
        return "矩形半径为 \(radius) "
    }
}

class Rectangle: Circle {
    var print = 7
    override var area: String {
        return super.area + " ,但现在被重写为 \(print)"
    }
}


let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("半径: \(rect.area)")

class Square: Rectangle {
    override var radius: Double {
        didSet {
            print = Int(radius/5.0)+1
        }
    }
}


let sq = Square()
sq.radius = 100.0
print("半径: \(sq.area)")
半径: 矩形半径为 25.0  ,但现在被重写为 3
半径: 矩形半径为 100.0  ,但现在被重写为 21

Verhindern von Überschreibungen

Wir können das Schlüsselwort final verwenden, um zu verhindern, dass sie überschrieben werden.

Wenn du eine finale Methode, Eigenschaft oder ein finales Subscript überschreibst, tritt ein Compilerfehler auf.

Du kannst eine gesamte Klasse als final markieren, indem du den Modifikator final (final class) vor das Schlüsselwort class setzt. Eine solche Klasse kann nicht geerbt werden; andernfalls tritt ein Compilerfehler auf.

final class Circle {
    final var radius = 12.5
    var area: String {
        return "矩形半径为 \(radius) "
    }
}
class Rectangle: Circle {
    var print = 7
    override var area: String {
        return super.area + " ,但现在被重写为 \(print)"
    }
}

let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("半径: \(rect.area)")

class Square: Rectangle {
    override var radius: Double {
        didSet {
            print = Int(radius/5.0)+1
        }
    }
}

let sq = Square()
sq.radius = 100.0
print("半径: \(sq.area)")

Da das obige Beispiel das Schlüsselwort final verwendet und kein Überschreiben zulässt, führt die Ausführung zu einem Fehler:

error: var overrides a 'final' var
    override var area: String {
                 ^
note: overridden declaration is here
    var area: String {
        ^
error: var overrides a 'final' var
    override var radius: Double {
                 ^
note: overridden declaration is here
    final var radius = 12.5
              ^
error: inheritance from a final class 'Circle'
class Rectangle: Circle {
      ^
Andere Erweiterungen