Cet article décrit le modèle d'usine du modèle de conception Java. Partagez-le pour votre référence, comme suit:
1. Usine simple
Réfléchissons d'abord à une question. Lorsque nous écrivons des programmes, il y aura une telle situation. L'objet A doit appeler la méthode de l'objet B. Pour le moment, nous utilisons généralement le nouveau mot-clé pour créer une instance B, puis appelez la méthode d'instance B. L'inconvénient de cette approche est que la méthode de la classe A appelle directement le nom de classe de la classe B (cette méthode est également appelée couplage codé dur). Une fois que le système doit être refactorisé: lorsque la classe C doit être utilisée à la place de la classe B, le programme doit modifier le code de classe A. Si 100 ou 10 000 classes dans l'application sont codées, 100 ou 10 000 places doivent être modifiées, ce qui est évidemment une chose très terrible.
En regardant ce problème sous une autre perspective: pour un objet déjà A, il n'a qu'à appeler la méthode de l'objet B, et ne se soucie pas du processus d'implémentation et de création de l'objet B, envisagez de laisser la classe B implémenter une interface IB, tandis que la classe A doit uniquement être couplée à l'interface IB - la classe A n'utilise pas directement le mot-clé pour créer des instances B, mais redéfinit une méthode d'usine: IBFACTOR d'appeler l'usine IBFactory pour obtenir des instances IB. Grâce à la conception ci-dessus: si vous avez besoin d'utiliser la classe C au lieu de la classe B, vous n'avez qu'à laisser la classe C implémenter l'interface IB et réécrire le code d'implémentation pour créer une instance IB dans l'usine IBFactory, afin que l'usine puisse générer une instance C. Cette méthode de conception pour remettre plusieurs objets de classe aux classes d'usine pour la génération est appelée le modèle d'usine simple.
Voici le code pour un modèle d'usine simple:
/ ** * Mode d'usine simple * Interface commune qui nécessite des instances d'objets produites en usine * Interface de style cheveux * @Author Administrator * * / interface publique Hair {/ ** * Draw Hairstyle * / public void Draw ();} / ** * gauche de la coiffure latérale * @Override Administrator * * / public class lefthail implémente les cheveux {@Override public draw () {) System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Righthair implémente les cheveux {@Override public void draw () { System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Administrateur * * / public class Hairtest {public static void Main (String [] args) {Hairfactory Factory = New Hairfactory ();Comme vous pouvez le voir, si vous voulez changer le gaucher généré dans Hairtest to Righthair, il vous suffit de modifier la mise en œuvre de la méthode Gethair dans HairFactory.
L'avantage de l'utilisation du mode d'usine simple est qu'il sépare l'appelant d'objet et le processus de création d'objet. Lorsque l'appelant d'objet a besoin d'un objet, il peut le demander directement à l'usine, évitant ainsi l'appelant d'objet et la classe d'implémentation d'objet couplée de manière dure pour améliorer la maintenabilité et l'évolutivité du système. Bien sûr, le modèle d'usine a également un petit défaut. Lorsque le produit est modifié, la classe d'usine doit également être modifiée en conséquence. Ici, vous pouvez utiliser le modèle de stratégie pour le résoudre. Ce qui suit est le code.
Interface publique Hairbuilder {/ ** * faire coiffure * @return * / public hair gethair ();} public class Lefthairbuilder implémente Hairbuilder {@Override public hair gethair () {return new lefthair (); }} classe publique RighthairBuilder implémente Hairbuilder {@Override public hair gethair () {return new Righthair (); }} public class hairfactory {private hairbuilder hairbuilder; Public HairFactory (Hairbuilder Hairbuilder) {this.hairbuilder = Hairbuilder; } public void Sethairbuilder (Hairbuilder Hairbuilder) {this.hairbuilder = Hairbuilder; } public Hair Gethair () {return hairbuilder.gethair (); }} public class hairtest {public static void main (String [] args) {// hairbuilder builder = new lefthairbuilder (); Hairbuilder Builder = New RighthairBuilder (); Hairfactory Factory = New HairFactory (constructeur); Hair Hair = Factory.Gethair (); Hair.Draw (); }}L'avantage de cette approche est qu'il n'est plus nécessaire de modifier la classe d'usine et de résumer la logique de création dans l'usine selon différentes stratégies. Quels objets le programme a-t-il besoin pour créer? Passez simplement le constructeur correspondant dans l'usine de réseau.
2. Méthode d'usine
Dans le modèle d'usine simple, le système utilise la classe d'usine pour produire toutes les instances de produit, et la classe d'usine décide de quelle classe d'instances à produire, c'est-à-dire que la classe d'usine est responsable de tous les jugements logiques, de la création d'instances et d'autres travaux.
Si vous ne voulez pas faire de jugements logiques dans la classe d'usine, le programme peut fournir différentes usines pour différentes catégories de produits et différentes classes d'usine produisent différents produits, sans porter de jugements logiques complexes dans la classe d'usine. Ceci est un peu similaire au modèle d'usine simple combiné avec le modèle de stratégie ci-dessus. La différence est que le premier n'a qu'une seule usine, tandis que le second nécessite plusieurs usines. Vous trouverez ci-dessous le code du modèle de méthode d'usine.
/ ** * Modèle de la méthode d'usine * Interface commune à implémenter par les instances d'objet produites par l'usine * @author Administrator * * / public interface personne {public void drawPerson ();} public class man implémente la personne {@Override public void drawperson () {{ System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @Author Administrator * * / public class WomenFactory implémente Personfactory {@Override Public Person GetPerson () {RETOUR WomenFactory (); personne Personne = Factory.getSerson ();La caractéristique typique de ce type est qu'elle produit ses produits correspondants selon différentes usines du code client, et il n'est pas nécessaire de mettre toute la logique complexe dans la classe d'usine à juger. Il y a une faille évidente dans cette implémentation, à savoir que le client est couplé à la classe d'usine.
3. Factory abstraite
En utilisant l'architecture de conception ci-dessus de la méthode d'usine, le code client est séparé avec succès de la classe d'implémentation de l'objet appelé, mais il apporte un autre couplage: le code client est couplé à différentes classes d'usine. Pour résoudre ce problème de couplage, envisagez d'ajouter une classe d'usine pour générer des instances d'usine et séparer l'usine du client pour produire des produits. Cette méthode de conception est appelée modèle d'usine abstrait. Vous trouverez ci-dessous le code pour le modèle d'usine abstrait
/ ** * Résumé Modèle d'usine * Factory Produisant PersonFactory * @Author Administrator * * / public class PersonFactoryFactory {public static personFactory getSersonFactory (String Type) {if (type.equalsignoreCase ("man")) {return new ManFactory (); } else {return new WomenFactory (); }}} / ** * Classe de test client * @Author Administrator * * / public class PersonTest {public static void main (String [] args) {PersonFactory Factory = PersonfactoryFactory.getPersonFactory ("man"); Personne personne = factory.getSerson (); Person.Drawperson (); }}Pour plus de contenu lié à Java, les lecteurs qui sont intéressés par ce site peuvent afficher les sujets: "Tutoriel de structure de données Java et d'algorithme", "Résumé des conseils de nœud de Dom Operation Java", "Résumé du fichier Java et des conseils d'opération de répertoire" et "Résumé des conseils d'opération Java Cache"
J'espère que cet article sera utile à la programmation Java de tous.