Implémenter ou étendre

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

Maintenant que tu comprends à la fois extends et implements, clarifions quand utiliser chacun d’eux.

Utilisez extends lorsque vous souhaitez hériter d’un comportement. Votre sous-classe obtient gratuitement tout le code de la classe parente et peut s’appuyer dessus :

class Animal {
  void breathe() {
    print('Breathing...');
  }
}

class Dog extends Animal {
  void bark() {
    print('Woof!');
  }
}

void main() {
  var dog = Dog();
  dog.breathe();  // Hérité - fonctionne automatiquement
  dog.bark();
}

Utilisez implements lorsque vous voulez garantir une structure sans hériter de code. Vous devez écrire chaque méthode vous-même :

class Robot implements Animal {
  @override
  void breathe() {
    print('Ventilating circuits...');  // Implémentation complètement personnalisée
  }
}

La différence essentielle : extends signifie « Je suis un type de ceci », tandis que implements signifie « Je peux faire ce que ceci fait ». Un Dog est un Animal et respire de la même manière. Un Robot n’est pas un animal, mais il peut respecter le même contrat avec sa propre logique.

Rappelle-toi : tu ne peux étendre qu’une seule classe, mais tu peux implémenter de nombreuses interfaces. Choisis extends pour les véritables relations d’héritage, et implements lorsque tu as besoin de flexibilité ou que tu veux imposer un contrat sans partager les détails de l’implémentation.

Défi

Facile

Construisons un système de travailleurs qui démontre quand utiliser extends plutôt que implements. Vous allez créer une classe de base pour les travailleurs, puis présenter les deux approches : une classe qui « est un » travailleur et hérite de son comportement, et une autre qui peut simplement « faire » ce que fait un travailleur, mais avec une logique entièrement personnalisée.

Vous organiserez votre code en deux fichiers :

worker.dart : définissez ici votre hiérarchie de travailleurs :
- Une classe Worker avec une propriété String name et un constructeur. Incluez une méthode work() qui affiche [name] is working... et une méthode takeBreak() qui affiche [name] takes a coffee break
- Une classe OfficeWorker qui étend Worker. Ajoutez une propriété String department. Surchargez work() pour afficher [name] is typing reports in [department], tout en conservant le comportement hérité de takeBreak()
- Une classe RobotWorker qui implémente Worker. Ajoutez une propriété String model. Comme les robots ne sont pas réellement des travailleurs, mais peuvent faire ce que font les travailleurs, fournissez des implémentations entièrement personnalisées : work() doit afficher Robot [model] is assembling parts et takeBreak() doit afficher Robot [model] is recharging
main.dart : importez votre fichier de travailleurs et présentez les deux approches :
- Créez un OfficeWorker nommé 'Alice' dans le service 'Marketing'
- Créez un RobotWorker avec le modèle 'RX-7'
- Pour le travailleur de bureau, appelez work() puis takeBreak()
- Affichez une ligne vide
- Pour le robot, appelez work() puis takeBreak()

Remarquez comment OfficeWorker hérite automatiquement de takeBreak() parce qu’il étend Worker — c’est véritablement « un » travailleur. En revanche, RobotWorker doit fournir sa propre implémentation pour chaque élément, car il ne fait qu’implémenter l’interface — il peut « faire » ce que fait un travailleur, mais à sa propre manière robotique.

Sortie attendue :

Alice is typing reports in Marketing
Alice takes a coffee break

Robot RX-7 is assembling parts
Robot RX-7 is recharging

Essayez vous-même

import 'worker.dart';

void main() {
  // TODO: Créer un OfficeWorker nommé 'Alice' dans le département 'Marketing'
  
  // TODO: Créer un RobotWorker avec le modèle 'RX-7'
  
  // TODO: Pour le travailleur de bureau, appeler work() puis takeBreak()
  
  // TODO: Afficher une ligne vide
  
  // TODO: Pour le travailleur robot, appeler work() puis takeBreak()
}