Comment fonctionne l'héritage dans le langage Swift ?

En Swift, l'héritage est réalisé via des classes. Une classe peut hériter des propriétés et méthodes d'une autre classe.

• Classe de base : Classe dont héritent d'autres classes. N'hérite d'aucune autre classe.
• Classe dérivée (héritée) : Classe qui hérite de la classe de base. Peut ajouter de nouvelles propriétés et méthodes, ainsi que redéfinir celles héritées.

Points clés :

• Swift supporte uniquement l'héritage simple (une classe ne peut hériter que d'une seule classe).
• Utilisation du mot-clé class pour définir une classe.
• Utilisation de deux points : après le nom de la classe héritée, suivi du nom de la classe de base.
• Redéfinition des méthodes et propriétés avec le mot-clé override.
• Interdiction de redéfinir avec le mot-clé final avant la définition de la classe, méthode ou propriété.

// Classe de base
class Vehicle {
    var currentSpeed = 0.0

    func accelerate() {
        currentSpeed += 10
    }

    func description() -> String {
        return "voyageant à \(currentSpeed) mph"
    }
}

// Classe dérivée
class Car: Vehicle {
    var gear = 1

    // Redéfinition de la méthode
    override func accelerate() {
        super.accelerate() // Appel de la méthode de la classe de base
        gear += 1
    }

    // Ajout d'une nouvelle méthode
    func changeGear(to newGear: Int) {
        gear = newGear
    }

    // Redéfinition de la propriété (calculée)
    override func description() -> String {
        return super.description() + " en vitesse \(gear)"
    }
}

// Classe interdite à l'héritage
final class Motorcycle: Vehicle {
    // Peut avoir ses propres propriétés et méthodes, mais ne peut pas être hérité
}

Avantages de l'héritage :

• Réutilisation du code : Les héritiers utilisent la fonctionnalité de la classe de base.
• Polymorphisme : Possibilité de travailler avec des objets de différentes classes héritées via une référence à la classe de base.
• Extensibilité : Ajout de nouvelles fonctionnalités dans les héritiers sans modifier la classe de base.

Inconvénients de l'héritage :

• Liaison rigide : Les changements dans la classe de base peuvent affecter les classes héritées.
• Problème du diamant (dans les langages avec héritage multiple) : Swift ne le possède pas grâce à l'héritage simple.
• Complexité de la hiérarchie : Les hiérarchies profondes peuvent être difficiles à comprendre et à maintenir.

Swift privilégie la composition plutôt que l'héritage pour atteindre flexibilité et réutilisation du code, notamment avec les protocoles et extensions. Cependant, l'héritage reste un outil important pour créer des structures hiérarchiques et appliquer les principes de la programmation orientée objet.