Interfaces multiples

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy — leçon 48 sur 110.

L'un des plus grands avantages des interfaces par rapport à l'héritage est qu'une classe peut implémenter plusieurs interfaces. Alors que Dart vous limite à l'extension d'une seule classe, vous pouvez implémenter autant d'interfaces que nécessaire.

abstract class Printable {
  void printContent();
}

abstract class Saveable {
  void save();
}

abstract class Shareable {
  void share(String recipient);
}

class Document implements Printable, Saveable, Shareable {
  String content;
  
  Document(this.content);
  
  @override
  void printContent() {
    print('Printing: $content');
  }
  
  @override
  void save() {
    print('Saving document...');
  }
  
  @override
  void share(String recipient) {
    print('Sharing with $recipient');
  }
}

Lors de l'implémentation de plusieurs interfaces, vous devez fournir des implémentations pour toutes les méthodes de chaque interface. La classe doit remplir tous les contrats qu'elle s'engage à supporter.

Vous pouvez également combiner extends avec plusieurs clauses implements :

class Report extends Document implements Printable, Shareable {
  Report(String content) : super(content);
  
  // Must still implement all interface methods
  // (already inherited from Document in this case)
}

Cette flexibilité vous permet de concevoir des classes qui s'adaptent à plusieurs rôles. Un SmartPhone pourrait implémenter les interfaces Camera, Phone et MusicPlayer, promettant qu'il peut faire tout ce que chaque interface requiert tout en conservant sa propre implémentation unique.

Défi

Facile

Construisons un système d'appareils intelligents qui démontre comment une seule classe peut implémenter plusieurs interfaces pour combiner différentes capacités. Vous allez créer des classes d'interface distinctes pour les différentes fonctionnalités de l'appareil, puis construire un appareil capable de tout faire.

Vous organiserez votre code en deux fichiers :

devices.dart : Définissez vos interfaces et la classe d'implémentation ici :
- Une classe Connectable avec une méthode connect() qui affiche Connecting to network...
- Une classe Chargeable avec une méthode charge() qui affiche Charging battery...
- Une classe Displayable avec une méthode showScreen(String content) qui affiche Displaying: [content]
- Une classe Tablet qui implémente les trois interfaces : Connectable, Chargeable, et Displayable. Ajoutez une propriété String brand avec un constructeur. Vos implémentations doivent afficher [brand] tablet connecting to WiFi pour connect, [brand] tablet charging via USB-C pour charge, et [brand] screen: [content] pour showScreen
main.dart : Importez votre fichier d'appareils et démontrez comment la Tablet remplit les trois contrats d'interface :
- Créez une Tablet avec la marque 'Galaxy'
- Appelez connect()
- Appelez charge()
- Appelez showScreen('Welcome Home')

Votre classe Tablet doit fournir sa propre implémentation pour chaque méthode des trois interfaces. Cela montre comment l'implémentation de plusieurs interfaces permet à une seule classe de promettre plusieurs capacités tout en gardant chaque implémentation unique à l'appareil.

Sortie attendue :

Galaxy tablet connecting to WiFi
Galaxy tablet charging via USB-C
Galaxy screen: Welcome Home

Aide-mémoire

Une classe peut implémenter plusieurs interfaces en les listant après le mot-clé implements, séparées par des virgules :

abstract class Printable {
  void printContent();
}

abstract class Saveable {
  void save();
}

class Document implements Printable, Saveable {
  @override
  void printContent() {
    print('Printing...');
  }
  
  @override
  void save() {
    print('Saving...');
  }
}

Lors de l'implémentation de plusieurs interfaces, vous devez fournir des implémentations pour toutes les méthodes de chaque interface.

Vous pouvez combiner extends avec plusieurs implements :

class Report extends Document implements Printable, Shareable {
  Report(String content) : super(content);
  
  // Doit implémenter toutes les méthodes de l'interface
}

Cela permet à une classe de remplir plusieurs contrats et d'assumer plusieurs rôles simultanément.

Essayez vous-même

import 'devices.dart';

void main() {
  // TODO: Créer une Tablet avec la marque 'Galaxy'
  
  // TODO: Appeler connect()
  
  // TODO: Appeler charge()
  
  // TODO: Appeler showScreen('Welcome Home')
  
}