Héritage Swift

L'héritage peut être compris comme une classe qui obtient les méthodes et les propriétés d'une autre classe.

Lorsqu'une classe hérite d'une autre classe, la classe héritée est appelée sous-classe, et la classe héritée est appelée classe parente (ou classe mère)

En Swift, une classe peut appeler et accéder aux méthodes, propriétés et scripts d'index de la classe parente, et peut les redéfinir.

Nous pouvons également ajouter des observateurs d'attributs aux propriétés héritées de la classe.

Classe de base

Une classe qui ne hérite pas d'une autre classe est appelée classe de base (Base Class).

Dans cet exemple, nous avons défini la classe de base StudDetails, qui décrit l'étudiant (stname) et les notes de chaque matière (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)

Le résultat de l'exécution du programme ci-dessus est :

swift
98
89
76

Sous-classe

La sous-classe fait référence à la création d'une nouvelle classe sur la base d'une classe existante.

Pour indiquer la classe parente d'une classe, écrivez le nom de la classe parente après le nom de la sous-classe, séparés par un deux-points (:), comme suit

class SomeClass: SomeSuperclass {
    // Définition de la classe
}

Exemple en ligne

Dans cet exemple, nous avons défini la classe parente StudDetails, puis avons utilisé la sous-classe Tom pour l'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()

Le résultat de l'exécution du programme ci-dessus est :

Mark1:93, Mark2:89

Redéfinition (Overriding)

Une sous-classe peut réaliser des fonctionnalités personnalisées en utilisant des méthodes d'exemple héritées, des méthodes de classe, des propriétés d'exemple ou des scripts de sous-script, que nous appelons redéfinition (overriding).

Nous pouvons utiliser le mot-clé override pour réaliser la redéfinition.

Accéder aux méthodes, propriétés et scripts de sous-script de la classe parente

Vous pouvez accéder aux méthodes, propriétés ou scripts de sous-script de la classe parente en utilisant le préfixe super.

Redéfinir	Accéder aux méthodes, propriétés et scripts de sous-script
Méthode	super.somemethod()
Propriété	super.someProperty()
Script de sous-script	super[someIndex]

Redéfinir une méthode et une propriété

Redéfinir une méthode

Dans notre sous-classe, nous pouvons utiliser le mot-clé override pour redéfinir la méthode de la classe parente.

Dans cet exemple, nous avons redéfini la méthode show() :

class SuperClass {
    func show() {
        print("C'est la classe SuperClass")
    }
}
class SubClass: SuperClass {
    override func show() {
        print("C'est la sous-classe SubClass")
    }
}
let superClass = SuperClass()
superClass.show()
let subClass = SubClass()
subClass.show()

Le résultat de l'exécution du programme ci-dessus est :

C'est la super-classe SuperClass
C'est la sous-classe SubClass

Redéfinir la propriété

Vous pouvez fournir un getter (ou un setter) personnalisé pour redéfinir toute propriété héritée, que la propriété héritée soit de type stockage ou de type calcul.

La sous-classe ne sait pas si la propriété héritée est de type stockage ou de type calcul, elle ne sait que la propriété héritée aura un nom et un type. Par conséquent, vous devez écrire le nom et le type de la propriété lorsque vous la redéfinissez.

Remarque :

• Si vous fournissez un setter pour redéfinir une propriété, vous devez également fournir un getter.

• Si vous ne souhaitez pas modifier la valeur de la propriété héritée dans le getter de la version redéfinie, vous pouvez retourner directement la valeur héritée à l'aide de super.someProperty, où someProperty est le nom de la propriété que vous souhaitez redéfinir.

Dans l'exemple suivant, nous définissons la super-classe Cercle et la sous-classe Rectangle, dans la classe Rectangle, nous redéfinissons la propriété area :

class Cercle {
    var radius = 12.5
    var area: String {
        return "Rayon du rectangle \(radius) "
    }
}
// Héritage de la super-classe Cercle
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("Rayon \(rect.area)")

Le résultat de l'exécution du programme ci-dessus est :

Rayon Rayon du rectangle 25.0 ，但现在被重写为 3

Redéfinir l'observateur de propriété

Vous pouvez ajouter un observateur de propriété à une propriété héritée dans une redéfinition de propriété. De cette manière, vous serez informé lorsque la valeur de la propriété héritée change.

Remarque :Vous ne pouvez pas ajouter un observateur de propriété à une propriété de type stockage héritée ou à une propriété de type calcul héritée.

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

Rayon: Rayon du rectangle 25.0 ，但现在被重写为 3
Rayon: Rayon du rectangle 100.0 ，但现在被重写为 21

Empêcher la redéfinition

Nous pouvons utiliser le mot-clé final pour empêcher qu'elles ne soient redéfinies.

Si vous redéfinissez une méthode, une propriété ou un script d'index final, une erreur sera signalée lors de la compilation.

Vous pouvez marquer toute la classe comme final en ajoutant l'attribut final avant le mot-clé class (final class)，une telle classe ne peut pas être héritée, sinon une erreur de compilation sera signalée.

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

En raison de l'utilisation de la clé finale dans l'exemple ci-dessus, il n'est pas permis de la redéfinir, donc l'exécution produira une erreur :

erreur : var redéfinit une 'final' var
    override var area: String {
                 ^
note : la déclaration redéfinie est ici
    var area: String {
        ^
erreur : var redéfinit une 'final' var
    override var radius: Double {
                 ^
note : la déclaration redéfinie est ici
    final var radius = 12.5
              ^
erreur : héritage d'une classe finale 'Circle'
class Rectangle: Circle {
      ^