[GO] [Viererbande] Designmusterlernen - Abstract Factory

Abstrakte Fabrik-Abstrakte Fabrik

** Inhaltsverzeichnis **

Die Grundidee der Objektorientierung ist, dass es besser ist, einen geringen Grad an Verbindung zwischen Objekten zu haben. Durch die Verwendung der Schnittstelle in Java können Sie es für die Seite, die die konkrete Klasse verwendet, unnötig machen, sich dessen bewusst zu sein.

Schnittstelle

Screen.java

interface Screen {
    public void view();
}

** Betonklasse **

TopScreen.java

public class TopScreen implements Screen {
    public void view() {
        System.out.println("der obere Bildschirm");
    }
}

LoginScreen.java

public class LoginScreen implements Screen {
    public void view() {
        System.out.println("Anmeldebildschirm");
    }
}

** Nutzer **

Client.java

public class Client {
    public void displayTopScreen() {
        Screen top = new TopScreen()
        top.view();
    }

    public void displayLoginScreen() {
        Screen login = new LoginScreen()
        login.view();
    }
}

Auf den ersten Blick scheint es kein Problem zu geben, aber in dem Teil, der jede Klasse instanziiert, `Screen top = new TopScreen ()` und Screen login = new LoginScreen () ` Es ist absolut notwendig, sich der konkreten Klasse bewusst zu sein. Dies widerspricht der Vorstellung, dass ein geringerer Kopplungsgrad besser ist. Wenn Sie den von Ihnen verwendeten Konstruktor ändern, müssen Sie alle instanziierten Teile ändern.

Dies wird gelöst, indem eine Klasse erstellt wird, die eine Instanz mit dem Namen `factory class erstellt. Diese factory class` ist jedoch auch flexibler, indem sie in eine abstrakte Klasse und eine konkrete Klasse unterteilt wird. Mit diesem Muster wird eine neue Objektgenerierungsfactory erstellt.

Zweck

Es bietet eine Schnittstelle zum Erstellen von Gruppen von Objekten, die miteinander verbunden oder voneinander abhängig sind, ohne ihre konkreten Klassen zu klären.

Komponente

-Definieren Sie die Schnittstelle, die die AbstractFactory AbstractProduct-Klasse generiert -Definieren Sie die Schnittstelle, die die ConcreteFactory ConcreteProduct-Klasse generiert -AbstractProduct Eine abstrakte Klasse, die die gemeinsamen Teile der generierten Teile extrahiert ・ ConcreteProduct Generierte Teile ・ Client-Benutzer

Implementierung

Hier ist der Beispielcode. Wir werden eine Fabrik einrichten, die die für das Auto erforderlichen Teile herstellt und das Fahrzeug dem Händler im folgenden Ablauf vorstellt.

Der Händler fordert das Fahrzeug vom Hersteller an-> Der Hersteller fordert die Autoteile vom Werk an-> Das Werk sendet verschiedene Teile an den Hersteller zurück-> Der Hersteller baut das Auto zusammen und sendet es an den Händler zurück-> Das Fahrzeug wird beim Händler angezeigt.

AbstractFactory Definiert die Schnittstelle, die die AbstractProduct-Klasse generiert

Fabrikklasse für die Herstellung von Autoteilen

CarFactory.kt

package abstractfactory

open class CarFactory {

    open fun makeEngine(displacement: Int): Engine {
        return Engine(displacement)
    }

    open fun makeTire(position: Int): Tire {
        return Tire(position)
    }

    open fun makeSteering(weight: Int): Steering {
        return Steering(weight)
    }

}

AbstractProduct Eine abstrakte Klasse, die die gemeinsamen Teile der generierten Teile extrahiert

Motorklasse

Engine.kt

package abstractfactory

open class Engine(displacement: Int) {
    open val type = "Gewöhnlicher Motor"
    val displacement = displacement
}

Reifenklasse

Tire.kt

package abstractfactory

open class Tire(position: Int) {
    open val type = "Gewöhnlicher Reifen"
    val position = position
}

Klasse behandeln

Steering.kt

package abstractfactory

class Steering(weight: Int) {
    val type = "Gewöhnlicher Griff"
    val weight = weight
}

Autoklasse

Car.kt

package abstractfactory

open class Car(type: String, engine: Engine, tire: Tire, steering: Steering) {
    val type = type
    val engine = engine
    val tire = tire
    val steering = steering

    fun getConstitution(): String {
        return  "[Fahrzeugtyp]:" + type + "," +
                "【Motor】:" + engine.type + "," +
                "【Reifen】:" + tire.type + "," +
                "【Griff】:" + steering.type
    }
}

Client-Benutzer

Autohersteller Klasse

Maker.kt

package abstractfactory

class Maker {

    /**
     *Gewöhnliche Automobilherstellung
     */
    fun getCar(): Car {
        return make("Familienauto", CarFactory())
    }

    /**
     *Herstellung
     */
    private fun make(type: String, factory: CarFactory): Car {
        val engine = factory.makeEngine(1000)
        val tire = factory.makeTire(1)
        val steering = factory.makeSteering(100)

        return Car(type, engine, tire, steering)
    }

}

Autohändlerklasse

AutomobileDealer.kt

package abstractfactory

class AutomobileDealer {

    val cars = mutableListOf<Car>()

    init {
        openingUp()
    }

    /**
     *Liste der Autos im Händler
     */
    fun showCars() {
        cars.forEach {
            println(it.getConstitution())
        }
    }

    /**
     *Ladenöffnung
     */
    private fun openingUp() {
        val maker = Maker()
        cars.add(maker.getCar())
    }
}

Ausgabeergebnis

Wenn Sie AutomobileDealer # showCars () aufrufen, wird das angezeigte Fahrzeug (Spezifikation) ausgegeben.

[output]
[Fahrzeugtyp]: Familienauto,[Motor]: Gewöhnlicher Motor,[Reifen]: Gewöhnlicher Reifen,[Griff]: Gewöhnlicher Griff

Es wurde mit dem oben Gesagten abgeschlossen, aber plötzlich sagte der Präsident, er solle eine Fabrik bauen, in der auch Teile für Superautos auf derselben Linie hergestellt werden können, während die bestehende Produktionslinie beibehalten wird.

ConcreteFactory Definiert die Schnittstelle, die die ConcreteProduct-Klasse generiert

Super Autoteile Herstellung Fabrikklasse

SuperCarFactory.kt

package abstractfactory

class SuperCarFactory: CarFactory() {

    override fun makeEngine(displacement: Int): Engine {
        return HiPerformanceEngine(displacement)
    }

    override fun makeTire(position: Int): Tire {
        return HiGripTire(position)
    }
}

ConcreteProduct Generierte Teile

Hochleistungs-Motorklasse

HiPerformanceEngine.kt

package abstractfactory

class HiPerformanceEngine(displacement: Int): Engine(displacement) {
    override val type = "Hochleistungsmotor"
}

High Grip Reifenklasse

HiGripTire.kt

package abstractfactory

class HiGripTire(position: Int): Tire(position) {
    override val type = "Reifen mit hohem Grip"
}

Fügen Sie dem Hersteller eine Super-Auto-Herstellungsmethode hinzu.

Client-Benutzer

Herstellerklasse

Maker.kt

package abstractfactory

class Maker {

    /**
     *Automobilherstellung
     */
    fun getCar(): Car {
        return make(CarFactory())
    }

    /**
     *Super Autoherstellung
     */
    fun getSuperCar(): Car {
        return make("Super Auto", SuperCarFactory())
    }

    /**
     *Herstellung
     */
    private fun make(type: String, factory: CarFactory): Car {
        val engine = factory.makeEngine(1000)
        val tire = factory.makeTire(1)
        val steering = factory.makeSteering(100)

        return Car(type, engine, tire, steering)
    }

}

Der Händler verlangt vom Hersteller ein neues Fahrzeug (Superauto).

AutomobileDealer.kt

package abstractfactory

class AutomobileDealer {

    val cars = mutableListOf<Car>()

    init {
        openingUp()
    }

    /**
     *Liste der Autos im Händler
     */
    fun showCars() {
        cars.forEach {
            println(it.getConstitution())
        }
    }

    /**
     *Ladenöffnung
     */
    private fun openingUp() {
        val maker = Maker()
        cars.add(maker.getCar())
        cars.add(maker.getSuperCar())
        cars.add(maker.getSuperCar())
    }
}

Wenn Sie AutomobileDealer # showCars () aufrufen, können Sie sehen, dass die Supercars neu angezeigt werden.

Ausgabeergebnis

[output]
[Fahrzeugtyp]: Familienauto,[Motor]: Gewöhnlicher Motor,[Reifen]: Gewöhnlicher Reifen,[Griff]: Gewöhnlicher Griff
[Fahrzeugtyp]: Superauto,[Motor]: Hochleistungsmotor,[Reifen]: Reifen mit hohem Grip,[Griff]: Gewöhnlicher Griff
[Fahrzeugtyp]: Superauto,[Motor]: Hochleistungsmotor,[Reifen]: Reifen mit hohem Grip,[Griff]: Gewöhnlicher Griff

Mit dem oben Gesagten konnten wir der Bitte des Präsidenten nachkommen.