Entwurfsmuster in Java mit Beispielen: von A bis Z

Entwurfsmuster in Java: Vollständiger Leitfaden mit Beispielen

Entwurfsmuster (design patterns) sind bewährte Lösungen für typische Aufgaben, die bei der Softwareentwicklung auftreten. In Java, einer streng typisierten objektorientierten Sprache, sind Muster besonders effektiv. Sie helfen, Code flexibel, wiederverwendbar und leicht wartbar zu machen. In diesem Artikel betrachten wir die drei Hauptgruppen von Mustern (nach der GoF-Klassifikation): Erzeugungsmuster, Strukturmuster und Verhaltensmuster – mit echten Java-Beispielen.

1. Erzeugungsmuster (Creational Patterns)

Diese Muster steuern den Prozess der Objekterstellung und machen das System unabhängig davon, wie Objekte erstellt, zusammengesetzt und dargestellt werden.

1.1. Singleton (Einzelstück)

Stellt sicher, dass eine Klasse nur eine Instanz hat, und bietet einen globalen Zugriffspunkt darauf. Ein klassisches Beispiel ist ein Datenbankverbindungspool oder ein Logger.

public class DatabaseConnection {    private static volatile DatabaseConnection instance;    private String connectionString;

    private DatabaseConnection(String connectionString) {        this.connectionString = connectionString;    }

    public static DatabaseConnection getInstance(String connectionString) {        if (instance == null) {            synchronized (DatabaseConnection.class) {                if (instance == null) {                    instance = new DatabaseConnection(connectionString);                }            }        }        return instance;    }

    public void connect() {        System.out.println("Connected to: " + connectionString);    }}

// VerwendungDatabaseConnection conn = DatabaseConnection.getInstance("jdbc:mysql://localhost:3306/mydb");conn.connect();

1.2. Factory Method (Fabrikmethode)

Definiert eine Schnittstelle zur Erstellung eines Objekts, ermöglicht es Unterklassen jedoch, den Typ des erstellten Objekts zu ändern. Ideal geeignet, wenn der genaue Objekttyp im Voraus nicht bekannt ist.

interface Transport {    void deliver();}

class Truck implements Transport {    public void deliver() { System.out.println("Lieferung per LKW auf der Straße"); }}

class Ship implements Transport {    public void deliver() { System.out.println("Lieferung per Schiff auf dem Seeweg"); }}

abstract class Logistics {    abstract Transport createTransport();        public void planDelivery() {        Transport t = createTransport();        t.deliver();    }}

class RoadLogistics extends Logistics {    Transport createTransport() { return new Truck(); }}

class SeaLogistics extends Logistics {    Transport createTransport() { return new Ship(); }}

// VerwendungLogistics logistics = new RoadLogistics();logistics.planDelivery(); // Ausgabe: Lieferung per LKW auf der Straße

2. Strukturmuster (Structural Patterns)

Sie sind für die Zusammensetzung von Klassen und Objekten verantwortlich und helfen, komplexe Strukturen aus einfachen Komponenten aufzubauen.

2.1. Adapter (Adapter)

Ermöglicht Objekten mit inkompatiblen Schnittstellen die Zusammenarbeit. Wird häufig zur Integration von Altcode (Legacy) mit neuem Code verwendet.

// Alte Schnittstelleinterface OldSystem {    String getDataInXML();}

// Neue Schnittstelleinterface NewSystem {    String getDataInJSON();}

// Implementierung des alten Systemsclass LegacySystem implements OldSystem {    public String getDataInXML() { return "<data>Hello</data>"; }}

// Adapterclass XMLToJSONAdapter implements NewSystem {    private OldSystem oldSystem;        public XMLToJSONAdapter(OldSystem oldSystem) {        this.oldSystem = oldSystem;    }        public String getDataInJSON() {        String xml = oldSystem.getDataInXML();        return "{\\"data\\": \\"" + xml.replaceAll("<.*?>", "") + "\\"}";    }}

// U