Nennen Sie die Muster, die zu den Erzeugungsmustern…

Fabrikmethode (Factory Method): Definiert eine Schnittstelle zur Objekterstellung, lässt aber Unterklassen entscheiden, welche Klasse instanziiert wird.

// Schnittstelle der Fabrik
class Creator {
    factoryMethod() {
        throw new Error("Methode muss von Unterklassen implementiert werden");
    }

    anOperation() {
        const product = this.factoryMethod();
        return `Creator: dieselbe Logik, die gerade mit ${product.operation()} gearbeitet hat`;
    }
}

// Konkrete Fabrik, die ProductA erstellt
class ConcreteCreatorA extends Creator {
    factoryMethod() {
        return new ConcreteProductA();
    }
}

// Schnittstelle des Produkts
class Product {
    operation() {
        throw new Error("Methode muss von Unterklassen implementiert werden");
    }
}

// Konkretes Produkt, erstellt von ConcreteCreatorA
class ConcreteProductA extends Product {
    operation() {
        return "Ergebnis von ConcreteProductA";
    }
}

// Verwendung
const creator = new ConcreteCreatorA();
console.log(creator.anOperation());

Abstrakte Fabrik (Abstract Factory): Bietet eine Schnittstelle zur Erstellung von Familien verwandter oder abhängiger Objekte, ohne ihre konkreten Klassen zu spezifizieren.

// Schnittstelle der abstrakten Fabrik
class AbstractFactory {
    createProductA() {
        throw new Error("Methode muss von Unterklassen implementiert werden");
    }

    createProductB() {
        throw new Error("Methode muss von Unterklassen implementiert werden");
    }
}

// Konkrete Fabrik für die Erstellung von Produkten Variante 1
class ConcreteFactory1 extends AbstractFactory {
    createProductA() {
        return new ConcreteProductA1();
    }

    createProductB() {
        return new ConcreteProductB1();
    }
}

// Konkrete Fabrik für die Erstellung von Produkten Variante 2
class ConcreteFactory2 extends AbstractFactory {
    createProductA() {
        return new ConcreteProductA2();
    }

    createProductB() {
        return new ConcreteProductB2();
    }
}

// Schnittstellen der Produkte
class AbstractProductA {
    operationA() {
        throw new Error("Methode muss von Unterklassen implementiert werden");
    }
}

class AbstractProductB {
    operationB() {
        throw new Error("Methode muss von Unterklassen implementiert werden");
    }

    anotherOperationB(collaborator) {
        throw new Error("Methode muss von Unterklassen implementiert werden");
    }
}

// Konkrete Produkte Variante 1
class ConcreteProductA1 extends AbstractProductA {
    operationA() {
        return "Ergebnis von ConcreteProductA1";
    }
}

class ConcreteProductB1 extends AbstractProductB {
    operationB() {
        return "Ergebnis von ConcreteProductB1";
    }
    anotherOperationB(collaborator) {
        return `Ergebnis von ConcreteProductB1 zusammen mit ${collaborator.operationA()}`;
    }
}

// Konkrete Produkte Variante 2
class ConcreteProductA2 extends AbstractProductA {
    operationA() {
        return "Ergebnis von ConcreteProductA2";
    }
}

class ConcreteProductB2 extends AbstractProductB {
    operationB() {
        return "Ergebnis von ConcreteProductB2";
    }
    anotherOperationB(collaborator) {
        return `Ergebnis von ConcreteProductB2 zusammen mit ${collaborator.operationA()}`;
    }
}

// Verwendung
function clientCode(factory) {
    const productA = factory.createProductA();
    const productB = factory.createProductB();

    console.log(productB.operationB());
    console.log(productB.anotherOperationB(productA));
}

console.log('Kunde: Testen von Factory1...');
clientCode(new ConcreteFactory1());

console.log('Kunde: Testen von Factory2...');
clientCode(new ConcreteFactory2());

Builder (Builder): Ermöglicht die schrittweise Erstellung komplexer Objekte. Bietet die Möglichkeit, einen einheitlichen Bauprozess zu verwenden, um verschiedene Darstellungen des Objekts zu erhalten.

// Schnittstelle des Bauers
class Builder {
    producePartA() { }
    producePartB() { }
    producePartC() { }
}

// Konkreter Bauer
class ConcreteBuilder1 extends Builder {
    constructor() {
        super();
        this.reset();
    }

    reset() {
        this.product = new Product1();
    }

    producePartA() {
        this.product.parts.push('PartA1');
    }

    producePartB() {
        this.product.parts.push('PartB1');
    }

    producePartC() {
        this.product.parts.push('PartC1');
    }

    getProduct() {
        const result = this.product;
        this.reset();
        return result;
    }
}

// Das dargestellte Produkt
class Product1 {
    constructor() {
        this.parts = [];
    }

    listParts() {
        console.log(`Teile des Produkts: ${this.parts.join(', ')}`);
    }
}

// Regisseur (optional, steuert den Bauprozess)
class Director {
    setBuilder(builder) {
        this.builder = builder;
    }

    buildMinimalViableProduct() {
        this.builder.producePartA();
    }

    buildFullFeaturedProduct() {
        this.builder.producePartA();
        this.builder.producePartB();
        this.builder.producePartC();
    }
}

// Verwendung
const director = new Director();
const builder = new ConcreteBuilder1();
director.setBuilder(builder);

console.log('Standardminimumprodukt:');
director.buildMinimalViableProduct();
builder.getProduct().listParts();

console.log('Standardvollprodukt:');
director.buildFullFeaturedProduct();
builder.getProduct().listParts();

console.log('Benutzerdefiniertes Produkt:');
builder.producePartA();
builder.producePartC();
builder.getProduct().listParts();

Nennen Sie die Muster, die zu den Erzeugungsmustern gehören.