Hourra ! La version française est enfin sortie ! Laissez-nous un message svp, si vous voulez nous faire part de vos commentaires ou signaler une erreur.
Fabrique abstraite

Fabrique abstraite en Java

La Fabrique abstraite est un patron de conception de création qui permet de créer des familles de produits complètes sans avoir à préciser leurs classes concrètes.

La fabrique abstraite définit une interface pour la création de chaque produit, mais délègue la véritable création des produits aux classes concrètes de la fabrique. Chaque type de fabrique correspond à une certaine variété de produits.

Le code client appelle les méthodes de création d’un objet Fabrique plutôt que de créer directement les produits à l’aide d’un constructeur (opérateur new). Comme chaque fabrique possède sa propre variante de produit, tous ses produits seront compatibles.

Le code client manipule les fabriques et les produits uniquement via leurs interfaces abstraites, ce qui lui permet de travailler avec n’importe quelle variante de produit créée par un objet Fabrique. Créez juste une nouvelle classe concrète Fabrique et passez-la au code client.

Lisez notre Comparaison des fabriques si vous avez du mal à comprendre la différence entre les divers concepts et patrons.

Utilisation du patron de conception en Java

Complexité :

Popularité :

Exemples d’utilisation : Le patron fabrique abstraite est très répandu en Java. Il est utilisé dans de nombreux frameworks et bibliothèques afin d’étendre et de personnaliser leurs composants standards.

Voici quelques exemples tirés des bibliothèques principales de Java :

Identification : Ce patron est facile à identifier, car ses méthodes renvoient un objet Fabrique. De plus, la fabrique est utilisée pour créer des sous-composants spécifiques.

Les familles de composants GUI (interface graphique utilisateur) multiplateforme et leur fabrication

Dans cet exemple, les boutons et cases à cocher feront office de produits. Ils possèdent deux variantes : macOS et Windows.

La fabrique abstraite définit une interface pour la création des boutons et des cases à cocher. Deux fabriques concrètes retournent les deux produits d’une seule variante.

Le code client manipule les fabriques et les produits via leurs interfaces abstraites. Ainsi, le code client peut travailler avec plusieurs variantes de produits en fonction du type de l’objet Fabrique.

buttons: Première hiérarchie de produits

buttons/Button.java

package refactoring_guru.abstract_factory.example.buttons;

/**
 * Abstract Factory assumes that you have several families of products,
 * structured into separate class hierarchies (Button/Checkbox). All products of
 * the same family have the common interface.
 *
 * This is the common interface for buttons family.
 */
public interface Button {
    void paint();
}

buttons/MacOSButton.java

package refactoring_guru.abstract_factory.example.buttons;

/**
 * All products families have the same varieties (MacOS/Windows).
 *
 * This is a MacOS variant of a button.
 */
public class MacOSButton implements Button {

    @Override
    public void paint() {
        System.out.println("You have created MacOSButton.");
    }
}

buttons/WindowsButton.java

package refactoring_guru.abstract_factory.example.buttons;

/**
 * All products families have the same varieties (MacOS/Windows).
 *
 * This is another variant of a button.
 */
public class WindowsButton implements Button {

    @Override
    public void paint() {
        System.out.println("You have created WindowsButton.");
    }
}

checkboxes: Deuxième hiérarchie de produits

checkboxes/Checkbox.java

package refactoring_guru.abstract_factory.example.checkboxes;

/**
 * Checkboxes is the second product family. It has the same variants as buttons.
 */
public interface Checkbox {
    void paint();
}

checkboxes/MacOSCheckbox.java

package refactoring_guru.abstract_factory.example.checkboxes;

/**
 * All products families have the same varieties (MacOS/Windows).
 *
 * This is a variant of a checkbox.
 */
public class MacOSCheckbox implements Checkbox {

    @Override
    public void paint() {
        System.out.println("You have created MacOSCheckbox.");
    }
}

checkboxes/WindowsCheckbox.java

package refactoring_guru.abstract_factory.example.checkboxes;

/**
 * All products families have the same varieties (MacOS/Windows).
 *
 * This is another variant of a checkbox.
 */
public class WindowsCheckbox implements Checkbox {

    @Override
    public void paint() {
        System.out.println("You have created WindowsCheckbox.");
    }
}

factories

factories/GUIFactory.java: Fabrique abstraite

package refactoring_guru.abstract_factory.example.factories;

import refactoring_guru.abstract_factory.example.buttons.Button;
import refactoring_guru.abstract_factory.example.checkboxes.Checkbox;

/**
 * Abstract factory knows about all (abstract) product types.
 */
public interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

factories/MacOSFactory.java: Fabrique concrète (macOS)

package refactoring_guru.abstract_factory.example.factories;

import refactoring_guru.abstract_factory.example.buttons.Button;
import refactoring_guru.abstract_factory.example.buttons.MacOSButton;
import refactoring_guru.abstract_factory.example.checkboxes.Checkbox;
import refactoring_guru.abstract_factory.example.checkboxes.MacOSCheckbox;

/**
 * Each concrete factory extends basic factory and responsible for creating
 * products of a single variety.
 */
public class MacOSFactory implements GUIFactory {

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

    @Override
    public Checkbox createCheckbox() {
        return new MacOSCheckbox();
    }
}

factories/WindowsFactory.java: Fabrique concrète (Windows)

package refactoring_guru.abstract_factory.example.factories;

import refactoring_guru.abstract_factory.example.buttons.Button;
import refactoring_guru.abstract_factory.example.buttons.WindowsButton;
import refactoring_guru.abstract_factory.example.checkboxes.Checkbox;
import refactoring_guru.abstract_factory.example.checkboxes.WindowsCheckbox;

/**
 * Each concrete factory extends basic factory and responsible for creating
 * products of a single variety.
 */
public class WindowsFactory implements GUIFactory {

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

    @Override
    public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
}

app

app/Application.java: Code client

package refactoring_guru.abstract_factory.example.app;

import refactoring_guru.abstract_factory.example.buttons.Button;
import refactoring_guru.abstract_factory.example.checkboxes.Checkbox;
import refactoring_guru.abstract_factory.example.factories.GUIFactory;

/**
 * Factory users don't care which concrete factory they use since they work with
 * factories and products through abstract interfaces.
 */
public class Application {
    private Button button;
    private Checkbox checkbox;

    public Application(GUIFactory factory) {
        button = factory.createButton();
        checkbox = factory.createCheckbox();
    }

    public void paint() {
        button.paint();
        checkbox.paint();
    }
}

Demo.java: Configuration de l’application

package refactoring_guru.abstract_factory.example;

import refactoring_guru.abstract_factory.example.app.Application;
import refactoring_guru.abstract_factory.example.factories.GUIFactory;
import refactoring_guru.abstract_factory.example.factories.MacOSFactory;
import refactoring_guru.abstract_factory.example.factories.WindowsFactory;

/**
 * Demo class. Everything comes together here.
 */
public class Demo {

    /**
     * Application picks the factory type and creates it in run time (usually at
     * initialization stage), depending on the configuration or environment
     * variables.
     */
    private static Application configureApplication() {
        Application app;
        GUIFactory factory;
        String osName = System.getProperty("os.name").toLowerCase();
        if (osName.contains("mac")) {
            factory = new MacOSFactory();
            app = new Application(factory);
        } else {
            factory = new WindowsFactory();
            app = new Application(factory);
        }
        return app;
    }

    public static void main(String[] args) {
        Application app = configureApplication();
        app.paint();
    }
}

OutputDemo.txt: Résultat de l’exécution

You create WindowsButton.
You created WindowsCheckbox.

Fabrique abstraite dans les autres langues

Patrons de conception : Fabrique abstraite en C# Patrons de conception : Fabrique abstraite en C++ Patrons de conception : Fabrique abstraite en PHP Patrons de conception : Fabrique abstraite en Python Patrons de conception : Fabrique abstraite en Ruby Patrons de conception : Fabrique abstraite en Swift Patrons de conception : Fabrique abstraite en TypeScript Patrons de conception : Fabrique abstraite en Go