[JAVA] [Gang of Four] Apprentissage des modèles de conception - Usine abstraite

Usine abstraite-usine abstraite

** Table des matières **

L'idée de base de l'orientation des objets est qu'il vaut mieux avoir un faible degré de connexion entre les objets. En utilisant l'interface en java, il est possible de rendre inutile pour le côté utilisant la classe concrète d'en être conscient.

interface

Screen.java


interface Screen {
    public void view();
}

** Classe de béton **

TopScreen.java


public class TopScreen implements Screen {
    public void view() {
        System.out.println("l'écran supérieur");
    }
}

LoginScreen.java


public class LoginScreen implements Screen {
    public void view() {
        System.out.println("Écran de connexion");
    }
}

** Utilisateur **

Client.java


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

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

À première vue, il ne semble y avoir aucun problème, mais dans la partie qui instancie chaque classe, Haut de l'écran = nouveau TopScreen () '' et Connexion à l'écran = nouveau LoginScreen () Il faut absolument être conscient de la classe concrète. Cela va à l'encontre de l'idée qu'un degré de couplage inférieur est meilleur, et si vous modifiez le constructeur que vous utilisez, vous devrez modifier toutes les pièces instanciées.

Ce problème est résolu en créant une classe qui crée une instance appelée classe d'usine '', mais cette classe d'usine '' est également plus flexible en la divisant en une classe abstraite et une classe concrète. Ce modèle consiste à créer une nouvelle fabrique de génération d'objets.

Objectif

Il fournit une interface pour créer des groupes d'objets liés ou dépendants les uns des autres sans clarifier leurs classes concrètes.

Composant

-Définir l'interface qui génère la classe AbstractFactory AbstractProduct -Définir l'interface qui génère la classe ConcreteFactory ConcreteProduct -AbstractProduct Une classe abstraite qui extrait les parties communes des parties générées ・ Pièces générées par le béton ・ Utilisateur client

la mise en oeuvre

Voici l exemple de code. Nous mettrons en place une usine qui fabrique les pièces nécessaires à la voiture et présenterons le véhicule au concessionnaire dans le flux suivant.

Le concessionnaire demande le véhicule au constructeur-> Le constructeur demande les pièces automobiles à l'usine-> L'usine renvoie diverses pièces au constructeur-> Le constructeur assemble la voiture et la renvoie au concessionnaire-> Le véhicule est présenté chez le concessionnaire.

AbstractFactory Définit l'interface qui génère la classe AbstractProduct

Classe d'usine de fabrication de pièces automobiles

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 Une classe abstraite qui extrait les parties communes des parties générées

Classe de moteur

Engine.kt


package abstractfactory

open class Engine(displacement: Int) {
    open val type = "Moteur ordinaire"
    val displacement = displacement
}

Classe de pneu

Tire.kt


package abstractfactory

open class Tire(position: Int) {
    open val type = "Pneu ordinaire"
    val position = position
}

Classe de poignée

Steering.kt


package abstractfactory

class Steering(weight: Int) {
    val type = "Poignée ordinaire"
    val weight = weight
}

Classe de voiture

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  "[Type de véhicule]:" + type + "," +
                "【moteur】:" + engine.type + "," +
                "【pneu】:" + tire.type + "," +
                "【manipuler】:" + steering.type
    }
}

Utilisateur client

Classe de constructeur automobile

Maker.kt


package abstractfactory

class Maker {

    /**
     *Fabrication de voitures ordinaires
     */
    fun getCar(): Car {
        return make("Voiture familiale", CarFactory())
    }

    /**
     *Fabrication
     */
    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)
    }

}

Classe de concessionnaire automobile

AutomobileDealer.kt


package abstractfactory

class AutomobileDealer {

    val cars = mutableListOf<Car>()

    init {
        openingUp()
    }

    /**
     *Liste des voitures chez le concessionnaire
     */
    fun showCars() {
        cars.forEach {
            println(it.getConstitution())
        }
    }

    /**
     *Ouverture du magasin
     */
    private fun openingUp() {
        val maker = Maker()
        cars.add(maker.getCar())
    }
}

Résultat de sortie

Si vous appelez AutomobileDealer # showCars (), le véhicule affiché (spec) sera sorti.

[output]
[Type de véhicule]: Voiture familiale,[Engine]: moteur ordinaire,[Pneu]: pneu ordinaire,[Handle]: poignée ordinaire

Il a été complété par ce qui précède, mais soudain, le président a dit qu'il devrait construire une usine qui peut également fabriquer des pièces pour les super voitures sur la même ligne tout en conservant la ligne de production existante.

ConcreteFactory Définit l'interface qui génère la classe ConcreteProduct

Classe d'usine de fabrication de pièces de voiture Super

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)
    }
}

BétonProduit Pièces générées

Classe de moteur haute puissance

HiPerformanceEngine.kt


package abstractfactory

class HiPerformanceEngine(displacement: Int): Engine(displacement) {
    override val type = "Moteur haute puissance"
}

Classe de pneus haute adhérence

HiGripTire.kt


package abstractfactory

class HiGripTire(position: Int): Tire(position) {
    override val type = "Pneu haute adhérence"
}

Ajoutez une méthode de fabrication de super voiture au fabricant.

Utilisateur client

Classe de fabricant

Maker.kt


package abstractfactory

class Maker {

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

    /**
     *Fabrication de super voitures
     */
    fun getSuperCar(): Car {
        return make("Super voiture", SuperCarFactory())
    }

    /**
     *Fabrication
     */
    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)
    }

}

Le concessionnaire exige un nouveau véhicule (super voiture) du constructeur.

AutomobileDealer.kt


package abstractfactory

class AutomobileDealer {

    val cars = mutableListOf<Car>()

    init {
        openingUp()
    }

    /**
     *Liste des voitures chez le concessionnaire
     */
    fun showCars() {
        cars.forEach {
            println(it.getConstitution())
        }
    }

    /**
     *Ouverture du magasin
     */
    private fun openingUp() {
        val maker = Maker()
        cars.add(maker.getCar())
        cars.add(maker.getSuperCar())
        cars.add(maker.getSuperCar())
    }
}

Si vous appelez AutomobileDealer # showCars (), vous pouvez voir que les supercars sont nouvellement affichées.

Résultat de sortie

[output]
[Type de véhicule]: Voiture familiale,[Engine]: moteur ordinaire,[Pneu]: pneu ordinaire,[Handle]: poignée ordinaire
[Type de véhicule]: Super voiture,[Engine]: moteur haute puissance,[Pneu]: pneu à adhérence élevée,[Handle]: poignée ordinaire
[Type de véhicule]: Super voiture,[Engine]: moteur haute puissance,[Pneu]: pneu à adhérence élevée,[Handle]: poignée ordinaire

Avec ce qui précède, nous avons pu répondre à la demande du président.

Recommended Posts

[Gang of Four] Apprentissage des modèles de conception - Usine abstraite
[Gang of Four] Apprentissage des modèles de conception - Méthode d'usine
[Gang of Four] Apprentissage des modèles de conception
[Gang of Four] Apprentissage des modèles de conception --Singleton
[Gang of Four] Apprentissage des modèles de conception - Décorateur
[Gang of Four] Apprentissage des modèles de conception - Visiteur
[Gang of Four] Apprentissage des modèles de conception - Médiateur
[Gang of Four] Apprentissage des modèles de conception - Itérateur
[Gang of Four] Apprentissage des modèles de conception - Façade
[Gang of Four] Apprentissage des modèles de conception - Composite
[Gang of Four] Apprentissage des modèles de conception - Prototype
[Gang of Four] Apprentissage des modèles de conception --Mémento
[Gang of Four] Apprentissage des modèles de conception - État
[Gang of Four] Apprentissage des modèles de conception - Interprétation
[Gang of Four] Apprentissage des modèles de conception - Constructeur
[Gang of Four] Apprentissage des modèles de conception - Pont
[Gang of Four] Apprentissage des modèles de conception - Proxy
[Gang of Four] Apprentissage des modèles de conception - Stratégie
[Gang of Four] Apprentissage des modèles de conception - Adaptateur
[Gang of Four] Apprentissage des modèles de conception --Observer
[Gang of Four] Apprentissage des modèles de conception - Commande
[Gang of Four] Apprentissage des modèles de conception - Poids du vol
[Gang of Four] Apprentissage des modèles de conception - Chaîne de responsabilité
[Gang of Four] Apprentissage des modèles de conception - Méthode du modèle
Design Pattern #Factory, méthode
Apprenez le modèle de conception "Abstract Factory" avec Python
Modèles de conception à utiliser avec les bibliothèques Java fréquemment utilisées - Modèle abstrait Factory
Modèles Gang of Four (GoF) en Python
Apprentissage de la reconnaissance de formes en vidéo Partie 1 Champ de reconnaissance de formes
Apprenez le modèle de conception "Méthode d'usine" en Python
Modèle de conception #Builder
Modèle de conception #Adapter
Modèle de conception #Decorator
Modèle de conception #Observer
Modèle de conception #Facade
Modèle de conception #Strategy
Modèle de conception #Singleton
Modèle de conception #Proxy
J'ai écrit un modèle de conception dans l'édition Kotlin Factory
Apprenez le modèle de conception «Chaîne de responsabilité» en Python