Composición vs. Herencia

Parte de la sección Programación Orientada a Objetos del Journey de Dart de Coddy. Lección 82 de 110.

Has aprendido que la herencia crea una relación de «es-un»: un Dog es un Animal. Pero existe otro enfoque potente: la composición, que crea una relación de «tiene-un». En lugar de heredar comportamiento, una clase contiene instancias de otras clases y les delega el trabajo.

Considera una clase Car. Con la herencia, podrías intentar extender una clase Engine, pero un coche no es un motor, tiene un motor:

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

class Car {
  final Engine _engine = Engine();  // Composición: Car TIENE un Engine
  
  void start() {
    _engine.start();  // Delega al motor
    print('Car is ready to drive');
  }
}

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

La principal ventaja de la composición es la flexibilidad. Con la herencia, estás limitado a una sola clase padre. Con la composición, puedes combinar varios componentes e incluso intercambiarlos durante la ejecución:

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 directriz habitual es «favorece la composición sobre la herencia». Usa la herencia cuando exista una verdadera relación «es-un» y necesites polimorfismo. Usa la composición cuando quieras reutilizar comportamientos sin un acoplamiento estrecho, o cuando un objeto necesite capacidades de varias fuentes.

Desafío

Fácil

¡Vamos a crear un sistema informático usando composición! En lugar de intentar hacer que un ordenador herede de sus componentes, crearás clases de componentes independientes y las combinarás, porque un ordenador tiene una CPU y tiene memoria; no es una CPU ni memoria.

Organizarás el código en tres archivos:

components.dart: Crea dos clases de componentes que representen las partes del ordenador:
- Una clase CPU con un String brand y un double speedGHz. Incluye un método process() que devuelva una cadena: [brand] processing at [speedGHz]GHz
- Una clase Memory con un int sizeGB. Incluye un método load() que devuelva una cadena: Loading [sizeGB]GB of data
computer.dart: Crea una clase Computer que use composición para combinar los componentes. Tu ordenador debe:
- Tener un campo String name
- Contener una instancia de CPU y una de Memory (composición: el ordenador TIENE estas partes)
- Aceptar todos los valores necesarios mediante su constructor para crear ambos componentes internamente
- Tener un método boot() que delegue en ambos componentes e imprima tres líneas: el nombre del ordenador seguido de starting..., después el resultado del método process de la CPU y, después, el resultado del método load de Memory
- Tener un método specs() que devuelva una cadena que describa el sistema: [name]: [brand] [speedGHz]GHz, [sizeGB]GB RAM
main.dart: Importa tus archivos y demuestra la composición en acción:
- Crea un Computer llamado Workstation con una CPU Intel que funcione a 3.5 GHz y 16 GB de memoria
- Llama al método boot()
- Imprime el resultado de specs()

Fíjate en que la clase Computer no extiende CPU ni Memory: los contiene y delega el trabajo en ellos. ¡Esta es la relación «tiene» que crea la composición!

Salida esperada:

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

Pruébalo tú mismo

import 'computer.dart';

void main() {
  // TODO: Crea un Computer llamado "Workstation" con:
  // - CPU Intel funcionando a 3.5 GHz
  // - 16 GB de memoria

  // TODO: Llama al método boot()

  // TODO: Imprime el resultado de specs()
}