Swift Academy · Leçon

Héritage de classes et mot-clé super

Créer des sous-classes, appeler super.init() et étendre le comportement de la superclasse.

Leçon 1 sur 412 étapes

Héritage de classes et mot-clé super est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Bienvenue

Les classes prennent en charge l’héritage : une sous-classe peut étendre ou spécialiser une superclasse. Cela permet la réutilisation du code et le polymorphisme, piliers essentiels de la conception orientée objet.

Définir une sous-classe

```swift class Animal { var name: String init(name: String) { self.name = name } func speak() { print("...") } } class Dog: Animal { func fetch() { print("\(name) fetches!") } } let d = Dog(name: "Rex") d.speak() // "..." d.fetch() // "Rex fetches!" ```

Appel obligatoire de `super.init()`

```swift class Vehicle { var speed: Double init(speed: Double) { self.speed = speed } } class Car: Vehicle { var brand: String init(brand: String, speed: Double) { self.brand = brand super.init(speed: speed) // must call super } } ```

Initialisation en deux phases

Règles d’initialisation en deux phases de Swift : 1. Toutes les propriétés stockées *propres à la classe* doivent être définies *avant* l’appel de `super.init()` 2. Après `super.init()`, vous pouvez personnaliser les propriétés héritées Cela vous empêche d’utiliser une mémoire non initialisée.

Appeler les méthodes de la superclasse

```swift class Shape { func draw() { print("Drawing shape") } } class Circle: Shape { override func draw() { super.draw() // call parent implementation print("Drawing circle") } } ```

Héritage des propriétés

Les sous-classes héritent de toutes les propriétés de la superclasse : ```swift class Person { var name: String = "" var age: Int = 0 } class Employee: Person { var company: String = "" } let e = Employee() e.name = "Alice" e.company = "Acme" ```

Initialiseurs désignés et de commodité

• *Désigné* — initialise complètement toutes les propriétés ; appelle `super.init()` • *De commodité* — délègue à un autre initialiseur avec `self.init()` ```swift convenience init(name: String) { self.init(name: name, age: 0) // delegates to designated } ```

Initialiseur requis

Marquez un initialiseur `required` pour obliger toutes les sous-classes à l’implémenter : ```swift class Base { required init(id: Int) { ... } } class Sub: Base { required init(id: Int) { super.init(id: id) } } ``` Cas fréquent lorsqu’une méthode de fabrique doit créer des instances via un protocole.

Hiérarchie des classes et types

```swift let a: Animal = Dog(name:"Buddy") print(a is Dog) // true print(a is Animal) // true ``` Une `Dog` IS-A `Animal` — les instances d’une sous-classe satisfont aux exigences de type de la superclasse.

Héritage simple

Les classes Swift ne prennent en charge que l’héritage *simple* (une seule superclasse). Cependant, une classe peut se conformer à de nombreux protocoles : ```swift class MyVC: UIViewController, UITableViewDelegate, UITableViewDataSource { } ``` Les protocoles sont le mécanisme de Swift permettant l’héritage multiple du comportement.

Vérification rapide

Dans l’initialiseur désigné d’une sous-classe, quand devez-vous appeler `super.init()` ?

Réponds-y dans la leçon interactive

Récapitulatif

Points essentiels : • Créez une sous-classe avec `class Sub: Super` • Appelez `super.init()` après avoir défini vos propres propriétés • Initialisation en deux phases : vos propres propriétés d’abord, puis la superclasse • `super.method()` appelle l’implémentation de la classe parente • Swift utilise l’héritage simple ; utilisez les protocoles pour obtenir plusieurs comportements Ensuite : redéfinition, final et prévention de l’héritage.

Gratuit pour commencer

Apprends Swift avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 122
Leçons: 409

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Héritage de classes et mot-clé super » est-elle gratuite ?

Oui — le texte complet de « Héritage de classes et mot-clé super » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Héritage de classes et mot-clé super » ?

Créer des sous-classes, appeler super.init() et étendre le comportement de la superclasse. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Héritage de classes et mot-clé super » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Héritage de classes et mot-clé super
override, final et prévention de l’héritage
Conversion de types : is, as?, as! et as
Désinitialiseurs et cycle de vie de la mémoire

← Retour à Swift Academy