1. Hierarchie aufbauen: von der Abstraktion zu den Details
Die Implementierung von Abstraktionen und Hierarchien ist eine Methode, Code von allgemeinen Regeln hin zu konkreten Details zu strukturieren. Zuerst beschreiben wir, was alle Objekte können müssen (Abstraktion), und danach präzisieren wir, wie genau das jede konkrete Klasse macht.
In der Programmierung beginnt wie im Leben alles mit Fragen. Zum Beispiel: „Was haben Kreis und Rechteck gemeinsam?“ Antwort: Beide sind Figuren. Und was haben Figuren gemeinsam? Meistens haben sie eine Fläche und man kann sie zeichnen.
In Java wird das durch eine abstract-Klasse ausgedrückt:
public abstract class Shape {
public abstract double area();
public abstract void draw();
}
Hier sagen wir:
- Jede Figur muss ihre Fläche berechnen können (area()).
- Jede Figur muss gezeichnet werden können (draw()).
- Wie genau sie das macht – interessiert uns vorerst nicht.
Jetzt erstellen wir konkrete Figuren:
public class Circle extends Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public double area() {
return Math.PI * radius * radius;
}
@Override
public void draw() {
System.out.println("Wir zeichnen einen Kreis mit Radius " + radius);
}
}
public class Rectangle extends Shape {
private double width, height;
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
@Override
public double area() {
return width * height;
}
@Override
public void draw() {
System.out.println("Wir zeichnen ein Rechteck " + width + "x" + height);
}
}
Was haben wir getan?
- Gemeinsames in eine abstrakte Klasse ausgelagert.
- Das Verhalten in den Unterklassen konkretisiert.
Schematisch:
. Shape
/ \
Circle Rectangle
Tabelle: Was ist wo implementiert
| Klasse | area() | draw() | Eigene Felder |
|---|---|---|---|
| Shape | |
|
- |
| Circle | implementiert | implementiert | |
| Rectangle | implementiert | implementiert | |
2. Warum ist das praktisch? (und warum funktioniert das überhaupt)
Einheitliche Schnittstelle für die Arbeit mit unterschiedlichen Objekten
Angenommen, Sie haben eine Sammlung von Figuren:
Shape[] shapes = {
new Circle(5),
new Rectangle(3, 4),
new Circle(2.5)
};
Sie können sie alle gleichartig durchlaufen, ohne über den Typ nachzudenken:
for (Shape shape : shapes) {
shape.draw();
System.out.println("Fläche: " + shape.area());
}
Lassen Sie die JVM selbst herausfinden, wer Kreis und wer Rechteck ist! Das ist Polymorphie (wir haben bereits darüber gesprochen und werden im nächsten Block noch genauer darauf eingehen).
Einfache Erweiterbarkeit
Möchten Sie ein Dreieck hinzufügen? Einfach schreiben (neuer Typ – alter Code bleibt unverändert): Triangle extends Shape.
public class Triangle extends Shape {
private double base, height;
public Triangle(double base, double height) {
this.base = base;
this.height = height;
}
@Override
public double area() {
return 0.5 * base * height;
}
@Override
public void draw() {
System.out.println("Wir zeichnen ein Dreieck: Grundseite " + base + ", Höhe " + height);
}
}
Den restlichen Code (z. B. die Iteration über die Liste der Figuren) müssen Sie nicht ändern.
Vermeidung von Duplikaten im Code
Wenn alle Figuren eine gemeinsame Eigenschaft bekommen (z. B. die Farbe), kann man sie bequem in die abstrakte Klasse auslagern:
public abstract class Shape {
private String color = "schwarz";
public String getColor() { return color; }
public void setColor(String color) { this.color = color; }
public abstract double area();
public abstract void draw();
}
Nun erbt jeder Nachfolger – ob Kreis oder Dreieck – die Farbe.
3. Praxis: Wir entwickeln einen Mini‑Grafikeditor
Lassen Sie uns alles zusammenführen. Stellen Sie sich vor, Sie entwickeln einen einfachen Grafikeditor.
Abstrakte Klasse Figure
public abstract class Figure {
private String color = "black";
public String getColor() { return color; }
public void setColor(String color) { this.color = color; }
public abstract void draw();
public abstract void resize(double factor);
}
Konkrete Figuren
public class Line extends Figure {
private double length;
public Line(double length) {
this.length = length;
}
@Override
public void draw() {
System.out.println("Wir zeichnen eine Linie der Länge " + length + " in der Farbe " + getColor());
}
@Override
public void resize(double factor) {
length *= factor;
System.out.println("Neue Linienlänge: " + length);
}
}
public class Ellipse extends Figure {
private double a, b;
public Ellipse(double a, double b) {
this.a = a;
this.b = b;
}
@Override
public void draw() {
System.out.println("Wir zeichnen eine Ellipse mit den Achsen " + a + " und " + b + " in der Farbe " + getColor());
}
@Override
public void resize(double factor) {
a *= factor;
b *= factor;
System.out.println("Neue Achsen der Ellipse: " + a + ", " + b);
}
}
Möchten Sie ein neues Werkzeug hinzufügen, zum Beispiel Polygon? Erstellen Sie einfach eine neue Klasse – der gesamte Editor-Code arbeitet über die abstrakte Figure.
Verwendung im Code
Figure[] figures = {
new Line(10),
new Ellipse(5, 3)
};
for (Figure figure : figures) {
figure.setColor("red");
figure.draw();
figure.resize(1.5);
}
Ausgabe:
Wir zeichnen eine Linie der Länge 10.0 in der Farbe red
Neue Linienlänge: 15.0
Wir zeichnen eine Ellipse mit den Achsen 5.0 und 3.0 in der Farbe red
Neue Achsen der Ellipse: 7.5, 4.5
Visualisierung der Hierarchie
. Figure
/ \
Line Ellipse
4. So vermeidet man Duplikate: gemeinsame Felder und Methoden
Manchmal haben alle Unterklassen nicht nur gemeinsame Methoden, sondern auch gemeinsame Felder (zum Beispiel die Koordinaten des Zentrums). Die abstrakte Klasse ist der ideale Ort dafür:
public abstract class Figure {
private double x, y; // Koordinaten des Zentrums
public Figure(double x, double y) {
this.x = x;
this.y = y;
}
public void moveTo(double newX, double newY) {
x = newX;
y = newY;
System.out.println("Die Figur wurde zum Punkt (" + x + ", " + y + ") verschoben");
}
public abstract void draw();
}
Jetzt können beliebige Line oder Ellipse verschoben werden, ohne diese Methode neu zu implementieren.
5. Noch ein Beispiel: Zahlungssysteme
Abstraktion ist nicht nur etwas für Figuren! Stellen Sie sich vor, Sie schreiben ein System zur Zahlungsabwicklung.
Abstrakte Klasse Payment
public abstract class Payment {
public abstract void process();
}
Konkrete Implementierungen
public class CreditCardPayment extends Payment {
@Override
public void process() {
System.out.println("Verarbeitung einer Zahlung mit Kreditkarte");
}
}
public class PaypalPayment extends Payment {
@Override
public void process() {
System.out.println("Verarbeitung einer Zahlung über PayPal");
}
}
Verwendung
Payment[] payments = {
new CreditCardPayment(),
new PaypalPayment()
};
for (Payment payment : payments) {
payment.process();
}
Ausgabe:
Verarbeitung einer Zahlung mit Kreditkarte
Verarbeitung einer Zahlung über PayPal
6. Vorteile dieses Ansatzes
- Einheitliche Schnittstelle: Mit unterschiedlichen Objekten lässt sich auf die gleiche Weise arbeiten.
- Erweiterbarkeit: Das Hinzufügen neuer Objektarten erfordert kein Umschreiben des alten Codes.
- Minimale Duplizierung: Gemeinsames ist in der abstrakten Basisklasse untergebracht.
- Flexibilität: Man kann Sammlungen abstrakter Typen verwenden, ohne sich um Details zu kümmern.
7. Beispiel aus der Praxis: Transport
Abstraktion begegnet uns nicht nur in Lehrbüchern. Wenn Sie zum Beispiel ein System zur Steuerung von Transportmitteln entwerfen:
public abstract class Transport {
public abstract void move();
public abstract void fuelUp();
}
Konkrete Verkehrsmittel implementieren die Details:
public class Car extends Transport {
@Override
public void move() {
System.out.println("Das Auto fährt auf der Straße");
}
@Override
public void fuelUp() {
System.out.println("Wir tanken Benzin");
}
}
public class Bicycle extends Transport {
@Override
public void move() {
System.out.println("Das Fahrrad wird durch Pedale angetrieben");
}
@Override
public void fuelUp() {
System.out.println("Ein Fahrrad braucht keinen Treibstoff, nur Sandwiches für den Radfahrer!");
}
}
8. Nützliche Skizze: wie man eine Abstraktionshierarchie aufbaut
[Abstrakte Klasse]
|
[Konkrete Unterklasse]
|
[Noch spezifischere Unterklasse] (falls nötig)
- Alles Gemeinsame – nach oben!
- Alles Einzigartige – nach unten!
9. Typische Fehler bei der Implementierung von Abstraktionen und Hierarchien
Fehler Nr. 1: Code-Duplikate in Unterklassen.
Wenn Sie feststellen, dass Sie in jeder Unterklasse die gleichen Felder oder Methoden schreiben, ist das ein Signal, sie in die abstrakte Klasse auszulagern. Scheuen Sie sich nicht, die Abstraktion „breiter“ zu machen, wenn das die Duplizierung verringert.
Fehler Nr. 2: Verstoß gegen das Prinzip „vom Allgemeinen zum Besonderen“.
Manche Einsteiger beginnen, Hierarchien „von den Details her“ zu bauen und vergessen das Allgemeine. Dadurch entstehen seltsame Klassen wie RedCircleWithShadow, die schlecht in die Gesamtstruktur passen. Identifizieren Sie immer zuerst die Abstraktion und erst danach die Details.
Fehler Nr. 3: Zu tiefe Hierarchien.
Wenn Ihre Vererbungskette länger als 3–4 Ebenen ist, überlegen Sie, ob es nicht Zeit ist, Komposition oder Interfaces statt Vererbung einzusetzen.
Fehler Nr. 4: Erzwungene Implementierung irrelevanter Methoden.
Wenn eine abstrakte Klasse zu viele abstrakte Methoden enthält, die für einige Unterklassen nicht relevant sind, sollten Sie die Struktur überdenken. Nicht alle Verkehrsmittel benötigen beispielsweise die Methode fuelUp() (für ein Fahrrad ist sie überflüssig).
Fehler Nr. 5: Verwechslung zwischen abstrakter Klasse und Interface.
Abstrakte Klasse – wenn es einen gemeinsamen Zustand und/oder eine teilweise Implementierung gibt. Interface – wenn man nur das Vorhandensein von Methoden „versprechen“ muss, aber keine Daten speichern und kein Verhalten implementieren soll. Mischen Sie diese Ansätze nicht ohne Not.
GO TO FULL VERSION