Modèle d'usine abstrait

Qu’est-ce que le modèle d’usine abstrait ?

Abstract Factory Pattern est un modèle de création qui fournit une interface pour créer des familles d'objets liés ou dépendants sans spécifier leurs classes concrètes.

Quand l'utiliser ?

Utilisez le modèle d'usine abstrait lorsque vous avez des familles d'objets dans lesquelles les objets d'une même famille sont censés travailler ensemble, tout en souhaitant dissocier les produits en béton et leurs usines du code client.

Problème

Nous prévoyons de développer une application thématique simple permettant au client de choisir une interface utilisateur claire ou sombre en fonction de ses préférences. Nous préparons trois composants Bouton, Menu et Barre d'outils. Chaque composant a des apparences de style clair et sombre.
Évidemment, nous voulons nous assurer que tous les composants du thème clair fonctionnent ensemble (nous ne voulons pas afficher le bouton clair, le menu sombre et la barre d'outils claire en même temps). De plus, nous souhaitons conserver la possibilité d'ajouter d'autres thèmes à l'avenir, tels que le thème "Contraste élevé".

Solution

1. ApplicationThème
   C'est notre client. Le constructeur reçoit la fabrique concrète comme argument, puis createComponents() créera les composants correspondants. Le client dépend uniquement d'une usine abstraite et de produits abstraits.

2. ThèmeFactory
   Une interface pour toutes les thématiques concrètes.

3. Usines à thèmes en béton
   Fournit une implémentation réelle des méthodes de ThemeFactory. Ces usines à béton créent des produits en béton.

4. Interfaces produits
   Interfaces pour composants.

5. Produits en béton
   Définit un comportement spécifique.

Structure

Implémentation en Java

public interface Button {

    void render();
}

public class DarkButton implements Button{

    @Override
    public void render() {
        System.out.println("Successfully render a dark button");
    }
}

public class LightButton implements Button {

    @Override
    public void render() {
        System.out.println("Successfully render a light button");
    }
}

Vous pouvez écrire le code des composants Menu et Barre d'outils de la même manière.

public interface ThemeFactory {

    Button createButton();

    Menu createMenu();

    Toolbar createToolbar();
}

public class DarkThemeFactory implements ThemeFactory {

    @Override
    public Button createButton() {
        return new DarkButton();
    }

    @Override
    public Menu createMenu() {
        return new DarkMenu();
    }

    @Override
    public Toolbar createToolbar() {
        return new DarkToolbar();
    }
}

public class LightThemeFactory implements ThemeFactory {

    @Override
    public Button createButton() {
        return new LightButton();
    }

    @Override
    public Menu createMenu() {
        return new LightMenu();
    }

    @Override
    public Toolbar createToolbar() {
        return new LightToolbar();
    }
}

// This is our client code, notice client sees neither concrete products nor concrete factories
public class ThemeApplication {

    private ThemeFactory themeFactory;
    private Button button;
    private Menu menu;
    private Toolbar toolbar;

    public ThemeApplication(ThemeFactory factory) {
        themeFactory = factory;
        createComponents();
    }

    public void createComponents() {
        button = themeFactory.createButton();
        menu = themeFactory.createMenu();
        toolbar = themeFactory.createToolbar();
    }

    public void renderComponents() {
        button.render();
        menu.render();
        toolbar.render();
    }
}

public class ThemeApplicationTestDrive {

    public static void main (String[] args) {
        ThemeFactory darkFactory = new DarkThemeFactory();
        ThemeApplication app1 = new ThemeApplication(darkFactory);
        app1.renderComponents();
        System.out.println("*******************");

        ThemeFactory lightFactory = new LightThemeFactory();
        ThemeApplication app2 = new ThemeApplication(lightFactory);
        app2.renderComponents();
    }
}

Sortie :

Successfully render a dark button
Successfully render a dark menu
Successfully render a dark toolbar
*******************
Successfully render a light button
Successfully render a light menu
Successfully render a light toolbar

Pièges

• Plus complexe à mettre en œuvre qu'un modèle d'usine.
• L'ajout d'un nouveau produit nécessite des changements à la fois dans l'usine abstraite et dans les usines à béton.

Comparaison avec le modèle d'usine

• Le modèle d'usine dissocie les produits en béton du code client, tandis que le modèle d'usine abstrait masque les usines en béton ainsi que les produits en béton.
• Le modèle d'usine fonctionne avec un produit et ses sous-classes. En revanche, le modèle d'usine abstrait convient lorsque plusieurs produits doivent fonctionner ensemble.

---

Vous pouvez consulter toutes les implémentations de modèles de conception ici.
Dépôt GitHub

---

P.S.
Je suis nouveau dans l'écriture d'un blog technique, si vous avez des conseils pour améliorer mon écriture ou si vous avez un point déroutant, veuillez laisser un commentaire !
Merci d'avoir lu :)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!