Polimorfismo tramite interfacce

Fa parte della sezione Programmazione orientata agli oggetti del percorso Dart di Coddy. Lezione 58 di 110.

Nella lezione precedente, hai visto il polimorfismo tramite l'ereditarietà: usare il tipo di una classe genitore per lavorare con oggetti figlio. Ma il polimorfismo funziona anche tramite le interfacce e questo approccio è spesso più flessibile.

Quando le classi implementano la stessa interfaccia, puoi trattarle in modo polimorfico anche se non hanno alcuna relazione di ereditarietà:

abstract class Printable {
  void printDetails();
}

class Invoice implements Printable {
  @override
  void printDetails() => print('Invoice #1234');
}

class Report implements Printable {
  @override
  void printDetails() => print('Monthly Report');
}

class Receipt implements Printable {
  @override
  void printDetails() => print('Receipt for purchase');
}

void printAll(List<Printable> items) {
  for (var item in items) {
    item.printDetails();
  }
}

void main() {
  var documents = [Invoice(), Report(), Receipt()];
  printAll(documents);
}

Invoice, Report e Receipt sono classi completamente non correlate: non condividono una classe genitore. Eppure, poiché implementano tutte Printable, possiamo memorizzarle nella stessa lista e chiamare printDetails() su ciascuna.

Questo è potente perché ti permette di definire contratti di comportamento senza imporre una gerarchia di ereditarietà. Qualsiasi classe può implementare un'interfaccia, indipendentemente da ciò che estende. Il tuo codice diventa più modulare, poiché puoi aggiungere nuovi tipi stampabili senza modificare il codice esistente: basta implementare l'interfaccia.

Sfida

Facile

Costruiamo un sistema di riproduzione multimediale che dimostri il polimorfismo tramite interfacce. Creerai un'interfaccia che definisce cosa significa essere «riproducibile», poi implementerai diversi tipi di contenuti multimediali non correlati che rispettano tutti questo contratto, consentendo di gestirli in modo uniforme nonostante non abbiano alcuna relazione di ereditarietà.

Organizzerai il codice in due file:

media.dart: definisci qui la tua interfaccia e le classi multimediali:
- Una classe astratta Playable con due metodi astratti: play() e String getMediaType()
- Una classe Song che implementa Playable. Dovrebbe avere String title e String artist. Il suo metodo play() stampa Playing song: [title] by [artist] e getMediaType() restituisce 'Audio'
- Una classe Video che implementa Playable. Dovrebbe avere String title e int duration (in minuti). Il suo metodo play() stampa Playing video: [title] ([duration] min) e getMediaType() restituisce 'Video'
- Una classe Podcast che implementa Playable. Dovrebbe avere String title e int episode. Il suo metodo play() stampa Playing podcast: [title] - Episode [episode] e getMediaType() restituisce 'Podcast'
Crea anche una funzione playAll(List<Playable> playlist) che scorre l'elenco e, per ogni elemento, stampa [Media Type]: e poi chiama play() su quell'elemento.
main.dart: importa il tuo file multimediale e mostra il polimorfismo basato sulle interfacce:
- Crea una List<Playable> contenente un Song con titolo 'Imagine' e artista 'John Lennon', un Video con titolo 'Dart Tutorial' e durata 15, e un Podcast con titolo 'Tech Talk' ed episodio 42
- Passa questo elenco a playAll()

Nota che Song, Video e Podcast non condividono alcuna classe genitore: sono tipi del tutto indipendenti. Tuttavia, poiché implementano tutti Playable, puoi inserirli nello stesso elenco e trattarli in modo uniforme tramite l'interfaccia.

Output previsto:

Audio:
Playing song: Imagine by John Lennon
Video:
Playing video: Dart Tutorial (15 min)
Podcast:
Playing podcast: Tech Talk - Episode 42

Provalo tu

import 'media.dart';

void main() {
  // TODO: Crea una List<Playable> contenente:
  // - Una Song con title 'Imagine' e artist 'John Lennon'
  // - Un Video con title 'Dart Tutorial' e duration 15
  // - Un Podcast con title 'Tech Talk' e episode 42
  
  // TODO: Passa la lista a playAll()
}