Was bedeutet der Modifikator abstract?

Abstrakte Klassen und Methoden sind solche, die nicht oder nur teilweise implementiert sind. Die Implementierung findet in abgeleiteten Typen und überschriebenen Methoden statt.

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 Interface1 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:

  Interface abstrakte Klasse
Ableitung Eine Klasse kann eine beliebige Anzahl an Interfaces implementieren. Eine Klasse kann nur von einer Elternklasse erben.
Methoden ohne Implementierung mit oder ohne Implementierung
Zugriff auf abstrakte Methoden immer public public
protected
Zugriff auf konkrete Methoden - public
protected
private
Feld-Zugriff immer public static final public
protected
private

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...

Demgegenüber sollte ein Interface verwendet werden...

Quellen

http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html

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