Composição vs Herança

Parte da seção Programação Orientada a Objetos do Journey de Dart da Coddy — lição 82 de 110.

Você aprendeu que a herança cria uma relação "é-um" - um Dog é um Animal. Mas existe outra abordagem poderosa: composição, que cria uma relação "tem-um". Em vez de herdar comportamento, uma classe contém instâncias de outras classes e delega o trabalho a elas.

Considere uma classe Car. Com herança, você pode tentar estender uma classe Engine - mas um carro não é um motor, ele tem um motor:

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

class Car {
  final Engine _engine = Engine();  // Composição: Car TEM um Engine
  
  void start() {
    _engine.start();  // Delega para o engine
    print('Car is ready to drive');
  }
}

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

A principal vantagem da composição é a flexibilidade. Com a herança, você fica preso a uma única classe pai. Com a composição, você pode combinar múltiplos componentes e até mesmo trocá-los em tempo de execução:

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();
    }
  }
}

Uma diretriz comum é "favoreça a composição em vez da herança". Use a herança quando houver um verdadeiro relacionamento "é-um" e você precisar de polimorfismo. Use a composição quando quiser reutilizar o comportamento sem acoplamento rígido, ou quando um objeto precisar de recursos de múltiplas fontes.

Desafio

Fácil

Vamos construir um sistema de computador usando composição! Em vez de tentar fazer um computador herdar de suas partes, você criará classes de componentes separadas e as comporá - porque um computador tem uma CPU e tem memória, ele não é uma CPU ou memória.

Você organizará seu código em três arquivos:

components.dart: Crie duas classes de componentes que representam partes do computador:
- Uma classe CPU com um String brand e double speedGHz. Inclua um método process() que retorna uma string: '$brand processing at ${speedGHz}GHz'
- Uma classe Memory com um int sizeGB. Inclua um método load() que retorna uma string: 'Loading ${sizeGB}GB of data'
computer.dart: Crie uma classe Computer que usa composição para combinar os componentes. Seu computador deve:
- Ter um campo String name
- Conter uma instância de CPU e uma de Memory (composição - o computador TEM essas partes)
- Aceitar todos os valores necessários através de seu construtor para criar ambos os componentes internamente
- Ter um método boot() que delega para ambos os componentes e imprime três linhas: o nome do computador seguido por starting..., depois o resultado do método process da CPU, e então o resultado do método load da Memória
- Ter um método specs() que retorna uma string descrevendo o sistema: '$name: ${cpu.brand} ${cpu.speedGHz}GHz, ${memory.sizeGB}GB RAM'
main.dart: Importe seus arquivos e demonstre a composição em ação:
- Crie um Computer chamado 'Workstation' com uma CPU 'Intel' rodando a 3.5 GHz e 16 GB de memória
- Chame o método boot()
- Imprima o resultado de specs()

Observe como a classe Computer não estende CPU ou Memory - ela os contém e delega o trabalho a eles. Este é o relacionamento "tem-um" (has-a) que a composição cria!

Saída esperada:

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

Folha de consulta

A composição cria um relacionamento do tipo "tem um" (has-a), onde uma classe contém instâncias de outras classes e delega o trabalho a elas, em vez de herdar delas.

Exemplo básico de composição:

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

class Car {
  final Engine _engine = Engine();  // Car HAS an Engine
  
  void start() {
    _engine.start();  // Delegate to the engine
    print('Car is ready to drive');
  }
}

Composição com flexibilidade - trocando componentes:

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();
    }
  }
}

Quando usar composição vs herança:

Use herança para relacionamentos verdadeiros do tipo "é um" (is-a) quando você precisar de polimorfismo
Use composição para reutilizar comportamento sem acoplamento rígido, ou quando um objeto precisa de capacidades de múltiplas fontes
Diretriz geral: "prefira a composição à herança"

Experimente você mesmo

import 'computer.dart';

void main() {
  // TODO: Crie um Computer chamado "Workstation" com:
  // - Intel CPU rodando a 3.5 GHz
  // - 16 GB de memória

  // TODO: Chame o método boot()

  // TODO: Imprima o resultado de specs()
}