Classi astratte in Java: la parola chiave abstract spiegata

Cos'è una classe astratta

Un'interfaccia dichiara un comportamento senza stato. Una classe normale è completamente implementata e si può istanziare. Una classe astratta sta a metà strada: può avere campi, costruttori e metodi completi come una classe normale, ma può anche lasciare alcuni metodi non implementati e non può essere istanziata direttamente. La contrassegni con la parola chiave abstract.

L'idea è raccogliere in un unico punto tutto ciò che le sottoclassi hanno in comune, obbligando ogni sottoclasse a completare le parti che cambiano davvero.

abstract class Animal {
    private final String name;

    Animal(String name) { this.name = name; }   // costruttore condiviso

    String getName() { return name; }            // metodo condiviso e completo

    abstract String sound();                     // senza corpo: decide ogni sottoclasse
}

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 definisce getName() una sola volta per tutte le sottoclassi e dichiara sound() come abstract: un metodo con una firma ma senza corpo, che Dog deve fornire.

Non puoi istanziare una classe astratta

Dato che una classe astratta può avere metodi incompleti, crearne una direttamente ti lascerebbe con un oggetto incompleto. Il compilatore lo rifiuta:

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

Istanzi sempre una sottoclasse concreta, cioè una che ha implementato ogni metodo astratto. L'istanza di quella sottoclasse può poi essere memorizzata in una variabile del tipo astratto, ed è proprio così che si usa l'astrazione.

I metodi astratti obbligano le sottoclassi a decidere

Un metodo abstract è una promessa che la sottoclasse deve mantenere. Se una sottoclasse si dimentica di implementarne uno, diventa essa stessa astratta e il compilatore te lo segnala. È questa la leva principale della classe astratta: garantisce che un certo comportamento esista senza imporre cosa faccia.

abstract class Shape {
    abstract double area();                       // ogni figura deve definirlo

    void describe() {                             // condiviso, scritto una volta
        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();                         // chiama in automatico l'area() giusta
        }
    }
}

describe() è scritto una sola volta in Shape, eppure chiama l'area() di ciascuna sottoclasse. La classe astratta fornisce l'impalcatura comune; le sottoclassi forniscono i dettagli.

Stato condiviso e costruttori

A differenza di un'interfaccia tradizionale, una classe astratta può contenere campi di istanza e definire dei costruttori. Il costruttore non crea mai un Animal o una Shape da solo: viene eseguito tramite super(...) quando si crea una sottoclasse, e inizializza lo stato condiviso.

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();               // cambia per tipo di conto

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

Il campo balance, deposit e applyInterest stanno in un unico punto. Solo la regola che cambia davvero, interestRate(), resta astratta. Il costruttore di una sottoclasse deve chiamare super(...) per inizializzare lo stato ereditato.

Una trappola: abstract insieme a final

abstract e final sono opposti. Un metodo abstract richiede un override; un metodo final lo vieta. Marcare la stessa cosa in entrambi i modi, o creare una classe astratta final, è un errore di compilazione. Ricorda anche che una classe astratta può avere zero metodi astratti: dichiarare una classe abstract solo per impedirne l'istanziazione è lecito, e a volte utile per tipi base che vuoi soltanto estendere.

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 astratta o interfaccia

Le due cose si sovrappongono, quindi la scelta dipende da cosa devi condividere:

• Classe astratta: usala per classi strettamente collegate che condividono stato e codice. Savings e Checking estendono entrambe Account, ereditando il campo balance e la logica di deposit. Una classe ne estende solo una.
• Interfaccia: usala per una capacità che classi non collegate possono condividere. Un Bird e un Airplane possono essere entrambi Flyable senza condividere alcuna implementazione. Una classe può implementarne molte.

Uno schema frequente le combina: un'interfaccia definisce il contratto e una classe astratta implementa il codice ripetitivo, così le sottoclassi concrete completano solo ciò che le rende uniche.

Prossimo passo: il polimorfismo

Nota che in ogni esempio qui sopra abbiamo memorizzato un'istanza di una sottoclasse in una variabile del tipo astratto, poi abbiamo chiamato un metodo ottenendo in automatico il comportamento della sottoclasse. Questa capacità, un solo tipo di riferimento con molti comportamenti a runtime, si chiama polimorfismo, ed è ciò che rende davvero utili classi astratte e interfacce. È l'argomento della prossima pagina.