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();  // Delegar para o motor
    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 é "prefira 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 capacidades de múltiplas fontes.

Desafio

Fácil

Vamos criar 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 combinará — como um computador tem uma CPU e tem memória, ele não é uma CPU nem memória.

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

components.dart: crie duas classes de componentes que representem as partes do computador:
- Uma classe CPU com uma String brand e uma double speedGHz. Inclua um método process() que retorne uma string: [brand] processing at [speedGHz]GHz
- Uma classe Memory com um int sizeGB. Inclua um método load() que retorne uma string: Loading [sizeGB]GB of data
computer.dart: crie uma classe Computer que use 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 por meio de seu construtor para criar ambos os componentes internamente
- Ter um método boot() que delegue aos dois componentes e imprima três linhas: o nome do computador seguido de starting..., depois o resultado do método process da CPU e, em seguida, o resultado do método load da Memory
- Ter um método specs() que retorne uma string descrevendo o sistema: [name]: [brand] [speedGHz]GHz, [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 operando 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 nem Memory — ela os contém e delega o trabalho a eles. Essa é a relação "tem-um" criada pela composição!

Saída esperada:

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

Experimente você mesmo

import 'computer.dart';

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

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

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