Bases du polymorphisme

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy. Leçon 57 sur 110.

Le polymorphisme signifie « plusieurs formes » : c'est la capacité de traiter des objets de différentes classes via une interface commune. Lorsque vous avez une référence de classe parente, elle peut pointer vers n'importe quel objet de classe enfant, et la méthode appropriée est appelée en fonction du type d'objet réel.

C'est puissant car vous pouvez écrire du code qui fonctionne avec le type parent, tout en gérant automatiquement tous les types enfants correctement :

class Animal {
  void speak() => print('Some sound');
}

class Dog extends Animal {
  @override
  void speak() => print('Woof!');
}

class Cat extends Animal {
  @override
  void speak() => print('Meow!');
}

void main() {
  Animal myPet = Dog();  // Type parent, objet enfant
  myPet.speak();  // Sortie : Woof!
  
  myPet = Cat();  // Même variable, objet différent
  myPet.speak();  // Sortie : Meow!
}

La variable myPet est déclarée comme Animal, mais elle contient un Dog ou un Cat. Lorsque speak() est appelée, Dart examine le type réel de l'objet au moment de l'exécution et appelle la méthode redéfinie appropriée.

Cela vous permet d'écrire des fonctions flexibles qui fonctionnent avec n'importe quelle sous-classe :

void makeAllSpeak(List<Animal> animals) {
  for (var animal in animals) {
    animal.speak();  // Chaque animal s'exprime à sa manière
  }
}

void main() {
  var pets = [Dog(), Cat(), Dog()];
  makeAllSpeak(pets);
  // Sortie : Woof! Meow! Woof!
}

La fonction n'a pas besoin de connaître Dog ou Cat - elle fonctionne simplement avec Animal. Cela rend votre code plus extensible car l'ajout de nouveaux types d'animaux ne nécessite aucune modification des fonctions existantes.

Défi

Facile

Construisons un système d'instruments de musique qui démontre le polymorphisme en action. Tu vas créer une classe de base Instrument et plusieurs types d'instruments, puis écrire une fonction capable de faire jouer ensemble n'importe quelle collection d'instruments — sans connaître leurs types spécifiques.

Tu organiseras ton code en deux fichiers :

instruments.dart : Définis ici ta hiérarchie d'instruments :
- Une classe Instrument avec une propriété String name et un constructeur. Inclus une méthode play() qui affiche [name] makes a sound
- Une classe Guitar qui étend Instrument et redéfinit play() pour afficher [name] strums melodically
- Une classe Drum qui étend Instrument et redéfinit play() pour afficher [name] beats rhythmically
- Une classe Piano qui étend Instrument et redéfinit play() pour afficher [name] plays harmoniously
Crée également une fonction performConcert(List<Instrument> instruments) qui affiche Concert begins!, parcourt ensuite la liste en appelant play() sur chaque instrument, puis affiche finalement Concert ends!
main.dart : Importe ton fichier d'instruments et démontre le polymorphisme en créant un groupe mixte :
- Crée une liste de type List<Instrument> contenant une Guitar nommée 'Acoustic', un Drum nommé 'Snare' et un Piano nommé 'Grand'
- Transmets cette liste à performConcert()

Remarque que performConcert() fonctionne avec le type parent Instrument, tandis que chaque instrument joue d'une manière qui lui est propre. Il s'agit du polymorphisme : le même appel de méthode produit un comportement différent selon le type réel de l'objet.

Résultat attendu :

Concert begins!
Acoustic strums melodically
Snare beats rhythmically
Grand plays harmoniously
Concert ends!

Essayez vous-même

import 'instruments.dart';

void main() {
  // TODO: Créer une List<Instrument> contenant :
  // - Une Guitar nommée 'Acoustic'
  // - Un Drum nommé 'Snare'
  // - Un Piano nommé 'Grand'
  
  
  // TODO: Appeler performConcert() avec votre liste d'instruments
  
}