Abstrakte Klasse

Eine abstrakte Klasse ist eine besondere Art von Klasse.

Manche Klassen möchte man nicht direkt instanziieren können, sondern nur ihre Kinder. Dann kann man diese Klasse als abstrakt deklarieren.

Von abstrakten Klassen können nicht direkt Objekte erzeugt werden. Wenn man das möchte, muss man eine Unterklasse implementieren, die von der abstrakten Klasse erbt. Abstrakte Klassen dürfen neben normalen Methoden, die regulär vererbt werden, auch abstrakte Methoden enthalten, deren Methodenrumpf leer ist und deren Verhalten für jede Kind-Klasse einzeln definiert werden muss. Durch die Vererbung der Methoden bzw. wenigstens der Methoden-Schnittstellen kann mit einer abstrakten Klasse sichergestellt werden, dass alle ihrer Kind-Klassen ein vorhersehbares Verhalten aufweisen.

In UML-Klassendiagrammen werden abstrakte Klassen und Methoden durch kursive Schrift hervorgehoben.

Ein fiktives Beispiel

Der rechts dargestellte Quelltext als UML-Klassendiagramm

public abstract class Animal {
    
    // abstrakte Methode makeNoise -- jede Tierart macht ihr eigenes Geräusch
    public abstract void makeNoise();

    // Methode eat -- muss nicht von erbenden Klassen überschrieben werden.
    public void eat() {
        System.out.println("nom nom");
    }

}

public class Dog extends Animal {

    public void makeNoise() {
        System.out.println("woof!");
    }

}

public class Cat extends Animal {

    public void makeNoise() {
        System.out.println("meow!");
    }

    public void eat() {
        super.eat(); // ruft die eat()-Methode der Oberklasse auf
        wait();
        vomitAllOVerTheCarpet();
    }

}

In diesem Beispiel können keine Animal-Objekte mit dem Aufruf new Animal() erzeugt werden. Animal legt aber fest, dass alle Unterklassen wie Dog und Cat eine Methode namens makeNoise() enthalten müssen. Darauf aufbauend kann man nun z.B. eine Liste von Tieren anlegen:

public static void main(String[] args) {

    Cat felix = new Cat();
    Cat luna = new Cat();
    Dog milow = new Dog();
    Dog fiete = new Dog();

    ArrayList<Animal> zoo = new ArrayList<Animal>();
    zoo.add(felix);
    zoo.add(luna);
    zoo.add(milow);
    zoo.add(fiete);

    for(Animal a : zoo) {
        a.makeNoise();
    }
}

Zur ArrayList zoo dürfen nur Objekte hinzugefügt werden, die der Klasse Animal oder einer ihrer Unterklassen angehören. Die for-Wiederholung am Ende des Codeschnipsels erzeugt dann die folgende Ausgabe:

meow!
meow!
woof!
woof!

Dadurch, dass die ArrayList auf Animals beschränkt ist und dass alle Animals und ihre Unterklassen eine makeNoise()-Methode enthalten müssen, kann schon beim Programmieren sichergestellt werden, dass die for-Wiederholung problemlos durchlaufen wird.

Ein echtes Beispiel

Die abstrakte Java-Klasse JComponent ist eine Oberklasse für alle sichtbaren Komponenten eines Programms wie Buttons, Slider, Fortschrittsbalken usw. Die abstrakte Oberklasse stellt sicher, dass alle Unterklassen Methoden wie setFont() oder setVisible() enthalten und sich alle vorhersehbar verhalten. Durch generische Programmierung können auch mehrere JComponents z.B. zu einer ArrayList hinzugefügt werden und durch Iterieren über diese Liste alle nacheinander sichtbar oder unsichtbar geschaltet werden.

Zum Weiterlesen

• Abstract Class im Java Tutorial 🇬🇧

Objektorientierte Modellierung

Klasse | Objekt | Attribut

Abstrakte Klasse | Interface | Datenkapselung | Vererbung | Polymorphie