Abstrakte Klassen in Java: das Schlüsselwort abstract erklärt

Was eine abstrakte Klasse ist

Ein Interface deklariert Verhalten ohne Zustand. Eine gewöhnliche Klasse ist vollständig implementiert und lässt sich instanziieren. Eine abstrakte Klasse steht zwischen beiden: Sie kann wie eine normale Klasse Felder, Konstruktoren und fertige Methoden tragen, kann aber auch einige Methoden unimplementiert lassen und verbietet die direkte Instanziierung. Du markierst sie mit dem Schlüsselwort abstract.

Die Idee besteht darin, alles, was Unterklassen gemeinsam haben, an einer Stelle zu bündeln und zugleich jede Unterklasse zu zwingen, die Teile auszufüllen, die sich wirklich unterscheiden.

abstract class Animal {
    private final String name;

    Animal(String name) { this.name = name; }   // gemeinsamer Konstruktor

    String getName() { return name; }            // gemeinsame, fertige Methode

    abstract String sound();                     // kein Rumpf - jede Unterklasse entscheidet
}

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 definiert getName() einmalig für jede Unterklasse und deklariert sound() als abstract - eine Methode mit Signatur, aber ohne Rumpf, die Dog liefern muss.

Du kannst eine abstrakte Klasse nicht instanziieren

Da eine abstrakte Klasse unfertige Methoden haben kann, würdest du beim direkten Erzeugen ein unvollständiges Objekt erhalten. Der Compiler lehnt das ab:

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

Du instanziierst immer eine konkrete Unterklasse - eine, die jede abstrakte Methode implementiert hat. Diese Instanz der Unterklasse kann dann in einer Variablen des abstrakten Typs gehalten werden, und genau so nutzt man die Abstraktion.

Abstrakte Methoden zwingen Unterklassen zur Entscheidung

Eine abstract-Methode ist ein Versprechen, das die Unterklasse einhalten muss. Vergisst eine Unterklasse, eine davon zu implementieren, wird die Unterklasse selbst abstrakt und der Compiler weist dich darauf hin. Das ist der wichtigste Hebel der abstrakten Klasse: Sie garantiert, dass bestimmtes Verhalten existiert, ohne vorzuschreiben, was es tut.

abstract class Shape {
    abstract double area();                       // jede Form muss dies definieren

    void describe() {                             // gemeinsam, einmal geschrieben
        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();                         // ruft automatisch das richtige area() auf
        }
    }
}

describe() wird nur einmal in Shape geschrieben und ruft dennoch das eigene area() jeder Unterklasse auf. Die abstrakte Klasse liefert das gemeinsame Gerüst; die Unterklassen liefern die Details.

Gemeinsamer Zustand und Konstruktoren

Anders als ein traditionelles Interface kann eine abstrakte Klasse Instanzfelder halten und Konstruktoren definieren. Der Konstruktor erzeugt nie für sich allein ein Animal oder Shape - er läuft über super(...), wenn eine Unterklasse erzeugt wird, und initialisiert dabei den gemeinsamen Zustand.

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();               // unterscheidet sich je Kontotyp

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

Das Feld balance, deposit und applyInterest leben an einer einzigen Stelle. Nur die Regel, die tatsächlich variiert - interestRate() -, bleibt abstrakt. Der Konstruktor einer Unterklasse muss super(...) aufrufen, um diesen geerbten Zustand zu initialisieren.

Eine Falle: abstract und final mischen

abstract und final sind Gegensätze. Eine abstract-Methode verlangt eine Überschreibung; eine final-Methode verbietet sie. Dieselbe Sache auf beide Weisen zu markieren - oder eine abstrakte Klasse final zu machen - ist ein Kompilierfehler. Bedenke außerdem, dass eine abstrakte Klasse null abstrakte Methoden haben kann: eine Klasse nur deshalb als abstract zu deklarieren, um ihre Instanziierung zu verhindern, ist erlaubt und manchmal nützlich für Basistypen, die du nur erweitern möchtest.

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

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

Abstrakte Klasse versus Interface

Sie überschneiden sich, daher hängt die Wahl davon ab, was du teilen musst:

• Abstrakte Klasse - verwende sie für eng verwandte Klassen, die Zustand und Code teilen. Sowohl Savings als auch Checking erweitern Account und erben das Feld balance sowie die deposit-Logik. Eine Klasse erweitert nur eine einzige.
• Interface - verwende es für eine Fähigkeit, die nicht verwandte Klassen teilen können. Ein Bird und ein Airplane können beide Flyable sein, ohne irgendeine Implementierung zu teilen. Eine Klasse kann mehrere implementieren.

Ein häufiges Muster kombiniert beides: Ein Interface definiert den Vertrag, und eine abstrakte Klasse implementiert den Boilerplate-Code, sodass konkrete Unterklassen nur das ausfüllen, was einzigartig ist.

Als Nächstes: Polymorphie

Beachte, dass wir in jedem obigen Beispiel eine Instanz der Unterklasse in einer Variablen des abstrakten Typs gehalten, dann eine Methode aufgerufen und automatisch das Verhalten der Unterklasse erhalten haben. Genau diese eine Fähigkeit - ein Referenztyp, viele Laufzeitverhalten - ist die Polymorphie, und sie ist es, die abstrakte Klassen und Interfaces auszahlen lässt. Das ist das Thema der nächsten Seite.