Fabrique abstraite pour des familles de produits
Créez des familles d’objets associés, par exemple des composants d’interface par plateforme, avec Abstract Factory.
Fabrique abstraite pour des familles de produits est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.
L’intention de la fabrique abstraite
La fabrique abstraite fournit une interface pour créer des familles d’objets associés sans préciser leurs classes concrètes. Elle garantit que les produits issus d’une même fabrique sont compatibles.
Le problème : des familles de produits incohérentes
Sans fabrique abstraite, vous pourriez associer un bouton Windows à une case à cocher Mac. Le modèle impose que tous les produits proviennent de la même fabrique, ce qui garantit une cohérence visuelle ou comportementale.
Interface de la fabrique abstraite
Définissez une interface avec une méthode de création pour chaque produit de la famille. Chaque fabrique concrète implémente toutes les méthodes correspondant à une variante.
public interface UIFactory {
Button createButton();
Checkbox createCheckbox();
TextField createTextField();
}Fabriques concrètes
Chaque fabrique concrète crée tous les produits d’une plateforme ou d’un thème. Le code client ne fait référence qu’à l’interface, et non aux fabriques concrètes.
public class WindowsUIFactory implements UIFactory {
public Button createButton() { return new WindowsButton(); }
public Checkbox createCheckbox() { return new WindowsCheckbox(); }
public TextField createTextField() { return new WindowsTextField(); }
}
public class MacUIFactory implements UIFactory {
public Button createButton() { return new MacButton(); }
public Checkbox createCheckbox() { return new MacCheckbox(); }
public TextField createTextField() { return new MacTextField(); }
}Interfaces des produits abstraits
Chaque type de produit possède sa propre interface. Les produits concrets l’implémentent pour chaque plateforme. Le code client utilise le produit abstrait, et non le produit concret.
public interface Button { void render(); void onClick(); }
public interface Checkbox { void render(); boolean isChecked(); }
public interface TextField { void render(); String getValue(); }Client utilisant la fabrique
Le client reçoit une fabrique par l’intermédiaire de son constructeur. Il appelle les méthodes de la fabrique pour créer des composants graphiques et les utilise via des interfaces de produits abstraits — il est ainsi complètement découplé des classes concrètes.
public class Application {
private final UIFactory factory;
public Application(UIFactory factory) { this.factory = factory; }
public void buildUI() {
Button btn = factory.createButton();
Checkbox cb = factory.createCheckbox();
btn.render();
cb.render();
}
}Choisir la fabrique à l’exécution
Sélectionnez la fabrique concrète en fonction de l’environnement ou de la configuration, puis injectez-la. Le reste de l’application ne mentionne jamais les classes propres à la plateforme.
String os = System.getProperty("os.name").toLowerCase();
UIFactory factory = os.contains("mac") ? new MacUIFactory() : new WindowsUIFactory();
new Application(factory).buildUI();Ajouter un nouveau produit à la famille
Ajouter un nouveau produit (par exemple, Slider) exige de mettre à jour l’interface de la fabrique abstraite et toutes les fabriques concrètes — c’est un inconvénient du modèle.
public interface UIFactory {
Button createButton();
Checkbox createCheckbox();
Slider createSlider(); // new product — must update ALL factories
}Fabrique abstraite et méthode fabrique
La méthode fabrique crée un produit par héritage de sous-classes. La fabrique abstraite crée une suite de produits par composition. La fabrique abstraite est généralement implémentée à l’aide d’un ensemble de méthodes fabriques.
Fabrique abstraite pour les pilotes de bases de données
Une fabrique abstraite ConnectionFactory peut produire des objets Connection, Statement et ResultSet. Passez de MySQL à PostgreSQL en changeant de fabrique.
public interface DBFactory {
Connection createConnection();
Statement createStatement();
}
public class MySQLFactory implements DBFactory { ... }
public class PgFactory implements DBFactory { ... }Fabrique abstraite avec les profils Spring
Dans Spring Boot, définissez un bean UIFactory différemment pour chaque profil : l’application injecte toujours UIFactory, et Spring détermine la fabrique concrète appropriée pour le profil actif.
@Configuration
@Profile("mac")
public class MacConfig {
@Bean UIFactory uiFactory() { return new MacUIFactory(); }
}Garantir la cohérence
L’avantage essentiel est qu’une fabrique ne produit que des produits compatibles. Lorsque vous utilisez correctement la fabrique abstraite, vous ne pouvez jamais obtenir accidentellement une case à cocher Mac associée à un bouton Windows.
Vérification rapide
Que garantit la fabrique abstraite contrairement à la méthode fabrique ?
Récapitulatif
La fabrique abstraite crée des familles d’objets associés au moyen d’une interface commune. Vous pouvez remplacer des familles entières de produits en changeant de fabrique. Elle convient particulièrement lorsque les produits doivent être cohérents, mais ajoute une surcharge lors de l’ajout de nouveaux types de produits.
Questions Fréquemment Posées
La leçon « Fabrique abstraite pour des familles de produits » est-elle gratuite ?
Oui — le texte complet de « Fabrique abstraite pour des familles de produits » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Fabrique abstraite pour des familles de produits » ?
Créez des familles d’objets associés, par exemple des composants d’interface par plateforme, avec Abstract Factory. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Java Academy ?
Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Fabrique abstraite pour des familles de produits » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?
Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Singleton : implémentations sûres vis-à-vis des threads
- Modèle de méthode de fabrique
- Fabrique abstraite pour des familles de produits
- Modèle Builder avec API fluide