Classes abstratas em Java: a palavra-chave abstract explicada

O que é uma classe abstrata

Uma interface declara comportamento sem estado. Uma classe comum é totalmente implementada e pode ser instanciada. Uma classe abstrata fica entre as duas: pode carregar campos, construtores e métodos concluídos como uma classe normal, mas também pode deixar alguns métodos sem implementação e proíbe ser instanciada diretamente. Você a marca com a palavra-chave abstract.

A ideia é reunir em um só lugar tudo o que as subclasses têm em comum, ao mesmo tempo em que obriga cada subclasse a preencher as partes que realmente diferem.

abstract class Animal {
    private final String name;

    Animal(String name) { this.name = name; }   // construtor compartilhado

    String getName() { return name; }            // método compartilhado e concluído

    abstract String sound();                     // sem corpo - cada subclasse decide
}

class Dog extends Animal {
    Dog(String name) { super(name); }
    String sound() { return "Woof"; }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog("Rex");
        System.out.println(a.getName() + " says " + a.sound());
    }
}

Animal define getName() uma única vez para todas as subclasses e declara sound() como abstract - um método com assinatura, mas sem corpo, que Dog deve fornecer.

Você não pode instanciar uma classe abstrata

Como uma classe abstrata pode ter métodos não concluídos, criá-la diretamente deixaria você com um objeto incompleto. O compilador rejeita isso:

Animal a = new Animal("???");   // error: Animal is abstract; cannot be instantiated

Você sempre instancia uma subclasse concreta - uma que tenha implementado todos os métodos abstratos. Essa instância da subclasse pode então ser mantida em uma variável do tipo abstrato, que é exatamente como você usa a abstração.

Métodos abstratos obrigam as subclasses a decidir

Um método abstract é uma promessa que a subclasse precisa cumprir. Se uma subclasse esquecer de implementar um deles, a própria subclasse se torna abstrata e o compilador avisa você. Essa é a principal alavanca da classe abstrata: ela garante que certo comportamento existe sem ditar o que ele faz.

abstract class Shape {
    abstract double area();                       // toda figura deve definir isto

    void describe() {                             // compartilhado, escrito uma só vez
        System.out.printf("%s with area %.2f%n",
            getClass().getSimpleName(), area());
    }
}

class Circle extends Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    double area() { return Math.PI * r * r; }
}

class Square extends Shape {
    private final double side;
    Square(double side) { this.side = side; }
    double area() { return side * side; }
}

public class Main {
    public static void main(String[] args) {
        Shape[] shapes = { new Circle(2), new Square(3) };
        for (Shape s : shapes) {
            s.describe();                         // chama o area() certo automaticamente
        }
    }
}

describe() é escrito uma única vez em Shape e, ainda assim, chama o area() próprio de cada subclasse. A classe abstrata fornece a estrutura comum; as subclasses fornecem os detalhes.

Estado compartilhado e construtores

Diferentemente de uma interface tradicional, uma classe abstrata pode ter campos de instância e definir construtores. O construtor nunca cria um Animal ou um Shape sozinho - ele é executado via super(...) quando uma subclasse é criada, inicializando o estado compartilhado.

abstract class Account {
    private double balance;

    Account(double opening) { this.balance = opening; }

    double getBalance() { return balance; }

    void deposit(double amount) { balance += amount; }

    abstract double interestRate();               // varia conforme o tipo de conta

    void applyInterest() { balance += balance * interestRate(); }
}

class Savings extends Account {
    Savings(double opening) { super(opening); }
    double interestRate() { return 0.05; }
}

public class Main {
    public static void main(String[] args) {
        Account acc = new Savings(1000);
        acc.deposit(500);
        acc.applyInterest();
        System.out.printf("balance: %.2f%n", acc.getBalance());
    }
}

O campo balance, deposit e applyInterest ficam em um único lugar. Apenas a política que de fato varia - interestRate() - é deixada abstrata. O construtor de uma subclasse deve chamar super(...) para inicializar esse estado herdado.

Uma pegadinha: misturar abstract e final

abstract e final são opostos. Um método abstract exige uma sobrescrita; um método final a proíbe. Marcar a mesma coisa das duas formas - ou tornar uma classe abstrata final - é um erro de compilação. Lembre-se também de que uma classe abstrata pode ter zero métodos abstratos: declarar uma classe abstract apenas para impedir que ela seja instanciada é legal e às vezes útil para tipos base que você só quer estender.

abstract final class Bad { }        // error: abstract and final conflict

abstract class Base {
    abstract final void f();        // error: an abstract method can't be final
}

Classe abstrata versus interface

Elas se sobrepõem, então a escolha depende do que você precisa compartilhar:

• Classe abstrata - use-a para classes fortemente relacionadas que compartilham estado e código. Tanto Savings quanto Checking estendem Account, herdando o campo balance e a lógica de deposit. Uma classe estende apenas uma.
• Interface - use-a para uma capacidade que classes não relacionadas podem compartilhar. Um Bird e um Airplane podem ambos ser Flyable sem compartilhar nenhuma implementação. Uma classe pode implementar várias.

Um padrão frequente combina as duas: uma interface define o contrato e uma classe abstrata implementa o código repetitivo para que as subclasses concretas preencham somente o que é único.

A seguir: Polimorfismo

Repare que em todos os exemplos acima guardamos uma instância de subclasse em uma variável do tipo abstrato e, ao chamar um método, obtivemos automaticamente o comportamento da subclasse. Essa única capacidade - um tipo de referência, muitos comportamentos em tempo de execução - é o polimorfismo, e é o que faz as classes abstratas e as interfaces valerem a pena. Esse é o tema da próxima página.