Composizione vs ereditarietà

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

Hai imparato che l'ereditarietà crea una relazione «è un»: un Dog è un Animal. Ma c'è un altro approccio potente: la composizione, che crea una relazione «ha un». Invece di ereditare il comportamento, una classe contiene istanze di altre classi e delega loro il lavoro.

Considera una classe Car. Con l'ereditarietà, potresti provare a estendere una classe Engine, ma un'auto non è un motore: ha un motore:

class Engine {
  void start() => print('Engine started');
}

class Car {
  final Engine _engine = Engine();  // Composizione: Car HA un Engine
  
  void start() {
    _engine.start();  // Delega al motore
    print('Car is ready to drive');
  }
}

void main() {
  var car = Car();
  car.start();
}

Il vantaggio principale della composizione è la flessibilità. Con l'ereditarietà, sei vincolato a una singola classe genitore. Con la composizione, puoi combinare più componenti e persino sostituirli durante l'esecuzione:

class ElectricEngine {
  void start() => print('Electric motor humming');
}

class HybridCar {
  Engine? _gasEngine;
  ElectricEngine? _electricEngine;
  
  HybridCar({bool useElectric = false}) {
    if (useElectric) {
      _electricEngine = ElectricEngine();
    } else {
      _gasEngine = Engine();
    }
  }
}

Una linea guida comune è "preferisci la composizione all’ereditarietà". Usa l’ereditarietà quando c’è una vera relazione "è-un" e ti serve il polimorfismo. Usa la composizione quando vuoi riutilizzare un comportamento senza un accoppiamento stretto, oppure quando un oggetto ha bisogno di capacità provenienti da più fonti.

Sfida

Facile

Costruiamo un sistema informatico usando la composizione! Invece di cercare di far ereditare a un computer le sue parti, creerai classi separate per i componenti e li comporrai insieme: perché un computer ha una CPU e ha memoria, non è una CPU o una memoria.

Organizzerai il tuo codice in tre file:

components.dart: crea due classi di componenti che rappresentano le parti del computer:
- Una classe CPU con un String brand e un double speedGHz. Includi un metodo process() che restituisce una stringa: [brand] processing at [speedGHz]GHz
- Una classe Memory con un int sizeGB. Includi un metodo load() che restituisce una stringa: Loading [sizeGB]GB of data
computer.dart: crea una classe Computer che usa la composizione per combinare i componenti. Il tuo computer dovrebbe:
- Avere un campo String name
- Contenere un'istanza di CPU e un'istanza di Memory (composizione: il computer HA queste parti)
- Accettare tutti i valori necessari tramite il suo costruttore per creare internamente entrambi i componenti
- Avere un metodo boot() che delega a entrambi i componenti e stampa tre righe: il nome del computer seguito da starting..., poi il risultato del metodo process della CPU, infine il risultato del metodo load della Memory
- Avere un metodo specs() che restituisce una stringa che descrive il sistema: [name]: [brand] [speedGHz]GHz, [sizeGB]GB RAM
main.dart: importa i tuoi file e mostra la composizione in azione:
- Crea un Computer chiamato Workstation con una CPU Intel che funziona a 3.5 GHz e 16 GB di memoria
- Chiama il metodo boot()
- Stampa il risultato di specs()

Nota come la classe Computer non estende CPU o Memory: li contiene e delega loro il lavoro. Questa è la relazione "ha-un" creata dalla composizione!

Risultato atteso:

Workstation starting...
Intel processing at 3.5GHz
Loading 16GB of data
Workstation: Intel 3.5GHz, 16GB RAM

Provalo tu

import 'computer.dart';

void main() {
  // TODO: Crea un Computer chiamato "Workstation" con:
  // - una CPU Intel che funziona a 3.5 GHz
  // - 16 GB di memoria

  // TODO: Chiama il metodo boot()

  // TODO: Stampa il risultato di specs()
}