Métodos Abstratos

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

Um método abstrato é um método declarado dentro de uma classe abstrata que não possui corpo. Ele define a assinatura do método, mas deixa a implementação para cada subclasse. Qualquer classe que estenda a classe abstrata deve sobrescrever todos os métodos abstratos, ou ela também será abstrata.

abstract class Animal {
  // Método abstrato - sem corpo, deve ser implementado pelas subclasses
  String makeSound();

  // Método concreto - possui um corpo, compartilhado por todas as subclasses
  void breathe() {
    print('Breathing...');
  }
}

class Dog extends Animal {
  @override
  String makeSound() {
    return 'Woof!';  // Deve fornecer a implementação
  }
}

class Cat extends Animal {
  @override
  String makeSound() {
    return 'Meow!';  // Implementação diferente, mesma assinatura
  }
}

Se uma subclasse esquecer de implementar um método abstrato, o Dart fornecerá um erro de compilação. Este é o ponto principal - métodos abstratos impõem um contrato. Cada subclasse tem a garantia de possuir esse método, para que você possa chamá-lo com segurança em qualquer instância do tipo abstrato.

// Você pode usar o tipo abstrato como um tipo de variável
Animal a = Dog();
print(a.makeSound());  // Woof!

Animal b = Cat();
print(b.makeSound());  // Meow!

Métodos abstratos são diferentes de métodos concretos em uma classe abstrata. Métodos concretos possuem um corpo e são herdados como estão. Métodos abstratos não possuem corpo e devem ser sobrescritos.

Você pode misturar ambos na mesma classe abstrata para compartilhar algum comportamento, enquanto força as subclasses a definirem o seu próprio para outros.

Recurso	Método Abstrato	Método Concreto
Possui corpo	Não	Sim
Deve sobrescrever	Sim	Não
Propósito	Impor contrato	Compartilhar comportamento
Onde	Apenas classe abstrata	Qualquer classe

Desafio

Fácil

Vamos construir uma calculadora de formas que demonstra métodos abstratos em ação. Você definirá uma classe abstrata com métodos abstratos que cada forma deve implementar de maneira diferente e, em seguida, usará essas formas por meio de uma interface comum.

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

shape.dart: Defina uma classe abstrata Shape com um campo final color (String) e um construtor que o inicializa. Declare dois métodos abstratos: double area() e double perimeter(). Adicione também um método concreto describe() que imprime A [color] shape with area: [area] and perimeter: [perimeter]. Como area() e perimeter() são abstratos, cada subclasse fornecerá seu próprio cálculo, mas describe() funciona para todas elas sem ser sobrescrito.
circle.dart: Crie uma classe Circle que estende Shape. Ela possui um campo final radius (double). Seu construtor recebe color e radius e passa color para o super. Implemente area() para retornar 3.14 * radius * radius e perimeter() para retornar 2 * 3.14 * radius.
rectangle.dart: Crie uma classe Rectangle que estende Shape. Ela possui campos final width e height (ambos double). Seu construtor recebe color, width e height e passa color para o super. Implemente area() para retornar width * height e perimeter() para retornar 2 * (width + height).
main.dart: Importe todos os arquivos. Crie um Circle com a cor 'red' e raio 5.0, e um Rectangle com a cor 'blue', largura 4.0 e altura 6.0. Chame describe() em cada forma. Em seguida, crie uma List<Shape> contendo ambas as formas, percorra a lista e imprima Area: [area] para cada forma.

Saída esperada:

A red shape with area: 78.5 and perimeter: 31.400000000000002
A blue shape with area: 24.0 and perimeter: 20.0
Area: 78.5
Area: 24.0

Folha de consulta

Um método abstrato é um método declarado em uma classe abstrata sem um corpo. As subclasses devem sobrescrevê-lo para fornecer sua própria implementação.

abstract class Animal {
  // Método abstrato - sem corpo
  String makeSound();

  // Método concreto - possui um corpo
  void breathe() {
    print('Breathing...');
  }
}

As subclasses devem implementar todos os métodos abstratos:

class Dog extends Animal {
  @override
  String makeSound() {
    return 'Woof!';
  }
}

class Cat extends Animal {
  @override
  String makeSound() {
    return 'Meow!';
  }
}

Você pode usar o tipo abstrato como um tipo de variável:

Animal a = Dog();
print(a.makeSound());  // Woof!

Animal b = Cat();
print(b.makeSound());  // Meow!

Característica	Método Abstrato	Método Concreto
Possui corpo	Não	Sim
Deve sobrescrever	Sim	Não
Propósito	Impor contrato	Compartilhar comportamento
Onde	Apenas classe abstrata	Qualquer classe

Experimente você mesmo

import 'shape.dart';
import 'circle.dart';
import 'rectangle.dart';

void main() {
  // TODO: Crie um Circle com a cor 'red' e raio 5.0

  // TODO: Crie um Rectangle com a cor 'blue', largura 4.0 e altura 6.0

  // TODO: Chame describe() no circle

  // TODO: Chame describe() no rectangle

  // TODO: Crie uma List<Shape> contendo ambas as formas

  // TODO: Percorra a lista e imprima "Area: [area]" para cada forma
}