Fundamentos do polimorfismo

Parte da seção Programação Orientada a Objetos do Journey de Dart da Coddy. Lição 57 de 110.

Polimorfismo significa "muitas formas" - é a capacidade de tratar objetos de diferentes classes por meio de uma interface comum. Quando você tem uma referência de classe pai, ela pode apontar para qualquer objeto de classe filha, e o método correto é chamado com base no tipo real do objeto.

Isso é poderoso porque você pode escrever código que funciona com o tipo pai, mas ele lida automaticamente com todos os tipos filhos corretamente:

class Animal {
  void speak() => print('Some sound');
}

class Dog extends Animal {
  @override
  void speak() => print('Woof!');
}

class Cat extends Animal {
  @override
  void speak() => print('Meow!');
}

void main() {
  Animal myPet = Dog();  // Tipo pai, objeto filho
  myPet.speak();  // Saída: Woof!
  
  myPet = Cat();  // Mesma variável, objeto diferente
  myPet.speak();  // Saída: Meow!
}

A variável myPet é declarada como Animal, mas ela contém um Dog ou Cat. Quando speak() é chamado, o Dart verifica o tipo real do objeto em tempo de execução e chama o método sobrescrito apropriado.

Isso permite que você escreva funções flexíveis que funcionam com qualquer subclasse:

void makeAllSpeak(List<Animal> animals) {
  for (var animal in animals) {
    animal.speak();  // Cada animal fala à sua maneira
  }
}

void main() {
  var pets = [Dog(), Cat(), Dog()];
  makeAllSpeak(pets);
  // Saída: Woof! Meow! Woof!
}

A função não precisa saber sobre Dog ou Cat - ela apenas funciona com Animal. Isso torna seu código mais extensível, já que adicionar novos tipos de animais não requer alterações nas funções existentes.

Desafio

Fácil

Vamos construir um sistema de instrumentos musicais que demonstra o polimorfismo em ação. Você criará uma classe base Instrument e vários tipos de instrumentos, depois escreverá uma função que pode fazer qualquer coleção de instrumentos tocar junto - sem conhecer seus tipos específicos.

Você organizará seu código em dois arquivos:

instruments.dart: Defina sua hierarquia de instrumentos aqui:
- Uma classe Instrument com uma propriedade String name e um construtor. Inclua um método play() que imprime '$name makes a sound'
- Uma classe Guitar que estende Instrument e sobrescreve play() para imprimir '$name strums melodically'
- Uma classe Drum que estende Instrument e sobrescreve play() para imprimir '$name beats rhythmically'
- Uma classe Piano que estende Instrument e sobrescreve play() para imprimir '$name plays harmoniously'
Também crie uma função performConcert(List<Instrument> instruments) que imprime 'Concert begins!', depois itera pela lista chamando play() em cada instrumento, e finalmente imprime 'Concert ends!'
main.dart: Importe seu arquivo de instrumentos e demonstre o polimorfismo criando uma banda mista:
- Crie uma lista do tipo List<Instrument> contendo um Guitar chamado 'Acoustic', um Drum chamado 'Snare', e um Piano chamado 'Grand'
- Passe esta lista para performConcert()

Observe como performConcert() funciona com o tipo pai Instrument, mas cada instrumento toca de sua própria maneira única. Isso é polimorfismo - a mesma chamada de método produz comportamentos diferentes com base no tipo real do objeto.

Saída esperada:

Concert begins!
Acoustic strums melodically
Snare beats rhythmically
Grand plays harmoniously
Concert ends!

Experimente você mesmo

import 'instruments.dart';

void main() {
  // TODO: Criar uma List<Instrument> contendo:
  // - Um Guitar chamado 'Acoustic'
  // - Um Drum chamado 'Snare'
  // - Um Piano chamado 'Grand'
  
  
  // TODO: Chamar performConcert() com sua lista de instrumentos
  
}