Was bedeutet der Modifikator abstract?

abstract bei Methoden

Eine abstrakte Methode enthält keinen Methodenblock, somit also keine Implementierung. Die Deklaration einer abstrakten Methode besteht neben einem beliebigen Zugriffsmodifikator (public, protected, private oder keinem für package-default) aus dem Schlüsselwort abstract, dem Rückgabetyp und der Methodensignatur (Bezeichner + Parameterliste). Die Deklaration muss mit einem Semikolon abgeschlossen werden:

abstract void tuWas(int i);

Um die Methode nutzen zu können, muss die abstrakte Klasse, in der sie deklariert wurde, erweitert werden. Dort kann die abstrakte Methode dann überschrieben und entsprechend implementiert werden. Eine abstrakte Methode kann nur in einer ebenfalls als abstract deklarierten Klasse oder einem Interface¹ stehen.

abstract bei Klassen

Abstrakte Klassen sind solche, die durch das Schlüsselwort abstract gekennzeichnet sind. Von abstrakten Klassen können direkt keine Objekte gebildet werden. Sie müssen erst durch eine abgeleitete Klasse erweitert werden. Erst von dieser können dann Instanzen erzeugt werden.
Abstrakte Klassen können abstrakte und/oder nicht abstrakte Methoden enthalten. Wird die Klasse durch eine nicht abstrakte erweitert, so müssen alle ebenfalls abstrakten Methoden der Elternklasse in der Kindklasse implementiert werden. Im anderen Fall muss auch die Kindklasse abstract deklariert werden.
Felder können in abstrakten Klassen public, protected, private, static und final deklariert werden.

public class AbstractBsp {
    public static void main(String[] args) {
        Moped horex = new Moped();
        horex.beschleunigen();
        horex.fahren();
        horex.verzoegern(20);
        horex.fahren();
    }
}

abstract class Fahrzeug {
    int tempo = 0;
    
    abstract void beschleunigen();
    
    void verzoegern(int weniger) {
        tempo -= weniger;
        if (tempo < 0) tempo = 0;
    }

    void fahren() {
        System.out.println(getClass().getSimpleName() + " faehrt: " + tempo);
    }
}

class Moped extends Fahrzeug {
    void beschleunigen() {
        tempo += 50;
    }
}

class PKW extends Fahrzeug {
    void beschleunigen() {
        tempo += 30;
    }
}
				

Vergleich von abstrakten Klassen und Interfaces

Interfaces und abstrakte Klassen besitzen ähnliche Grundfunktionalitäten: Sie stellen das Gerüst von Eigenschaften und Methoden eines Typs bereit, ohne dass von ihnen konkrete Objekte abgeleitet werden können oder sollten. Dies kann z.B. der Fall sein, wenn ein Typ lediglich einen Oberbegriff repräsentiert.
Ein Beispiel: Kein Fahrzeug ist nur Fahrzeug, sondern immer genauer spezifiziert, etwa als Wakeboard, Tanklastzug, Rollschuh, Segelboot oder Mondlandefähre. Jedes Fahrzeug kann jedoch beschleunigt oder verzögert werden. Diese beiden Fähigkeiten stellen also eine Grundfunktionalität dar, die jedes Fahrzeug auf jeden Fall besitzen muss.
Durch Verwendung eines Interfaces oder einer abstrakten Klasse für den Typ Fahrzeug kann somit ein Rahmen definiert werden, der die Implementierung dieser beiden Fähigkeiten bei einer davon abgeleiteten Unterklasse auf jeden Fall sicherstellt.

Die Frage, ob man nun ein Interface oder eine abstrakte Klasse verwendet, hängt von einigen Faktoren ab. So bestehen zwischen abstrakten Klassen und Interfaces erhebliche Unterschiede, die bei der Auswahl berücksichtigt werden müssen:

Neben diesen syntaktischen Faktoren spielt auch die Frage der Klassenbeziehungen eine Rolle, die gleichwohl mit den o.a. Eigenschaften korrespondieren. Oracle empfiehlt die Verwendung abstrakter Klassen...

• ...wenn Code zwischen Klassen geteilt werden soll, die eine enge Beziehung untereinander haben.
• ...wenn die Klassen viele allgemeine Methoden und/oder Felder aufweisen oder diese einen anderen Zugriff als public besitzen sollen.
• ...wenn Felder nicht static oder final deklariert werden sollen.

Demgegenüber sollte ein Interface verwendet werden...

• ...wenn Code von sehr unterschiedlichen Klassen implementiert werden soll, die keinen Bezug zueinander haben.
• ...wenn ein Typ spezifiziert werden soll, bei dem nicht klar ist, wer zukünftig dessen Verhalten implementieren wird.
• ...wenn eine Ableitung von mehreren Typen notwendig ist.

1) Methodendeklarationen in Interfaces sind immer abstract. Die Verwendung des Schlüsselworts ist deshalb überflüssig und unüblich.