1. Übersicht
Insgesamt sind Designmuster in drei Kategorien unterteilt:
(1) Kreativer Modus , insgesamt fünf Typen: Factory Method -Modus, abstrakter Werksmodus, Singleton -Modus, Builder -Modus und Prototypenmodus.
(2) Strukturmodi , insgesamt sieben Typen: Adaptermodus, Dekorationsmodus, Proxy -Modus, Aussehensmodus, Brückenmodus, Kombinationsmodus und Genussmodus.
(3) Verhaltensmodus , insgesamt elf: Richtlinienmodus, Vorlagenmethodenmodus, Beobachtermodus, iterativer Untermodus, Verantwortungskettenmodus, Befehlsmodus, Memo-Modus, Statusmodus, Besuchermodus, Zwischenmodus und Interpreter-Modus.
2. Sechs Prinzipien des Designmodells
1. Open Close -Prinzip
Das Prinzip des Öffnens und Schließens besteht darin, Verlängerungen und nahe an Modifikationen zu öffnen. Wenn das Programm erweitert werden muss, können Sie den ursprünglichen Code nicht ändern, um einen Hot -Plug -Effekt zu erzielen.
2. Prinzip der Sukokov -Substitution
Die offizielle Beschreibung ist relativ abstrakt und kann in Baidu verwendet werden. Tatsächlich kann wie folgt verstanden werden: (1) Die Fähigkeit einer Unterklasse muss größer oder gleich der übergeordneten Klasse sein, dh die Methoden, die die übergeordnete Klasse verwenden kann, und die Unterklasse kann verwenden. (2) Das Gleiche gilt für den Rückgabewert. Angenommen, eine übergeordnete Klassenmethode gibt eine Liste zurück und eine Unterklasse gibt eine ArrayList zurück, die natürlich erledigt werden kann. Wenn die übergeordnete Klassenmethode eine ArrayList zurückgibt und die untergeordnete Klasse eine Liste zurückgibt, ist dies nicht sinnvoll. Hier ist die Fähigkeit der Unterklassen, Werte zurückzugeben, kleiner als die von übergeordneten Klassen. (3) Es gibt auch Fälle, in denen Ausnahmen geworfen werden. Jede Unterklasse -Methode kann eine Unterklasse deklarieren, die die übergeordnete Klassenmethode einsetzt, um eine Ausnahme zu deklarieren.
Es kann nicht erklären, dass die Ausnahme, die die übergeordnete Klasse nicht erklärt hat, geworfen wird.
3. Abhängigkeitsinversionsprinzip
Dies ist die Grundlage für das Prinzip des Öffnens und Schließens sowie der spezifische Inhalt: interface-orientierte Programmierung, die sich eher auf Abstraktion als konkret stützt.
4. Prinzip der Schnittstellensegregation
Dieses Prinzip bedeutet: Die Verwendung mehrerer isolierter Schnittstellen ist besser als die Verwendung einer einzelnen Schnittstelle. Es bedeutet auch, den Kopplungsgrad zwischen Klassen zu reduzieren. Von hier aus können wir erkennen, dass das Designmuster tatsächlich die Designidee einer Software ist, die von einer großen Softwarearchitektur ausgeht, um das Upgrade und die Wartung zu bequem zu machen. Daher ist der obige Artikel viele Male erschienen: Reduzieren Sie die Abhängigkeit und reduzieren Sie die Kopplung.
5. Demeter Prinzip
Warum ist das Prinzip des geringsten Wissens? Das heißt, eine Entität sollte so wenig wie möglich mit anderen Einheiten interagieren, damit die Systemfunktionsmodule relativ unabhängig sind.
6. Prinzip der Zusammensetzung der Wiederverwendung
Das Prinzip besteht darin, zu versuchen, Synthese-/Aggregationsmethoden als die Vererbung zu verwenden.
3. Erstellungsmodus
Es gibt fünf Arten von Erstellungsmodi: Factory Method -Modus, abstrakter Werksmodus, Singleton -Modus, Builder -Modus und Prototypmodus.
3.1. Fabrikmethodemodell
Der Factory -Methodenmodus ist in drei Typen unterteilt: der gewöhnliche Werksmodus, der multiple Werksmethodenmodus und den statischen Fabrikmethodenmodus.
3.1.1. Gewöhnliches Fabrikmodell
Das gewöhnliche Fabrikmodell besteht darin, eine Fabrikklasse einzurichten und Instanzen einiger Klassen zu erstellen, die dieselbe Schnittstelle implementieren.
Paket com.mode.create; öffentliche Schnittstelle MyInterface {public void print ();} Paket com.mode.create; öffentliche Klasse MyClassOne implementiert myInterface {@Override public void print () {System.out.println ("myclassOne"); }} Paket com.mode.create; öffentliche Klasse myclasstwo implementiert myInterface {@Override public void print () {System.out.println ("myclasstwo"); }} Paket com.mode.create; öffentliche Klasse myFactory {public myInterface produzieren (String -Typ) {if ("eins" .Equals (Typ)) {return New MyClassOne (); } else if ("zwei" .Equals (Typ)) {return New Myclasstwo (); } else {System.out.println ("kein Typ zu finden"); null zurückkehren; }}} Paket com.mode.create; public class factoryTest {public static void main (String [] args) {myfactory factory = new myFactory (); MyInterface myi = factory.produce ("eins"); myi.print (); }}Ich denke, die Ergebnisse der Fabriktest sollten offensichtlich sein.
Lassen Sie uns diesen Satz erneut verstehen: Das gewöhnliche Fabrikmodell besteht darin, eine Fabrikklasse festzulegen und Instanzen einiger Klassen zu erstellen, die dieselbe Schnittstelle implementieren.
3.1.2. Mehrere Fabrikmethodenmodi
Mehrere Fabrikmethodenmodi sind eine Verbesserung des normalen Fabrikmethodenmodus. Mehrere Fabrikmethodenmodi sollen mehrere Werksmethoden bereitstellen, um Objekte separat zu erstellen.
Schauen wir uns den Code direkt an. Wir ändern MyFactory und FactoryTest wie folgt:
Paket com.mode.create; public class myFactory {public myInterface processOne () {return New MyClassOne (); } public myInterface protoTETWO () {return New myclasstwo (); }} Paket com.mode.create; public class factoryTest {public static void main (String [] args) {myfactory factory = new myFactory (); MyInterface myi = factory.produceone (); myi.print (); }}Die Betriebsergebnisse sind ebenfalls sehr offensichtlich.
Lassen Sie uns diesen Satz erneut verstehen: Mehrere Fabrikmethodenmodi sind eine Verbesserung des ordentlichen Fabrikmethodenmodus. Mehrere Fabrikmethodenmodi sollen mehrere Werksmethoden bereitstellen, um Objekte separat zu erstellen.
3.1.3. Statische Fabrikmethodemodus
Statische Fabrikmethodenmodus, setzen Sie die Methoden in den oben genannten Methodenmodi mit mehreren Fabrikmethoden auf statisch, und es müssen keine Instanz erstellt werden. Rufen Sie sie einfach direkt auf.
Schauen wir uns den Code direkt an. Wir ändern MyFactory und FactoryTest wie folgt:
Paket com.mode.create; öffentliche Klasse myfactory {public static myInterface processOne () {return New MyClassOne (); } public static myInterface productetwo () {return New myclasstwo (); }} Paket com.mode.create; public class factoryTest {public static void main (String [] args) {myInterface myi = myfactory.produceOne (); myi.print (); }}Die Ergebnisse der Operation sind immer noch sehr offensichtlich.
Überprüfen Sie erneut: Static Factory Method -Modus, setzen Sie die Methoden in den oben genannten Methodenmodi in mehreren Werksmethoden auf statisch, und es besteht keine Notwendigkeit, eine Instanz zu erstellen. Rufen Sie sie einfach direkt auf.
3.2. Abstraktes Fabrikmuster
Es gibt ein Problem mit dem Factory -Methode -Modell, dass die Erstellung der Klassen von den Fabrikklassen abhängt. Wenn Sie das Programm erweitern möchten, müssen Sie die Fabrikklasse ändern, die gegen das Verschlussprinzip verstößt.
Um dieses Problem zu lösen, werfen wir einen Blick auf das abstrakte Werksmuster: Erstellen Sie mehrere Werksklassen, damit Sie, sobald neue Funktionen benötigt werden, neue Fabrikklassen direkt hinzufügen können, ohne den vorherigen Code zu ändern.
Dies entspricht dem Schließungsprinzip.
Schauen wir uns den folgenden Code an:
MyInterface, MyClasson, Myclasstwo bleibt unverändert.
Die folgenden Schnittstellen und Klassen werden hinzugefügt:
Paket com.mode.create; public interface Anbieter {public myInterface produc (); } paket com.mode.create; öffentliche Klasse myFactoryOne implementiert Anbieter {@Override public myInterface Produc () {return New MyClassOne (); }} paket com.mode.create; öffentliche Klasse myFactoryTwo implementiert Anbieter {@Override public myInterface proced () {neuer myclasstwo () zurückgeben; }}Ändern Sie den Testklassenfabriktest wie folgt:
Paket com.mode.create; public class FactoryTest {public static void main (String [] args) {Provider Provider = new MyFactoryOne (); MyInterface myi = provider.produce (); myi.print (); }}Die Betriebsergebnisse sind noch offensichtlich.
Überprüfen Sie erneut: Das abstrakte Fabrikmuster besteht darin, mehrere Werksklassen zu erstellen, sodass Sie neue Werksklassen direkt hinzufügen können, ohne den vorherigen Code zu ändern.
3.3. Singleton -Modus
Singleton -Muster, keine Notwendigkeit für zu viel Erklärung.
Schauen Sie sich einfach den Code an:
Pakettest; public class myObject {private static myObject myObject; private myObject () {} public static myObject getInstance () {if (myObject! = null) {} else {myObject = new myObject (); } myObject zurückgeben; }}Dies führt jedoch zu Problemen mit Multi-Threading. Für eine detaillierte Erklärung finden Sie Kapitel 6 im Buch "Core Technology of Java Multi-Threading-Programmierung".
3.4. Builder -Modus
Builder Muster: soll die Konstruktion eines komplexen Objekts von seiner Darstellung trennen, damit der gleiche Konstruktionsprozess unterschiedliche Darstellungen erzeugen kann.
Es sieht wörtlich sehr abstrakt aus, aber tatsächlich ist es auch sehr abstrakt! ! ! !
Der Builder -Modus enthält normalerweise die folgenden Zeichen:
(1) Builder: Geben Sie eine abstrakte Schnittstelle zur Standardisierung der Konstruktion verschiedener Komponenten des Produktobjekts. Diese Schnittstelle gibt an, welche Teile komplexer Objekte erstellt werden, und beinhaltet nicht die Erstellung spezifischer Objektkomponenten.
(2) Concretebuilder: Implementiert die Builder -Schnittstelle und definiert die Erstellung verschiedener Teile komplexer Objekte für verschiedene Geschäftslogik. Nach Abschluss des Bauprozesses wird ein Beispiel für das Produkt bereitgestellt.
(3) Direktor: Ruft spezifische Bauherren auf, um verschiedene Teile komplexer Objekte zu erstellen. Der Ausbilder beinhaltet keine spezifischen Produktinformationen, ist jedoch nur dafür verantwortlich, dass alle Teile des Objekts intakt oder in einer bestimmten Reihenfolge erstellt werden.
(4) Produkt: Das zu erstellende komplexe Objekt.
Es ist üblich, Bösewichte in der Spieleentwicklung zu bauen, und die Anforderung ist: Bösewichte müssen Kopf, Körper und Füße umfassen.
Schauen wir uns den folgenden Code an:
Produkt (komplexes Objekt zu erstellen.):
Paket com.mode.create; public class Person {private String Head; private Saitenkörper; privater Stringfuß; public String gethead () {return head; } public void Sethead (String Head) {this.head = head; } public String getBody () {return body; } public void setbody (String body) {this.body = body; } public String getfoot () {return foot; } public void setfoot (String foot) {this.foot = foot; }} Builder (gibt eine abstrakte Schnittstelle zur Standardisierung der Konstruktion verschiedener Komponenten eines Produktobjekts. Diese Schnittstelle gibt an, welche Teile eines komplexen Objekts implementiert werden sollen, und beinhaltet nicht die Erstellung spezifischer Objektkomponenten.):):
Paket com.mode.create; public interface Personbuilder {void Buildhead (); void BuildBody (); void Buildfoot (); Person Buildperson ();} Concretebuilder (implementiert die Builder -Schnittstelle, die die Erstellung verschiedener Teile komplexer Objekte für verschiedene Geschäftslogik verkörpert. Nach Abschluss des Konstruktionsprozesses geben Sie ein Beispiel für das Produkt an.):):
Paket com.mode.create; öffentliche Klasse Manbuilder implementiert Personbuilder {Person Person; Public Manbuilder () {Person = new Person (); } public void BuildBody () {Person.setBody ("Bauen Sie den Körper des Mannes"); } public void Buildfoot () {Person.Setfoot ("Bauen Sie die Füße des Mannes"); } public void Buildhead () {Person.sethead ("Bauen Sie den Kopf des Mannes"); } public person Buildperson () {return person; }} Direktor (Rufen Sie den spezifischen Bauherr an, um verschiedene Teile komplexer Objekte zu erstellen. Der Ausbilder beinhaltet keine spezifischen Produktinformationen. Es ist nur dafür verantwortlich, dass die Teile des Objekts intakt oder in einer bestimmten Reihenfolge erstellt werden.):
Paket com.mode.create; public class persondirector {public person constructperson (Personbuilder pb) {pb.buildhead (); pb.buildbody (); pb.buildfoot (); return pb.buildperson (); }} Testklasse:
Paket com.mode.create; public class test {public static void main (String [] args) {PERTIRECRECTOR PD = New PERONDirector (); Person Person = pd.constructperson (New Manbuilder ()); System.out.println (person.getBody ()); System.out.println (person.getfoot ()); System.out.println (Person.Gethead ()); }}Auslaufergebnisse:
Übersicht: Builder Muster: soll die Konstruktion eines komplexen Objekts von seiner Darstellung trennen, damit der gleiche Konstruktionsprozess unterschiedliche Darstellungen erzeugen kann.
3.5. Prototypmodus
Die Idee dieses Musters besteht darin, ein Objekt als Prototyp zu verwenden, es zu kopieren und zu klonen und ein neues Objekt zu erzeugen, das dem ursprünglichen Objekt ähnelt.
Apropos Kopieren von Objekten, ich werde in Kombination mit flachem Kopieren und tiefem Kopieren von Objekten darüber sprechen. Zunächst müssen Sie das Konzept des tiefen und flachen Kopierens von Objekten verstehen:
Flache Kopie: Nach dem Kopieren eines Objekts werden Variablen des Basistyps nachgebildet, während der Referenztyp auf das ursprüngliche Objekt zeigt.
Deep Copy: Nach dem Kopieren eines Objekts werden sowohl der grundlegende Datentyp als auch der Referenztyp nachgebildet. Einfach ausgedrückt wird ein tiefes Kopieren vollständig kopiert, während das flache Kopieren nicht gründlich ist.
Schreiben Sie ein Beispiel für das Kopieren der Tiefe:
Paket com.mode.create; Import Java.io.BytearrayInputStream; Import Java.io.BytearrayoutputStream; Import Java.io.ioxception; Import Java.io.objectinputStream; Import Java.io.objectputStream; Import Java.io.ioSserializable; Prototypen im öffentlichen Klassen implementiert klonable, serialisierbare {private statische endgültige lange Serialversionuid = 1L; private Int -Basis; Private Ganzzahl obj; /* flache Kopie*/ öffentliches Objekt Clone () löscht ClonenotsUsporteedException (// Da die klonbare Schnittstelle eine leere Schnittstelle ist, können Sie den Methodennamen der Implementierungsklasse nach Will // wie Clonea oder CloneB definieren, da der Fokus hier der Satz Super.clone () // Super.clone () -Shorte -Madhoy () -Methode (). Proto = (Prototyp) Super.clone (); Proto zurückgeben; } /* Deep Copy* / public Object DeepClone () löst ioException, classNotFoundException { /* Schreiben Sie den binären Stream an das aktuelle Objekt* / bytearrayoutputStream bos = new bytearrayoutputStream (); ObjectOutputStream OOS = New ObjectOutputStream (BOS); oos.writeObject (this); /* Lesen Sie das neue Objekt vor, das vom binären Stream erzeugt wird ObjectInputStream OIS = New ObjectInputStream (BIS); return ois.readObject (); } public int getbase () {return base; } public void setBase (int base) {this.base = base; } public Integer getObj () {return obj; } public void setObj (Ganzzahl obj) {this.obj = obj; }} Testklasse:
Paket com.mode.create; importieren java.io.ioException; public class test {public static void main (String [] args) löscht Clonenotsupportededexception, classNotFoundException, ioException {prototype prototype = new prototype (); Prototyp.SetBase (1); prototype.setObj (New Integer (2)); /* flache Kopie*/ Prototyp Prototype1 = (Prototyp) prototype.clone (); /* Deep Copy*/ Prototype Prototype2 = (Prototyp) Prototype.DeepClone (); System.out.println (prototyp1.getObj () == prototype1.getObj ()); System.out.println (prototyp1.getObj () == prototype2.getObj ()); }}Auslaufergebnisse:
Das Obige dreht sich alles um diesen Artikel, ich hoffe, es wird für das Lernen aller hilfreich sein.