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 comportamenti, 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 è "preferire la composizione all'ereditarietà". Usa l'ereditarietà quando esiste una vera relazione "è un" e hai bisogno del polimorfismo. Usa la composizione quando vuoi riutilizzare un comportamento senza un accoppiamento stretto, oppure quando un oggetto ha bisogno di funzionalità provenienti da più fonti.

Sfida

Facile

Costruiamo un sistema informatico usando la composizione! Invece di cercare di far ereditare un computer dalle sue parti, creerai classi di componenti separate e le comporrai insieme: poiché un computer ha una CPU e ha memoria, non è una CPU né memoria.

Organizzerai il codice in tre file:

components.dart: crea due classi di componenti che rappresentano parti del computer:
- Una classe CPU con una String brand e una 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 dovrà:
- Avere un campo String name
- Contenere un'istanza di CPU e una di Memory (composizione: il computer HA queste parti)
- Accettare tutti i valori necessari tramite il costruttore per creare entrambi i componenti internamente
- Avere un metodo boot() che delega il lavoro a entrambi i componenti e stampa tre righe: il nome del computer seguito da starting..., poi il risultato del metodo process della CPU e infine il risultato del metodo load della Memory
- Avere un metodo specs() che restituisce una stringa con le specifiche del 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 che la classe Computer non estende CPU né Memory: li contiene e delega loro il lavoro. Questa è la relazione "has-a" creata dalla composizione!

Output previsto:

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 a 3.5 GHz
  // - 16 GB di memoria

  // TODO: Chiama il metodo boot()

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