Dieser Artikel beschreibt das Werksmodell des Java -Designmusters. Teilen Sie es für Ihre Referenz wie folgt weiter:
1. Einfache Fabrik
Denken wir zuerst über eine Frage nach. Wenn wir Programme schreiben, wird es eine solche Situation geben. Objekt A muss die Methode von Objekt B aufrufen. Zu diesem Zeitpunkt verwenden wir normalerweise das neue Schlüsselwort, um eine Instanz B zu erstellen, und dann die Methode der Instanz B aufrufen. Der Nachteil dieses Ansatzes ist, dass die Methode der Klasse A direkt den Klassennamen der Klasse B aufruft (diese Methode wird auch als hartcodierte Kopplung bezeichnet). Sobald das System neu ausgerichtet werden muss: Wenn die Klasse C anstelle von Klasse B verwendet werden muss, muss das Programm den Code der Klasse A ändern. Wenn 100 oder 10.000 Klassen in der Anwendung hart codiert sind, müssen 100 oder 10.000 Orte geändert werden, was offensichtlich eine sehr schreckliche Sache ist.
Betrachtet man dieses Problem aus einer anderen Perspektive: Für ein Objekt bereits muss es nur die Methode des Objekts B aufrufen und sich nicht um die Implementierung und den Erstellungsprozess von Objekt B kümmern, um eine IB -Schnittstelle implementieren zu lassen, während die Klasse A nur mit der IB -Schnittstelle. BLASS -BLASS -BLASS -BLASS -BLASS -BLASS -SPLASS -SPASSPRAPT. Methode zum Aufrufen der IBFactory Factory, um IB -Instanzen zu erhalten. Über das obige Design: Wenn Sie die Klasse C anstelle von Klasse B verwenden müssen, müssen Sie die IB -Schnittstelle der Klasse C nur implementieren und den Implementierungscode umschreiben, um eine IB -Instanz in der IBFactory -Fabrik zu erstellen, damit die Fabrik eine C -Instanz generieren kann. Diese Entwurfsmethode zur Übergabe mehrerer Klassenobjekte an Werksklassen für die Generation wird als einfaches Fabrikmuster bezeichnet.
Hier ist der Code für ein einfaches Fabrikmuster:
/*** Einfacher Werksmodus* Gemeinsame Schnittstelle, die fabrikproduzierte Objektinstanzen erfordert* Friseurschnittstelle* @Author Administrator**/public interface hair {/*** Zeichnen Sie Frisur*/public void draw (); System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Righthair implementiert Haare {@Override public void draw () { System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Administrator * */public class hairtest {public static void main (String [] args) {hairfactory factory = new hairfactory ();Wie Sie sehen können, müssen Sie nur die Implementierung der Gethair -Methode im Haarfaktor ändern, wenn Sie den in Haartest erzeugten Linkshaar in Righthair ändern möchten.
Der Vorteil der Nutzung des einfachen Fabrikmodus besteht darin, dass der Objekt Anrufer und den Objekterstellungsprozess getrennt wird. Wenn der Objektanrufer ein Objekt benötigt, kann er es direkt aus der Fabrik anfordern und so vermeiden, dass der Objekt Anrufer und die Objektimplementierungsklasse hart codiert werden, um die Wartbarkeit und Skalierbarkeit des Systems zu verbessern. Natürlich hat das Fabrikmodell auch einen kleinen Fehler. Wenn das Produkt geändert wird, muss die Fabrikklasse auch entsprechend geändert werden. Hier können Sie das Richtlinienmodell verwenden, um es zu lösen. Das Folgende ist der Code.
öffentliche Schnittstelle Hairbuilder { / *** Machen Sie Frisur* @return* / public hair gethair ();} öffentliche Klasse Lefthairbuilder implementiert Haarbuilder {@Override public hair gethair () {return New Lefthair (); }} öffentliche Klasse RighthairBuilder implementiert Haarbuilder {@Override public hair gethair () {return New Righthair (); }} öffentliche Klasse 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 (); Haarbuilderbauer = neuer Righthairbuilder (); Haarfabrik fabrik = neuer Haarfaktor (Builder); Haarhaare = fabrik.gethair (); hair.draw (); }}Der Vorteil dieses Ansatzes besteht darin, dass es nicht mehr erforderlich ist, die Fabrikklasse zu ändern und die Erstellungslogik in der Fabrik nach verschiedenen Strategien abstrahieren. Welche Objekte müssen das Programm erstellen? Geben Sie einfach den entsprechenden Bauunternehmer in die Netzwerkfabrik weiter.
2. Fabrikmethode
Im einfachen Fabrikmodell verwendet das System die Fabrikklasse, um alle Produktinstanzen zu produzieren, und die Fabrikklasse entscheidet, welche Klasse von Instanzen zu produzieren ist, dh die Fabrikklasse ist für alle logischen Urteile, Instanzerstellung und andere Arbeiten verantwortlich.
Wenn Sie in der Fabrikklasse keine logischen Urteile fällen möchten, kann das Programm unterschiedliche Fabriken für verschiedene Produktkategorien bereitstellen, und verschiedene Fabrikklassen produzieren verschiedene Produkte, ohne komplexe logische Urteile in der Fabrikklasse zu fällen. Dies ähnelt dem einfachen Fabrikmodell in Kombination mit dem obigen Strategiemodell. Der Unterschied besteht darin, dass Ersteres nur eine Fabrik hat, während letztere mehrere Fabriken benötigt. Im Folgenden finden Sie den Code für das Factory -Methodenmuster.
/*** Factory -Methodenmuster* Gemeinsame Schnittstelle, die durch Objektinstanzen implementiert werden müssen, die von der Fabrik erstellt wurden System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @author administrator * */public class factory implements personfactory WomenFactory () person = factory.getPerson ();Das typische Merkmal dieser Art ist, dass sie seine entsprechenden Produkte gemäß verschiedenen Fabriken im Client -Code erzeugt, und es besteht nicht erforderlich, die gesamte komplexe Logik in die Fabrikklasse zu stecken, um sie zu beurteilen. In dieser Implementierung gibt es einen offensichtlichen Fehler, nämlich dass der Client mit der Fabrikklasse verbunden ist.
3.. Zusammenfassung Fabrik
Unter Verwendung der obigen Designarchitektur der Fabrikmethode wird der Client -Code erfolgreich von der Implementierungsklasse des aufgerufenen Objekts getrennt, bringt jedoch eine weitere Kopplung mit sich: Der Clientcode ist mit verschiedenen Fabrikklassen verbunden. Um dieses Kupplungsproblem zu lösen, sollten Sie eine Fabrikklasse hinzufügen, um Fabrikinstanzen zu generieren und die Fabrik vom Kunden zur Herstellung von Produkten zu trennen. Diese Entwurfsmethode wird als abstraktes Fabrikmodell bezeichnet. Unten finden Sie den Code für abstraktes Fabrikmuster
/*** Abstract Factory Muster* Fabrikproduktionspersonfaktor } else {return New WomenFactory (); }}}/** * Client -Testklasse * @Author Administrator * */öffentliche Klasse Persontest {public static void main (String [] args) {Personfactory factory = personFactoryFactory.getPersonFactory ("Man"); Person Person = factory.getPerson (); Person.Drawperson (); }}Für mehr Java-bezogene Inhalte können Leser, die an dieser Website interessiert sind, die Themen anzeigen: "Java-Datenstruktur und Algorithmus-Tutorial", "Zusammenfassung der Java-Operation DOM-Knoten-Tipps", "Zusammenfassung der Java-Datei- und Verzeichnisoperationstipps" und "Zusammenfassung von Java Cache Operation Tipps" "
Ich hoffe, dieser Artikel wird für Java -Programme aller hilfreich sein.