Fabrikdesignmuster

Hallo Freund! Heute werden wir weiterhin Designmuster untersuchen. In dieser Lektion werden wir über Fabriken sprechen. Wir besprechen das Problem, das dieses Muster löst, und schauen uns ein Beispiel an, wie eine Fabrik Ihnen bei der Eröffnung eines Cafés helfen kann. Darüber hinaus gebe ich Ihnen 5 einfache Schritte zum Erstellen einer Fabrik. Damit wir alle auf einer Wellenlänge sind und Sie das Konzept schnell verstehen, sollten Sie sich mit folgenden Themen auskennen:

• Vererbung in Java
• Eingrenzung und Erweiterung von Referenztypen in Java
• Interaktion zwischen verschiedenen Klassen und Objekten.

Was ist eine Fabrik?

Mit dem Factory-Designmuster können Sie die Erstellung von Objekten steuern. Der Prozess der Erstellung eines neuen Objekts ist nicht ganz einfach, aber auch nicht übermäßig kompliziert. Wir alle wissen, dass wir den Operator benötigen new, um ein neues Objekt zu erstellen. Vielleicht scheint es, dass es hier nichts zu kontrollieren gibt, aber das stimmt nicht. Angenommen, unsere Anwendung hat eine bestimmte Klasse, die viele Nachkommen hat. Schwierigkeiten können auftreten, wenn abhängig von bestimmten Bedingungen eine Instanz einer bestimmten Klasse erstellt werden muss. Eine Fabrik ist ein Entwurfsmuster, das dabei hilft, das Problem der Erstellung verschiedener Objekte abhängig von bestimmten Bedingungen zu lösen. Wie ist das für ein abstraktes Konzept? Dies wird klarer und konkreter, wenn wir uns das folgende Beispiel ansehen.

Lassen Sie uns verschiedene Kaffeesorten zubereiten

Angenommen, wir möchten ein Café automatisieren. Wir müssen unserem Programm beibringen, wie man verschiedene Kaffeesorten zubereitet. Dazu erstellen wir eine Kaffeeklasse und einige abgeleitete Klassen, um die Kaffeesorten darzustellen, die wir zubereiten werden: Americano, Cappuccino, Espresso und Latte. Beginnen wir mit einem allgemeinen Kaffeekurs:

public class Coffee {
    public void grindCoffee(){
        // Grind the coffee
    }
    public void makeCoffee(){
        // Brew the coffee
    }
    public void pourIntoCup(){
        // Pour into a cup
    }
}

Als Nächstes erstellen wir die untergeordneten Klassen:

public class Americano extends Coffee {}
public class Cappuccino extends Coffee {}
public class CaffeLatte extends Coffee {}
public class Espresso extends Coffee {}

Unsere Kunden können jede Kaffeesorte bestellen. Ihre Befehle müssen an das Programm weitergeleitet werden. Dies kann auf viele Arten erfolgen, zum Beispiel mit String. Aber enumdafür ist ein am besten geeignet. Wir erstellen ein enumEnumerationsfeld und definieren es, das den bestellbaren Kaffeesorten entspricht:

public enum CoffeeType {
    ESPRESSO,
    AMERICANO,
    CAFFE_LATTE,
    CAPPUCCINO
}

Großartig. Schreiben wir nun den Code für unser Café:

public class CoffeeShop {
    
    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = null;
        
        switch (type) {
            case AMERICANO:
                coffee = new Americano();
                break;
            case ESPRESSO:
                coffee = new Espresso();
                break;
            case CAPPUCCINO:
                coffee = new Cappucсino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }

        coffee.grindCoffee();
        coffee.makeCoffee();
        coffee.pourIntoCup();

        System.out.println("Here's your coffee! Thanks! Come again!");
        return coffee;
    }
}

Die orderCoffeeMethode kann in zwei Teile unterteilt werden:

1. Erstellung einer bestimmten Kaffeeinstanz in einer switchAnweisung. Hier tut eine Fabrik, was sie tut: Sie erstellt abhängig von den Bedingungen einen bestimmten Typ.
2. Zubereitung – das ist das Mahlen, Aufbrühen und Abfüllen in eine Tasse.

Folgendes ist wichtig zu wissen, wenn Sie in Zukunft Änderungen an der Methode vornehmen müssen:

1. Die Schritte der Zubereitung selbst (mahlen, aufbrühen und in eine Tasse füllen) bleiben unverändert (zumindest rechnen wir damit).
2. Das Kaffeesortiment kann sich jedoch ändern. Vielleicht fangen wir an, Mokka zuzubereiten... Frappu... Mochacci... Wie auch immer, eine neue Kaffeesorte.

Wir können schon jetzt ziemlich sicher sein, dass wir in Zukunft Änderungen an der Aussage der Methode vornehmen müssen switch. Es ist auch möglich, dass die Methode nicht der einzige Ort ist, an dem wir in unserem Café orderCoffeeverschiedene Kaffeesorten kreieren. Dadurch müssen an mehreren Stellen Änderungen vorgenommen werden. Du verstehst wahrscheinlich schon, worauf ich hinaus will. Wir müssen umgestalten. Verschieben Sie den für die Kaffeezubereitung verantwortlichen Block aus zwei Gründen in eine separate Klasse:

1. Wir können die Kaffeezubereitungslogik an anderen Stellen wiederverwenden.
2. Wenn sich das Sortiment ändert, müssen wir den Code nicht überall dort bearbeiten, wo Kaffee hergestellt wird. Es reicht aus, unseren Code an nur einer Stelle zu ändern.

Mit anderen Worten: Es ist an der Zeit, eine Fabrik zu errichten.

Aufbau unserer ersten Fabrik

Dazu erstellen wir eine neue Klasse, die nur für die Erstellung der erforderlichen Instanzen von Kaffeeklassen verantwortlich ist:

public class SimpleCoffeeFactory {
    public Coffee createCoffee(CoffeeType type) {
        Coffee coffee = null;

        switch (type) {
            case AMERICANO:
                coffee = new Americano();
                break;
            case ESPRESSO:
                coffee = new Espresso();
                break;
            case CAPPUCCINO:
                coffee = new Cappucino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }
        
        return coffee;
    }
}

Glückwunsch! Wir haben gerade das Fabrikentwurfsmuster (fast) in seiner einfachsten Form implementiert. Es hätte noch einfacher sein können, wenn wir die createCoffeeMethode statisch gemacht hätten. Aber dann würden wir zwei Fähigkeiten verlieren:

1. Die Möglichkeit, SimpleCoffeeFactorydie Methode zu erben und zu überschreiben createCoffee.
2. Die Möglichkeit, die erforderliche Factory-Implementierung zu unseren Klassen hinzuzufügen.

Apropos Umsetzung: Wir müssen zum Café zurückkehren und unsere Kaffeefabrik hinzufügen.

Erweiterung des Cafés um eine Fabrik

Schreiben wir die Coffee-Shop-Klasse mithilfe einer Factory um:

public class CoffeeShop {

    private final SimpleCoffeeFactory coffeeFactory;

    public CoffeeShop(SimpleCoffeeFactory coffeeFactory) {
        this.coffeeFactory = coffeeFactory;
    }

    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = coffeeFactory.createCoffee(type);
        coffee.grindCoffee();
        coffee.makeCoffee();
        coffee.pourIntoCup();

        System.out.println("Here's your coffee! Thanks! Come again!");
        return coffee;
    }
}

Exzellent. Jetzt geben wir eine kurze Beschreibung der allgemeinen Struktur des Fabrikentwurfsmusters.

5 Schritte zur Eröffnung Ihrer eigenen Fabrik

Schritt 1. Ihr Programm verfügt über eine Klasse mit mehreren Nachkommen, wie im Diagramm unten: Schritt 2. Sie erstellen eine Klasse enummit einem Feld für jede untergeordnete Klasse:

    enum CatType {
        LION,
        TIGER,
        FLUFFY
    }

Schritt 3. Bauen Sie Ihre Fabrik. Nennen Sie es CatFactory. Hier ist der Code:

class CatFactory {}

Schritt 4: Erstellen Sie in Ihrer Factory eine createCatMethode, die ein CatTypeArgument akzeptiert. Hier ist der Code:

    class CatFactory {
        public Cat createCat(CatType type) {
            
        }
    }

Schritt 5: Schreiben Sie im Hauptteil der Methode eine switchAnweisung, die die Enum-Felder auflistet und eine Instanz der Klasse erstellt, die dem übergebenen enumWert entspricht:

class CatFactory {
        public Cat createCat(CatType type) {
            Cat cat = null;
            
            switch (type) {
                case LION:
                    cat =  new Fluffy();
                    break;
                case TIGER:
                    cat = new Tiger();
                    break;
                case FLUFFY:
                    cat =  new Lion();
                    break;
            }
            
            return cat;
        }
    }

Jetzt können Sie eine Fabrik wie ein Chef leiten. :) :)

Wie man übt

Lesen ist gut, Code schreiben ist noch besser. Wenn Ihr Name eine gerade Anzahl von Buchstaben hat, versuchen Sie, Ihre eigene virtuelle Pizzeria zu gründen. Wenn Ihr Name eine ungerade Anzahl an Buchstaben hat, versuchen Sie, eine virtuelle Sushi-Bar zu erstellen. Wenn Sie keinen Namen haben, haben Sie Glück gehabt. Heute können Sie entspannen.