Einführung in Java-Designmuster

Diese Zusammenfassung basiert hauptsächlich auf meiner vorherigen Artikelserie zu den Grundlagen von Designmustern. Die Hauptsache ist, die wichtigen Wissenspunkte in meinen eigenen Worten zu erklären. Es kann einige Fehler geben, daher hoffe ich, dass Sie mir verzeihen und mir einige Hinweise geben können.

Entwurfsmuster

Kreatives Muster

Die Rolle des Schöpfungsmusters ist das Erstellen Beim Erstellen eines Objekts ist es am vertrautesten, ein neues Objekt zu erstellen und dann zugehörige Attribute festzulegen. In vielen Szenarien müssen wir Kunden jedoch eine benutzerfreundlichere Möglichkeit zum Erstellen von Objekten bieten, insbesondere wenn wir Klassen definieren, diese aber anderen Entwicklern zur Verfügung stellen müssen.

Einzelfall

单例模式保证全局的单例类只有一个实例，这样的话使用的时候直接获取即可，比如数据库的一个连接，Spring里的bean，都可以是单例的。

单例模式一般有5种写法。

第一种是饿汉模式，先把单例进行实例化，获取的时候通过静态方法直接获取即可。缺点是类加载后就完成了类的实例化，浪费部分空间。

第二种是饱汉模式，先把单例置为null，然后通过静态方法获取单例时再进行实例化，但是可能有多线程同时进行实例化，会出现并发问题。

第三种是逐步改进的方法，一开始可以用synchronized关键字进行同步，但是开销太大，而后改成使用volatile修饰单例，然后通过一次检查判断单例是否已初始化，如果未初始化就使用synchronized代码块，再次检查单例防止在这期间被初始化，而后才真正进行初始化。

第四种是使用静态内部类来实现，静态内部类只在被使用的时候才进行初始化，所以在内部类中进行单例的实例化，只有用到的时候才会运行实例化代码。然后外部类再通过静态方法返回静态内部类的单例即可。

第五种是枚举类，枚举类的底层实现其实也是内部类。枚举类确保每个类对象在全局是唯一的。所以保证它是单例，这个方法是最简单的。

Fabrikmuster

简单工厂一般是用一个工厂创建多个类的实例。

工厂模式一般是指一个工厂服务一个接口，为这个接口的实现类进行实例化

抽象工厂模式是指一个工厂服务于一个产品族，一个产品族可能包含多个接口，接口又会包含多个实现类，通过一个工厂就可以把这些绑定在一起，非常方便。

Prototypmuster

一般通过一个实例进行克隆从而获得更多同一原型的实例。使用实例的clone方法即可完成。

Builder-Muster

建造者模式中有一个概念叫做链式调用，链式调用为一个类的实例化提供便利，一般提供系列的方法进行实例化，实际上就是将set方法改造一下，将原本返回为空的set方法改为返回this实例，从而实现链式调用。

建造者模式在此基础上加入了builder方法，提供给外部进行调用，同样使用链式调用来完成参数注入。

Strukturmuster

Das vorherige Erstellungsmuster führte einige Entwurfsmuster zum Erstellen von Objekten ein. Die in diesem Abschnitt vorgestellte Struktur Ziel ist es, eine Entkopplung durch Änderung der Codestruktur zu erreichen, wodurch unser Code einfacher zu warten und zu erweitern ist.

Adaptermuster

Das Adaptermuster wird verwendet, um zwei verschiedene Klassen anzupassen.

Ähnlichkeiten und Unterschiede zwischen dem Adaptermodus und dem Proxy-Modus

Der Vergleich dieser beiden Modi ist eigentlich ein Vergleich des Objektadaptermodus und des Proxy-Modus.

Sie sind sehr ähnlich. Alle erfordern eine Instanz einer bestimmten Implementierungsklasse.

Aber ihre Zwecke sind unterschiedlich.

Der Adapter übernimmt die Arbeit der Anpassung, um „Hühnchen in Ente zu verpacken“ und dann zu verwenden es wie eine Ente“,

Es gibt keine Vererbungsbeziehung zwischen Hühnern und Enten.

Das Adaptermuster kann in Klassenadapter, Objektadapter usw. unterteilt werden.

Ein Klassenadapter kann sich an die übergeordnete Klasse anpassen, indem er die übergeordnete Klasse erbt.

Der Objektadapter muss das Objekt zum Packen an den Konstruktor eines anderen Objekts übergeben.

Fliegengewichtsmodus

/ Der Kern des Fliegengewichtsmodus ist die Fliegengewichts-Fabrikklasse.

// Die Funktion der Fliegengewichts-Fabrikklasse besteht darin Stellen Sie einen Flyweight-Pool bereit, der zum Speichern von Flyweight-Objekten verwendet wird.

// Wenn der Benutzer ein Objekt benötigt, holen Sie es zuerst aus dem Flyweight-Pool.

// Wenn es nicht im Flyweight-Pool vorhanden ist , erstelle ein neues Flyweight-Objekt, das an den Benutzer zurückgegeben wird.

// Speichern Sie das neue Objekt im Flyweight-Pool.

//Flyweight Pattern

// Englisch ist Flyweight Pattern. Ich habe das Gefühl, dass diese Übersetzung wirklich schwer zu verstehen ist Verbindung. Flyweight bedeutet „Lightweight“ und bezieht sich auf gemeinsam genutzte Komponenten, also auf die Wiederverwendung bereits generierter Objekte.

// Der einfachste Weg, Objekte wiederzuverwenden, besteht darin, eine HashMap zu verwenden, um jedes neu generierte Objekt zu speichern. Jedes Mal, wenn Sie ein Objekt benötigen, gehen Sie zuerst zur HashMap, um zu sehen, ob es vorhanden ist. Wenn nicht, generieren Sie ein neues Objekt und fügen Sie dieses Objekt dann in die HashMap ein.

// Ich werde diesen einfachen Code nicht demonstrieren.

Proxy-Modus

// Wir haben festgestellt, dass es so etwas nicht gibt, um es ganz klar auszudrücken: Der Proxy-Modus dient der „Methodenverpackung“ oder „Methodenverbesserung“. ".

// Vergessen wir diesen Begriff bei der aspektorientierten Programmierung. In AOP ist

// eigentlich der Prozess des dynamischen Proxyings. Zum Beispiel definieren wir in Spring

// die Proxy-Klasse nicht selbst, aber Spring hilft uns, den Proxy dynamisch zu definieren,

// und uns dann in @Before zu definieren, @After, @Around Die Codelogik wird dem Agenten dynamisch hinzugefügt.

Darstellungsmodus

Der Darstellungsmodus kapselt im Allgemeinen spezifische Implementierungsdetails, um Benutzern eine einfachere Benutzeroberfläche bereitzustellen.

Sie können den erforderlichen Inhalt durch einen Methodenaufruf erhalten.

Kompositionsmodus

//Der Kombinationsmodus wird verwendet, um Daten mit einer hierarchischen Struktur darzustellen, wodurch unser Zugriff auf einzelne Objekte und kombinierte Objekte konsistent wird.

//Schauen wir uns ein Beispiel direkt an.

// Es gibt auch eine Sammlung untergeordneter Mitarbeiter leer),

// Die Struktur der untergeordneten Mitarbeiter ist die gleiche wie bei uns,

// hat auch Attribute wie Name und Abteilung,

// hat auch eine Sammlung ihrer untergeordneten Mitarbeiter.

class Employee {
    private String name;
    private String dept;
    private int salary;
    private List<Employee> subordinates; // 下属
}

Decorator-Muster

Decorator

Das Decorator-Muster sorgt dafür, dass jede erweiterte Klasse die übergeordnete Klasse der höchsten Ebene erbt. Wenn dann eine Funktionserweiterung erforderlich ist, übergeben Sie einfach die Klasseninstanz an die erweiterte Klasse, und dann kann die erweiterte Klasse bei Verwendung die Funktionalität der ursprünglichen Klasse verbessern.

Im Gegensatz zum Proxy-Modus erbt im Dekorationsmodus jede Dekorationsklasse die übergeordnete Klasse und kann auf mehreren Ebenen gekapselt werden.

Verhaltensmuster

Das Verhaltensmuster konzentriert sich auf die Interaktion zwischen verschiedenen Klassen, indem es die Verantwortlichkeiten klar aufteilt und unseren Code klarer macht.

Strategiemuster

Strategiemuster betrachtet eine Strategie im Allgemeinen als Klasse und übergibt die Instanz, wenn die Strategie angegeben werden muss, sodass wir den Algorithmus dort verwenden können Übergeben Sie den angegebenen Algorithmus.

Befehlsmodus

Der Befehlsmodus ist im Allgemeinen in drei Rollen unterteilt: Befehlsinitiator, Befehl und Befehlsempfänger.

Der Befehlsinitiator muss die Befehlsinstanz einfügen, wenn er sie verwendet. Führen Sie dann den Befehlsaufruf aus.

Der Befehlsaufruf ruft tatsächlich die Methode des Befehlsempfängers auf, um den eigentlichen Aufruf durchzuführen.

Zum Beispiel entspricht eine Taste auf der Fernbedienung einem Befehl. Wenn auf die Taste geklickt wird, wird der Befehl ausgeführt und die vom Fernseher bereitgestellte Methode wird automatisch aufgerufen.

Template-Methodenmuster

Template-Methode bezieht sich im Allgemeinen auf die Bereitstellung einer Methodenvorlage, die einige Implementierungsklassen und einige abstrakte Klassen enthält und die Ausführungsreihenfolge angibt.

Implementierungsklassen sind gute Methoden, die von Vorlagen bereitgestellt werden. Abstrakte Klassen erfordern, dass Benutzer sie selbst implementieren.

Vorlagenmethoden geben die Ausführungsreihenfolge von Methoden in einer Vorlage an, was für einige Entwicklungsframeworks sehr gut geeignet ist, sodass Vorlagenmethoden auch in Open-Source-Frameworks häufig verwendet werden.

Beobachtermuster und Mechanismus zum Abhören von Ereignissen

Das Beobachtermuster wird im Allgemeinen für Datenabonnements zwischen Abonnenten und Nachrichtenherausgebern verwendet.

Im Allgemeinen unterteilt in Beobachter und Themen. Beobachter abonnieren Themen und registrieren Instanzen in der vom Thema verwalteten Beobachterliste.

Wenn das Thema Daten aktualisiert, sendet es die Daten automatisch an den Beobachter oder benachrichtigt den Beobachter, dass die Daten aktualisiert wurden.

Aber aufgrund dieser Methode ist die Kopplungsbeziehung des Nachrichten-Pushs relativ eng. Und es ist schwer zu wissen, um welchen Datentyp es sich handelt, ohne die Daten zu öffnen.

Ich weiß, dass die Ereignis- und Ereignis-Listener-Muster verwendet wurden, um das Datenformat flexibler zu gestalten. Der Ereignistyp und die Ereignisdaten des Ereignis-Wrappers wurden vom Subjekt und Beobachter entkoppelt.

Wenn ein Ereignis auftritt, löst das Thema alle Listener des Ereignisses aus und sendet das Ereignis über die Listener-Liste an jeden Listener. Nach dem Abhören des Ereignisses findet es zunächst den entsprechenden Ereignistyp entsprechend dem Ereignistyp Unterstützt den Event-Handler und verwendet dann den Handler, um das entsprechende Ereignis zu verarbeiten.

Verantwortungskettenmodell

Die Verantwortungskette muss normalerweise zuerst eine einseitig verknüpfte Liste erstellen, und dann muss der Anrufer nur den Hauptknoten aufrufen und ihn wird später automatisch fließen. Ein gutes Beispiel ist beispielsweise die Prozessgenehmigung. Solange der Endbenutzer einen Antrag einreicht, wird automatisch eine Verantwortungskette basierend auf den Inhaltsinformationen des Antrags eingerichtet, und dann kann der Ablauf beginnen

Das obige ist der detaillierte Inhalt vonEinführung in Java-Designmuster. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!