Swift Vererbung

Die Vererbung können wir als das Erhalten von Methoden und Eigenschaften einer anderen Klasse verstehen.

Wenn eine Klasse von einer anderen Klasse abgeleitet wird, wird die abgeleitete Klasse als Unterklasse und die abgeleitete Klasse als Superklasse (oder Elterklasse) bezeichnet.

In Swift können Klassen Methoden, Eigenschaften und Index-Operator der Superklasse aufrufen und auf sie zugreifen und sie überschreiben.

Wir können auch Property Observers zu den Attributen hinzufügen, die von der Klasse vererbt wurden.

Basisklasse

keine anderen Klassen vererbt, wird sie Basisklasse (Base Class) genannt.

In diesem Beispiel haben wir die Basisklasse StudDetails definiert, die die Daten des Schülers (stname) und die Noten der verschiedenen Fächer (mark1、mark2、mark3)：

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.mark)1)
print(sds.mark)2)
print(sds.mark)3)

Die Ausgabe des obigen Programms lautet:

swift
98
89
76

Unterklasse

Eine Unterklasse ist eine neue Klasse, die auf einer bestehenden Klasse basiert.

Um eine Oberklasse einer Klasse anzugeben, wird der Name der Oberklasse hinter dem Namen der Unterklasse geschrieben, getrennt durch einen Doppelpunkt (:), und die Syntax ist wie folgt

class SomeClass: SomeSuperclass {
    // Klassendefinition
}

Online-Beispiel

In diesem Beispiel haben wir die Oberklasse StudDetails definiert und dann die Unterklasse Tom verwendet, um sie 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 des obigen Programms lautet:

Mark1:93, Mark2:89

Überschreiben (Overriding)

Die Unterklasse kann durch geerbte Beispiele, Klassenmethoden, Beispieleigenschaften oder Index-Operator eigene angepasste Funktionen implementieren, die wir als Überschreiben (Overriding) bezeichnen.

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

Methoden, Eigenschaften und Index-Operator der Oberklasse aufrufen

Sie können den Präfix super verwenden, um Methoden, Eigenschaften oder Index-Operator der Oberklasse aufzurufen.

Überschreiben	Methoden, Eigenschaften und Index-Operator aufrufen
Methode	super.somemethod()
Eigenschaft	super.someProperty()
Index-Operator	super[someIndex]

Methode und Eigenschaft überschreiben

Methode überschreiben

In unserer Unterklasse können wir mit dem Schlüsselwort override Methoden der Oberklasse überschreiben.

In diesem Beispiel haben wir die Methode show() überschrieben:

class SuperClass {
    func show() {
        print("Das ist die Oberklasse SuperClass")
    }
}
class SubClass: SuperClass {
    override func show() {
        print("Das ist die Unterklasse SubClass")
    }
}
let superClass = SuperClass()
superClass.show()
let subClass = SubClass()
subClass.show()

Die Ausgabe des obigen Programms lautet:

Dies ist die Superklasse SuperClass
Dies ist die Unterklasse SubClass

Eigenschaft überschreiben

Du kannst angepasste Getter (oder Setter) bereitstellen, um jede vererbte Eigenschaft, ob sie eine speichernde oder berechnete Eigenschaft ist, zu überschreiben.

Die Unterklasse weiß nicht, ob die vererbte Eigenschaft eine speichernde oder berechnete Eigenschaft ist, sie weiß nur, dass die vererbte Eigenschaft einen Namen und einen Typ hat. Daher musst du den Namen und den Typ der Eigenschaft angeben, wenn du eine Eigenschaft überschreibst.

Hinweis:

• Wenn du einen Setter für die Eigenschaft überschreibst, dann musst du auch einen Getter bereitstellen.

• Wenn du den Wert der vererbten Eigenschaft im Getter der Überschreibversion nicht ändern möchtest, kannst du den Wert der vererbten Eigenschaft direkt über super.someProperty zurückgeben, wobei someProperty der Name der Eigenschaft ist, die du überschreiben möchtest.

Im folgenden Beispiel haben wir die Superklasse Circle und die Unterklasse Rectangle definiert. In der Klasse Rectangle überschreiben wir die Eigenschaft area:

class Circle {
    var radius = 12.5
    var area: String {
        return "Rechteckradius \(radius) "
    }
}
// Vererbe Superklasse 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 des obigen Programms lautet:

Radius Rechteckradius 25.0 ，但现在被重写为 3

Eigenschaftsbeobachter überschreiben

Du kannst in der Eigenschaftsüberschreibung einen Property-Beobachter für eine vererbte Eigenschaft hinzufügen. Auf diese Weise kannst du benachrichtigt werden, wenn der Wert der vererbten Eigenschaft geändert wird.

Hinweis:Du kannst keine Property-Beobachter für vererbte statische Eigenschaften oder vererbte reine Lesbar berechnete Eigenschaften hinzufügen.

class Circle {
    var radius = 12.5
    var area: String {
        return "Rechteckradius: \(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("Radius: \(rect.area)")
class Square: Rectangle {
    override var radius: Double {
        didSet {}}
            print = Int(radius/5.0)+1
        }
    }
}
let sq = Square()
sq.radius = 100.0
print("Radius: \(sq.area)")

Radius: Rechteckradius von 25.0 ，但现在被重写为 3
Radius: Rechteckradius von 100.0 ，但现在被重写为 21

Verhindere das Überschreiben

Wir können den final-Schlüssel verwenden, um zu verhindern, dass sie überschrieben werden.

Wenn du final Methoden, Eigenschaften oder Index-Scripte überschreibst, wird bei der Kompilierung ein Fehler gemeldet.

Du kannst die entire Klasse als final markieren, indem du die final-Eigenschaft vor dem Schlüsselwort class hinzufügst (final class). Solche Klassen können nicht vererbt werden, andernfalls wird eine Kompilationsfehlermeldung ausgegeben.

final class Circle {
    final var radius = 12.5
    var area: String {
        return "Rechteckradius: \(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("Radius: \(rect.area)")
class Square: Rectangle {
    override var radius: Double {
        didSet {}}
            print = Int(radius/5.0)+1
        }
    }
}
let sq = Square()
sq.radius = 100.0
print("Radius: \(sq.area)")

Da der obige Beispiel mit dem finalen Schlüsselwort nicht überschrieben werden darf, wird ein Fehler ausgegeben:

Fehler: var überschreibt einen 'final' var
    override var area: String {
                 ^
Hinweis: Überladene Deklaration ist hier
    var area: String {
        ^
Fehler: var überschreibt einen 'final' var
    override var radius: Double {
                 ^
Hinweis: Überladene Deklaration ist hier
    final var radius = 12.5
              ^
Fehler: Vererbung von einer finalen Klasse 'Circle'
class Rectangle: Circle {
      ^