Zusammenhang zwischen Polymorphismus und abstrakten Klassen

1. Abstrakte Klassen und Methoden

Manchmal möchte man im Leben (und in der Programmierung) sagen: „Nun, ich weiß nicht genau, wie das gemacht wird, aber ich weiß sicher, dass es sein muss!“ Zum Beispiel sollten alle Tiere einen Laut von sich geben können, aber welcher genau – das hängt vom konkreten Tier ab. Für solche Fälle gibt es in Java abstrakte Klassen und abstrakte Methoden.

Abstrakte Klasse – das ist eine Klasse, die nicht direkt instanziiert werden kann (man kann nicht new Animal() schreiben, wenn Animal abstrakt ist), von der man aber erben kann. Eine solche Klasse kann sowohl normale (implementierte) Methoden als auch abstrakte Methoden enthalten – also deklarierte, aber nicht implementierte.

Abstrakte Methode – das ist eine Methode ohne Rumpf. Sie wird mit dem Schlüsselwort abstract deklariert und muss in Unterklassen implementiert werden (es sei denn, die Unterklasse ist selbst abstrakt).

Beispiel aus dem Alltag

Angenommen, wir haben eine Anwendung für einen Zoo. Wir möchten, dass alle Tiere eine Methode makeSound() haben, wissen aber nicht, welchen Laut sie genau von sich geben. Dann erstellen wir eine abstrakte Klasse:

public abstract class Animal {
    public abstract void makeSound(); // Abstrakte Methode
}

Und konkrete Tiere implementieren diese Methode jeweils auf ihre Weise:

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Wau-wau!");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Miau!");
    }
}

Wenn jetzt jemand versucht, new Animal() zu erzeugen, sagt der Compiler sofort: „Entschuldige, aber abstrakte Tiere gibt es in der Natur nicht!“ Das ist nützlich: Sie stellen sicher, dass in der Anwendung nur konkrete Tiere mit konkretem Verhalten existieren.

2. Polymorphismus durch Abstraktion

Abstraktion – das ist die Hervorhebung einer gemeinsamen Schnittstelle für eine Objektgruppe. Eine abstrakte Klasse definiert genau diese gemeinsame Schnittstelle: Sie legt fest, welche Methoden zwingend von allen Unterklassen implementiert werden müssen.

Polymorphismus und Abstraktion arbeiten Hand in Hand: Die abstrakte Klasse garantiert, dass alle Unterklassen die benötigten Methoden haben, und der Polymorphismus erlaubt, diese Methoden über eine Referenz vom Basistyp aufzurufen.

Beispiel: Wir bauen einen Zoo

Stellen wir einen kleinen Zoo zusammen. Wir haben die abstrakte Klasse Animal und einige ihrer Unterklassen:

public abstract class Animal {
    public abstract void makeSound();
}

public class Cow extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Muh!");
    }
}

public class Duck extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Quak-quak!");
    }
}

Jetzt können wir ein Array von Tieren erstellen:

Animal[] zoo = {
    new Dog(),
    new Cat(),
    new Cow(),
    new Duck()
};

for (Animal animal : zoo) {
    animal.makeSound(); // Bei jedem Tier wird die richtige Methode aufgerufen
}

Jedes Objekt im Array ist ein konkretes Tier, aber für den Code ist es einfach Animal. Dank Polymorphismus und Abstraktion können wir sicher sein, dass jedes Objekt die Methode makeSound() besitzt und sie korrekt ausgeführt wird.

3. Einsatz abstrakter Klassen für Polymorphismus

Betrachten wir ein praxisnäheres Beispiel. Stellen wir uns vor, wir entwickeln eine Anwendung zur Verwaltung von Mitarbeitern eines Unternehmens. Es gibt verschiedene Mitarbeitertypen: Manager, Entwickler, Tester. Alle haben eine gemeinsame Methode work(), führen sie aber unterschiedlich aus.

Abstrakte Klasse Employee

public abstract class Employee {
    protected String name;

    public Employee(String name) {
        this.name = name;
    }

    public abstract void work();
}

Konkrete Unterklassen

public class Manager extends Employee {
    public Manager(String name) {
        super(name);
    }

    @Override
    public void work() {
        System.out.println(name + " leitet das Team.");
    }
}

public class Developer extends Employee {
    public Developer(String name) {
        super(name);
    }

    @Override
    public void work() {
        System.out.println(name + " schreibt Code.");
    }
}

public class Tester extends Employee {
    public Tester(String name) {
        super(name);
    }

    @Override
    public void work() {
        System.out.println(name + " testet die Anwendung.");
    }
}

Polymorphismus verwenden

Jetzt können wir ein Array von Mitarbeitern erstellen und für jeden die Methode work() aufrufen:

Employee[] employees = {
    new Manager("Anna"),
    new Developer("Ivan"),
    new Tester("Maria")
};

for (Employee e : employees) {
    e.work();
}

Ergebnis:

Anna leitet das Team.
Ivan schreibt Code.
Maria testet die Anwendung.

Beachten Sie: Wir wissen in der Schleife nicht (und wollen es auch nicht wissen), welcher konkrete Mitarbeitertyp vorliegt. Wir rufen einfach work() auf, und jedes Objekt erledigt seine Aufgabe.

4. Nützliche Nuancen

Garantie der Methodenimplementierung
Die abstrakte Klasse zwingt alle Unterklassen, die erforderlichen Methoden zu implementieren. Wenn Sie vergessen, eine abstrakte Methode in der Unterklasse zu implementieren, wird der Compiler Sie sofort ermahnen: „Das müssen Sie implementieren!“

Universelle Schnittstelle
Code, der mit einem Array oder einer Liste eines abstrakten Typs arbeitet (Employee[], List<Animal>), kann völlig generisch sein. Sie können neue Unterklassen hinzufügen – und der bestehende Code muss nicht geändert werden.

Schutz vor „fremden“ Objekten
Da eine abstrakte Klasse nicht direkt instanziiert werden kann, kann niemand versehentlich ein Objekt eines „unklaren“ Typs erzeugen, das die erforderlichen Methoden nicht implementiert.

Theorie und Syntax: Wie man eine abstrakte Klasse und Methode deklariert

• Eine abstrakte Klasse wird mit dem Schlüsselwort abstract vor class deklariert.
• Eine abstrakte Methode wird mit dem Schlüsselwort abstract deklariert und hat keinen Körper (nur ein Semikolon).
• Eine Klasse mit mindestens einer abstrakten Methode muss abstrakt sein.
• Eine Klasse, die von einer abstrakten Klasse erbt, muss alle deren abstrakten Methoden implementieren oder selbst abstrakt sein.

Schema

public abstract class Animal {
    public abstract void makeSound();
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Miau!");
    }
}

5. Typische Fehler beim Arbeiten mit abstrakten Klassen

Fehler Nr. 1: Versuch, ein Objekt einer abstrakten Klasse zu erzeugen.
Code wie new Animal() wird nicht kompiliert. Abstrakte Klassen – das ist wie eine Aufbauanleitung für Möbel ohne Bauteile: Solange keine konkrete Unterklasse vorhanden ist, kann kein Objekt zusammengebaut werden.

Fehler Nr. 2: Abstrakte Methode in der Unterklasse nicht implementiert.
Wenn Sie eine abstrakte Methode deklariert, aber in der Unterklasse nicht implementiert haben (und die Klasse nicht ebenfalls abstrakt ist), wird der Compiler sich beschweren und einen Fehler melden.

Fehler Nr. 3: Zugriffsmodifikatoren vergessen.
Eine überschriebene Methode darf keinen restriktiveren Zugriffsmodifikator haben als in der Basisklasse. Wenn die abstrakte Methode z. B. public war, muss auch die Implementierung public sein (und nicht protected oder private).

Fehler Nr. 4: Versuch, einer abstrakten Methode einen Rumpf zu geben.
abstract-Methoden dürfen keinen Körper haben, sonst verdreht der Compiler die Augen und sagt: „Entscheide dich – entweder Abstraktion oder Implementierung!“

Fehler Nr. 5: Polymorphismus funktioniert nicht für statische Methoden.
Polymorphismus funktioniert nur für nichtstatische Methoden. Statische Methoden werden nicht überschrieben – sie werden verdeckt, daher hängt das Verhalten beim Aufruf vom Typ der Variablen ab, nicht vom tatsächlichen Objekt.