Überblick über die 23 Entwurfsmuster und 6 wichtigsten Entwurfsmusterprinzipien von Java

Analyse von 23 Designmustern in Java

1. Übersicht über Designmuster

Im Allgemeinen werden Designmuster in drei Kategorien unterteilt :

Es gibt fünf kreative Muster: Fabrikmethodenmuster, abstraktes Fabrikmuster, Singleton-Muster, Builder-Muster und Prototypmuster.

Es gibt sieben Strukturmodi: Adaptermodus, Dekoratormodus, Proxy-Modus, Erscheinungsmodus, Bridge-Modus, Kombinationsmodus und Fliegengewichtsmodus.

Verhaltensmuster, insgesamt elf: Strategiemuster, Vorlagenmethodenmuster, Beobachtermuster, iteratives Untermuster, Verantwortungskettenmuster, Befehlsmuster, Memomuster, Zustandsmuster, Besuchermuster, Vermittlermuster, Dolmetschermodus.

Die Einzelheiten sind wie folgt:

Die Erstellungstypen sind:

1 Singleton, Singleton-Modus: Stellen Sie sicher, dass eine Klasse nur eine Instanz hat und stellen Sie eine bereit Zugriffsmethode darauf Globaler Zugriff

Punkt

2. Abstract Factory: Bietet eine Schnittstelle zum Erstellen einer Reihe verwandter oder voneinander abhängiger Objekte,

ohne Angabe ihrer konkreten Klassen.

3. Factory-Methode: Definieren Sie eine Schnittstelle zum Erstellen von Objekten und lassen Sie Unterklassen entscheiden, welche Klasse instanziiert werden soll, bis die Art der Unterklasse vorliegt.

4. Builder, Konstruktionsmodus: trennt die Konstruktion eines komplexen Objekts von seiner Darstellung, sodass derselbe Konstruktionsprozess unterschiedliche Darstellungen erstellen kann.

5. Prototyp, Prototypmodus: Verwenden Sie Prototypinstanzen, um die zu erstellenden Objekttypen anzugeben, und erstellen Sie neue Objekte durch Kopieren dieser Prototypen.

Zu den Verhaltenstypen gehören:

6. Iterator, Iteratormuster: Bietet eine Methode für den sequentiellen Zugriff auf jedes Element eines Aggregatobjekts, ohne die interne Darstellung des Objekts offenzulegen.

7. Beobachter, Beobachtermuster: Definieren Sie Eins-zu-Viele-Abhängigkeitsbeziehungen zwischen Objekten. Wenn sich der Status eines Objekts ändert, werden alle davon abhängigen Objekte benachrichtigt und automatisch aktualisiert. .

8. Template-Methode: Definieren Sie das Grundgerüst eines Algorithmus im Betrieb und verschieben Sie einige Schritte auf Unterklassen. Mit der Template-Methode können Unterklassen die Struktur eines Algorithmus nicht ändern bestimmte spezifische Schritte des Algorithmus.

9. Befehl, Befehlsmodus: Kapselt eine Anforderung als Objekt, sodass Sie Clients mit unterschiedlichen Anforderungen parametrisieren, Anforderungen in die Warteschlange stellen und Anforderungsprotokolle aufzeichnen können. Außerdem werden rückgängig gemachte Vorgänge unterstützt.

10. Zustand, Zustandsmodus: Ermöglicht einem Objekt, sein Verhalten zu ändern, wenn sich sein interner Zustand ändert. Das Objekt scheint seine Klasse geändert zu haben.

11. Strategie, Strategiemuster: Definieren Sie eine Reihe von Algorithmen, kapseln Sie sie einzeln und machen Sie sie austauschbar. Dieses Muster macht die Algorithmen unabhängig von den Benutzern, die sie verwenden .

12. China der Verantwortung, Chain-of-Responsibility-Modell: Geben Sie mehreren Objekten die Möglichkeit, Anfragen zu bearbeiten, und vermeiden Sie so die Kopplungsbeziehung zwischen dem Absender und dem Empfänger der Anfrage

13. Mediator, Mediatormuster: Verwenden Sie ein Mediatorobjekt, um eine Reihe von Objektinteraktionen zu kapseln.

14. Besucher, Besuchermodus: Stellt eine Operation dar, die auf jedes Element in einer Objektstruktur einwirkt. Es ermöglicht Ihnen, die Rolle jedes Elements zu definieren für dieses Element.

15. Dolmetscher, Dolmetschermodus: Definieren Sie bei gegebener Sprache eine Darstellung ihrer Grammatik und definieren Sie ein

ein Dolmetscher, der die Darstellung verwendet, um Sätze in der Sprache zu interpretieren.

16. Memento, Memo-Modus: Erfassen Sie den internen Zustand eines Objekts, ohne das Objekt zu zerstören, und speichern Sie diesen Zustand außerhalb des Objekts.

Zu den Strukturtypen gehören:

17. Zusammengesetzter Kombinationsmodus: Kombinieren Sie Objekte in einer Baumstruktur, um die Beziehung zwischen Teilen und dem Ganzen darzustellen Mit Composite können Benutzer einzelne Objekte und zusammengesetzte Objekte konsistent verwenden.

18. Fassade, Darstellungsmodus: Bietet eine konsistente Schnittstelle für eine Reihe von Schnittstellen im Subsystem. Fa?ade bietet eine High-Level-Schnittstelle, die die Verwendung des Subsystems erleichtert. .

19. Proxy, Proxy-Modus: Stellen Sie einen Proxy für andere Objekte bereit, um den Zugriff auf dieses Objekt zu steuern

20 einen Schnittstellentyp in eine andere vom Kunden gewünschte Schnittstelle umwandeln. Der Adaptermodus ermöglicht die Zusammenarbeit von Klassen, die aufgrund inkompatibler Schnittstellen nicht zusammenarbeiten können.

21. Decrator, Dekorationsmodus: Fügen Sie einem Objekt dynamisch einige zusätzliche Verantwortlichkeiten hinzu. In Bezug auf hinzugefügte Funktionen ist der Decorator-Modus flexibler als die Generierung von Unterklassen.

22. Bridge, Bridge-Modus: trennt den abstrakten Teil von seinem Implementierungsteil, sodass sie sich unabhängig voneinander ändern können.

Dreiundzwanzig, Fliegengewicht, Fliegengewichtsmodus

Tatsächlich gibt es zwei Kategorien: den gleichzeitigen Modus und den Thread-Pool-Modus. Verwenden Sie ein Bild, um es als Ganzes zu beschreiben:

2. Die sechs Prinzipien von Designmustern

Allgemeines Prinzip: Open-Close-Prinzip

Das Open-Close-Prinzip bedeutet, dass es offen für Erweiterungen und geschlossen für Änderungen ist. Wenn das Programm erweitert werden muss, kann der Originalcode nicht geändert werden, aber der Originalcode muss erweitert werden, um einen Hot-Swap-Effekt zu erzielen. Die Zusammenfassung in einem Satz lautet also: um das Programm skalierbar und einfach zu warten und zu aktualisieren. Um diesen Effekt zu erzielen, müssen wir Schnittstellen, abstrakte Klassen usw. verwenden. Wir werden dies später im spezifischen Design erwähnen.

1. Prinzip der Einzelverantwortung

Es gibt nicht mehr als einen Grund für Klassenänderungen, das heißt, jede Klasse sollte eine einzelne Verantwortung umsetzen. Wenn nicht, sollte die Klasse aufgeteilt werden.

2. Liskov-Substitutionsprinzip

Liskov-Substitutionsprinzip LSP (Liskov-Substitutionsprinzip LSP) ist eines der Grundprinzipien des objektorientierten Designs - ". Im Liskov-Substitutionsprinzip sagen wir:

Überall dort, wo eine Basisklasse erscheinen kann, kann eine Unterklasse nur dann der Grundstein für Vererbung und Wiederverwendung sein, wenn die abgeleitete Klasse die Basisklasse ersetzen kann und die Funktionalität der Softwareeinheit nicht beeinträchtigt wird kann wirklich wiederverwendet werden, und abgeleitete Klassen können auch neue Verhaltensweisen auf Basis von Basisklassen hinzufügen. Das Liskov-Substitutionsprinzip ist ein wichtiger Schritt zur Ergänzung des „Open-Close“-Prinzips ist die spezifische Implementierung der Abstraktion, daher ist das Liskov-Substitutionsprinzip eine Spezifikation für die spezifischen Schritte zur Erreichung der Abstraktion

Enzyklopädie

3

Dies ist die Grundlage des Öffnungs- und Schließprinzips: Schnittstellenorientierte Programmierung, die beim Schreiben von Code auf Abstraktion und nicht auf Konkretheit setzt , aber mit der übergeordneten Schnittstelle der konkreten Klasse

4. Dieses Prinzip bedeutet: Es gibt keine Methoden, die nicht von Unterklassen verwendet werden Andernfalls ist die Verwendung mehrerer isolierter Schnittstellen besser als die Verwendung einer einzelnen Schnittstelle (mehrere Schnittstellenmethoden werden zu einer Schnittstelle zusammengefasst).

5 🎜>

Das heißt: Je weniger eine Klasse über die Klassen weiß, von denen sie abhängt, desto besser. Das heißt, egal wie komplex die abhängige Klasse ist, die Logik sollte in der Methode gekapselt und bereitgestellt werden Wenn sich die abhängige Klasse ändert, hat dies nur minimale Auswirkungen auf die Klasse. Ein weiterer Ausdruck des am wenigsten bekannten Prinzips ist: Nur mit direkten Freunden kommunizieren. Es wird als Friend-Beziehung bezeichnet und kann in Abhängigkeiten, Assoziationen, Aggregationen, Kombinationen usw. unterteilt werden. Klassen, die in Mitgliedsvariablen, Methodenparametern und Methodenrückgabewerten auftreten, werden als direkte Freunde bezeichnet, temporäre Variablen jedoch nicht direkte Freunde. Wir verlangen, dass unbekannte Klassen nicht als lokale Variablen in der Klasse erscheinen. 6. Prinzip der zusammengesetzten Wiederverwendung

Das Prinzip besteht darin, zuerst die Synthese/Aggregation zu verwenden, anstatt die Vererbung zu verwenden.

3. Die 23 Entwurfsmuster in Java A. Erstellungsmuster

Ab diesem Abschnitt stellen wir die Konzepte, Anwendungsszenarien usw. der 23 Entwurfsmuster in Java im Detail vor. und kombinieren Sie sie mit ihren Eigenschaften und Prinzipien von Designmustern.

Erstens gehört das einfache Fabrikmuster nicht zu den Mustern in 23. Einfache Fabriken werden im Allgemeinen unterteilt in: gewöhnliche einfache Fabriken, einfache Fabriken mit mehreren Methoden und einfache Fabriken mit statischen Methoden.

0. Einfacher Factory-Modus

Der einfache Factory-Modus ist in drei Typen unterteilt: 01. Gewöhnlich

besteht darin, eine Factory-Klasse für einige Klassen zu erstellen, die dieselbe Schnittstelle implementieren Erstellen Sie eine Instanz. Schauen Sie sich zunächst das Beziehungsdiagramm an:

Zum Beispiel: (Lassen Sie uns ein Beispiel für das Senden von E-Mails und Textnachrichten geben) Erstellen Sie zunächst eine gemeinsame Schnittstelle zwischen den beiden:

public interface Sender {
    public void Send();
}

Zweitens erstellen Sie die Implementierungsklasse:

public class MailSender implements Sender {
    @Override
    public void Send() {
    System.out.println("this is mailsender!");
    }
}

public class SmsSender implements Sender {
    @Override
    public void Send() {
    System.out.println("this is sms sender!");
    }
}

Schließlich erstellen Sie die Factory-Klasse:

public class SendFactory {
    public Sender  produce(String type){
    if ("mail" .equals(type) {
        return new MailSender( );
    }else if("sms" .equals(type)){
        return new SmsSender();
    }else{
        System. out . println("请输入正确的类型！"); 
        return null;)
    }
}

Testen wir es:

public class FactoryTest {
    public static void main(String[] args) {
        SendFactory factory = new SendFactory();
        Sender sender = factory.produce("sms");
        sender.Send();
    }
}

Ausgabe: Dies ist der SMS-Absender !

02. Mehrere Methoden

stellen eine Verbesserung gegenüber dem normalen Factory-Methodenmuster dar. Wenn die übergebene Zeichenfolge falsch ist, kann das Objekt nicht korrekt erstellt werden Muster mit mehreren Factory-Methoden Es bietet mehrere Factory-Methoden zum separaten Erstellen von Objekten. Beziehungsdiagramm:

Ändern Sie den obigen Code und ändern Sie die SendFactory-Klasse wie folgt:

public class SendFactory {
    public Sender produceMail(){
        return new MailSender();   
    }        
    public Sender produceSms(){
        return new SmsSender();
    }
}

Die Testklasse lautet wie folgt:

public class FactoryTest{
    public static void main(String[] args) {
        SendFactory factory = new SendFactory( );
        Sender sender = factory.produceMail();
        sender.Send();
    }
}

Ausgabe: Das ist Mailsender!

Verwandte Artikel:

Java Design Patterns – Sechs Prinzipien von Design Patterns

24 Design Patterns und 7 Prinzipien in Java

Das obige ist der detaillierte Inhalt vonÜberblick über die 23 Entwurfsmuster und 6 wichtigsten Entwurfsmusterprinzipien von Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!