Objektorientiertes Design
Objektorientiertes Design (OOD) ist ein Ansatz zur Softwareentwicklung, der auf den Prinzipien der Objektorientierung basiert. Es zielt darauf ab, Systeme durch die Definition von Objekten zu modellieren, die sowohl Daten als auch Verhalten kapseln. Dieser Abschnitt behandelt die grundlegenden Prinzipien des OOD und stellt gängige Entwurfsmuster (Design Patterns) vor.
Prinzipien des objektorientierten Designs
1. Abstraktion
Abstraktion ist die Reduzierung der Komplexität durch das Modellieren von Systemen auf einer höheren Abstraktionsebene. Es ermöglicht Entwicklern, sich auf die wesentlichen Merkmale eines Objekts zu konzentrieren und unwichtige Details zu verbergen.
Beispiel:
// Abstrakte Klasse Fahrzeug definiert gemeinsame Eigenschaften und Methoden für verschiedene Fahrzeugtypen.
public abstract class Fahrzeug {
private String modell;
private String hersteller;
public Fahrzeug(String modell, String hersteller) {
this.modell = modell;
this.hersteller = hersteller;
}
// Abstrakte Methode, die in den Unterklassen implementiert wird.
public abstract void fahren();
}
2. Kapselung
Kapselung (Encapsulation) bedeutet, die internen Zustände und Daten eines Objekts zu verbergen und nur die notwendigen Funktionen bereitzustellen. Dies schützt die Daten und ermöglicht es, Änderungen an der Implementierung vorzunehmen, ohne die Benutzer des Objekts zu beeinträchtigen.
Beispiel:
// Klasse Konto kapselt das Saldo-Attribut und bietet öffentliche Methoden zur Manipulation.
public class Konto {
private double saldo;
// Methode zum Einzahlen eines Betrags auf das Konto.
public void einzahlen(double betrag) {
if (betrag > 0) {
saldo += betrag;
}
}
// Methode zum Abfragen des aktuellen Kontostands.
public double getSaldo() {
return saldo;
}
}
3. Vererbung
Vererbung ermöglicht es, neue Klassen auf der Basis bestehender Klassen zu erstellen und deren Verhalten zu erweitern. Dies fördert die Wiederverwendung von Code und die Hierarchisierung von Klassen.
Beispiel:
// Klasse Auto erbt von der abstrakten Klasse Fahrzeug.
public class Auto extends Fahrzeug {
public Auto(String modell, String hersteller) {
super(modell, hersteller);
}
// Implementierung der abstrakten Methode fahren.
@Override
public void fahren() {
System.out.println("Das Auto fährt.");
}
}
4. Polymorphismus
Polymorphismus ermöglicht es, dass verschiedene Klassen eine gemeinsame Schnittstelle implementieren und unterschiedlich reagieren können. Dies fördert die Flexibilität und die Erweiterbarkeit des Codes.
Beispiel:
// Schnittstelle Tier definiert eine Methode für Geräusche.
public interface Tier {
void geraeuschMachen();
}
// Klasse Hund implementiert die Tier-Schnittstelle.
public class Hund implements Tier {
@Override
public void geraeuschMachen() {
System.out.println("Wuff!");
}
}
// Klasse Katze implementiert die Tier-Schnittstelle.
public class Katze implements Tier {
@Override
public void geraeuschMachen() {
System.out.println("Miau!");
}
}
Entwurfsmuster (Design Patterns)
Entwurfsmuster sind bewährte Lösungen für häufig auftretende Probleme in der Softwareentwicklung. Sie bieten allgemeine, wiederverwendbare Lösungen, die in verschiedenen Kontexten angewendet werden können.
1. Singleton
Das Singleton-Muster stellt sicher, dass eine Klasse nur eine Instanz hat und bietet einen globalen Zugriffspunkt auf diese Instanz.
Beispiel:
// Singleton-Klasse stellt sicher, dass nur eine Instanz existiert.
public class Singleton {
// Statische Instanz der Klasse Singleton.
private static Singleton instance;
// Privater Konstruktor verhindert die Erstellung neuer Instanzen.
private Singleton() {}
// Öffentliche Methode zum Zugriff auf die Singleton-Instanz.
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
2. Factory
Das Factory-Muster ermöglicht die Erstellung von Objekten, ohne den genauen Klassennamen anzugeben. Es definiert eine Schnittstelle zur Erstellung eines Objekts, lässt aber Unterklassen entscheiden, welche Klasse instanziiert wird.
Beispiel:
// Abstrakte Fabrikklasse zur Erstellung von Tieren.
public abstract class TierFactory {
public abstract Tier createTier();
// Statische Methode zur Auswahl der passenden Fabrik basierend auf dem Typ.
public static TierFactory getFactory(String type) {
switch (type) {
case "Hund":
return new HundFactory();
case "Katze":
return new KatzeFactory();
default:
throw new IllegalArgumentException("Unbekannter Typ.");
}
}
}
// Konkrete Fabrikklasse zur Erstellung von Hunden.
public class HundFactory extends TierFactory {
@Override
public Tier createTier() {
return new Hund();
}
}
// Konkrete Fabrikklasse zur Erstellung von Katzen.
public class KatzeFactory extends TierFactory {
@Override
public Tier createTier() {
return new Katze();
}
}
3. Observer
Das Observer-Muster definiert eine Eins-zu-viele-Abhängigkeit zwischen Objekten, sodass bei Änderung eines Objekts alle abhängigen Objekte benachrichtigt und automatisch aktualisiert werden.
Beispiel:
import java.util.ArrayList;
import java.util.List;
// Subjekt-Klasse, die eine Liste von Beobachtern verwaltet.
public class Subject {
private List<Observer> observers = new ArrayList<>();
// Methode zum Hinzufügen eines Beobachters.
public void addObserver(Observer observer) {
observers.add(observer);
}
// Methode zur Benachrichtigung aller Beobachter.
public void notifyObservers() {
for (Observer observer : observers) {
observer.update();
}
}
}
// Observer-Schnittstelle definiert die update-Methode.
public interface Observer {
void update();
}
// Konkrete Beobachter-Klasse, die auf Benachrichtigungen reagiert.
public class ConcreteObserver implements Observer {
@Override
public void update() {
System.out.println("Benachrichtigung erhalten!");
}
}
Visualisierung des objektorientierten Designs
Klassendiagramm eines Singleton-Musters:
classDiagram
class Singleton {
-instance: Singleton
-Singleton()
+getInstance(): Singleton
}
Sequenzdiagramm eines Factory-Musters:
sequenceDiagram
participant Client
participant TierFactory
participant Tier
Client ->> TierFactory: getFactory("Hund")
TierFactory ->> HundFactory: createTier()
HundFactory ->> Tier: Hund()
Tier -->> Client: Hund-Objekt