Héritage Swift

L'héritage peut être comprise comme une classe, nous obtenons les méthodes et propriétés d'une autre classe.

Quand une classe hérite d'une autre classe, la classe dérivée est appelée une sous-classe, l'appelé superclasse classe héritée (ou parent)

Dans Swift, les classes peuvent appeler et accéder aux méthodes, les propriétés et script de l'indice superclasse, et peuvent les remplacer.

Nous pouvons également ajouter des propriétés observateur propriété héritée de la classe.

classe de base

Pas d'autres classes héritent d'une classe, appelez la classe de base (classe de base).

L'exemple suivant, nous définissons un StudDetails de classe de base, décrit l'étudiant (stname) et tous les sujets scores (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

print(stname)
print(mark1)
print(mark2)
print(mark3)

La sortie de l'exécution du programme ci-dessus est la suivante:

swift
98
89
76

swift
98
89
76

Sous-classe

Fait référence à une sous-classe est de créer une nouvelle classe basée sur une classe existante.

Pour spécifier la superclasse d'une classe, le nom de super classe écrit sur le dos du nom de la sous-classe, (:) syntaxe séparées par des virgules est comme suit

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

Exemples

L'exemple suivant, nous définissons un StudDetails superclasse, puis la sous-classe Tom hériter:

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()

La sortie de l'exécution du programme ci-dessus est la suivante:

Mark1:93, Mark2:89

Rewrite (Substitution)

Sous-classe peut être héritée des méthodes d'instance, les méthodes de classe, par exemple, la propriété ou script indice pour réaliser leurs capacités de personnalisation, nous appelons ce comportement réécrite (primordial).

Nous pouvons utiliser le mot-clé override pour atteindre réécriture.

Méthodes d'accès superclasse, propriétés et script indice

méthodes de Super vous pouvez utiliser pour accéder au préfixe super classe, la propriété, ou un script indice.

méthodes et propriétés prépondérants

Redéfinition des méthodes

Dans notre sous-classe, nous pouvons utiliser le mot-clé override pour remplacer la méthode superclasse.

Les exemples suivants, nous réécrivent la méthode 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()

La sortie de l'exécution du programme ci-dessus est la suivante:

这是超类 SuperClass
这是子类 SubClass

Propriétés prépondérants

Vous pouvez fournir un getter personnalisé (ou setter) pour réécrire toute propriété héritée, si la propriété est héritée à un type de stockage ou le type de propriété de l'informatique.

Classe ne connaît pas la propriété héritée est le type de stockage ou le type de calcul, il ne sait propriété héritée aura un nom et le type. Donc, vous réécrivez une propriété, il est nécessaire de nom et le type écrit.

Précautions:

• Si vous fournissez setter dans la réécriture des propriétés, vous devez fournir getter.

• Si vous ne voulez pas getter version réécrite pour modifier les valeurs des propriétés héritées, vous pouvez revenir aux valeurs héritées par super.someProperty, où someProperty est le nom que vous souhaitez remplacer la propriété.

L'exemple suivant, nous définissons une sous-classe de superclasse Circle et Rectangle, nous réécrire le domaine de la propriété de la classe Rectangle:

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)")

La sortie de l'exécution du programme ci-dessus est la suivante:

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

Substitution Propriétés Viewer

Vous pouvez ajouter une propriété à la propriété est héritée propriétés observées dans la réécriture. Par conséquent, lorsque les changements de valeur de propriété héritées, vous seront surveillés.

Remarque: Vous ne pouvez pas ajouter des propriétés observateur pour le type hérité attribuer des constantes mémoire ou propriété en lecture seule de calcul hérité.

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

Prévenir réécriture

Nous pouvons utiliser le mot-clé final les empêche d'être écrasé.

Si vous remplacez une dernière méthode, la propriété, ou un script de l'indice, en cas d'erreur de compilation.

Vous pouvez ajouter la finale avant la classe de mot-clé caractéristique (classe finale) à la classe entière est marquée finale, de sorte que la classe ne peut pas être héritée, sinon des erreurs de compilation seront communiquées.

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)")

En raison de l'exemple ci-dessus utilise le mot-clé final n'a pas le droit de réécrire, de sorte que l'exécution sera donnée:

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 {
      ^