Zusammenfassung der sieben Prinzipien von Designmustern

Dieses Tutorial erklärt Ihnen Schritt für Schritt anhand von Java-Beispielen das Konzept der Entwurfsmuster.

1. Prinzip der Einzelverantwortung

Zweck: Reduzierung der Codekomplexität, Entkopplung des Systems und Verbesserung der Lesbarkeit

Bedeutung: Für eine Klasse gibt es nur einen Grund für den Wechsel der Klasse; die Verantwortung der Klasse ist einzigartig, und diese Verantwortung ist der einzige Grund für den Wechsel anderer Klassen.

Lösung: Kapseln Sie verschiedene Verantwortlichkeiten in verschiedene Klassen oder Module. Wenn es neue Anforderungen gibt, die bestehende Verantwortlichkeiten in Verantwortlichkeiten mit geringerer Granularität aufteilen, sollte der bestehende Code zeitnah umgestaltet werden. Wenn die Systemlogik einfach genug ist, die Methoden ausreichend gering sind, die Unterklassen gering genug sind oder die nachfolgenden Assoziationen gering genug sind, müssen Sie Ihre SRP-Prinzipien nicht strikt befolgen, um übermäßiges Design und übermäßige Granularität zu vermeiden.

Beispiel: Der Leitungstyp Wire versorgt Bewohner mit Strom mit einer Spannung von 220 V; neue Anforderungen steigen jedoch, und die Leitungen transportieren auch Hochspannungsstrom mit einer Spannung von 200 kV Der ursprüngliche Drahttyp kann durch Hinzufügen von Erweiterungsmethoden implementiert werden, was gegen das Prinzip der Einzelverantwortung verstößt. Sie können eine Basisklasse bereitstellen und zwei abgeleitete Klassen erstellen: Stromversorgungsleitungen für Privathaushalte und Hochspannungsübertragungsleitungen.

2. Liskov-Substitutionsprinzip

Zweck: Vermeidung der Zerstörung des Systemvererbungssystems

Bedeutung: Alle Referenzen zu einer Basisklasse müssen in der Lage sein, Objekte ihrer Unterklassen transparent zu verwenden.

Lösung: Eine Unterklasse kann die abstrakte Methode der übergeordneten Klasse implementieren, aber die nicht abstrakte Methode der übergeordneten Klasse nicht überschreiben; Unterklasse überschreibt oder implementiert Wenn die Methode der übergeordneten Klasse eine Methode ist, sind die Vorbedingungen der Methode (d. h. die formalen Parameter der Methode) lockerer als die Eingabeparameter der Methode der übergeordneten Klasse, wenn die Methode der Unterklasse die Zusammenfassung implementiert Methode der übergeordneten Klasse, die Nachbedingungen der Methode (d. h. der Rückgabewert der Methode) sind strenger als die der übergeordneten Klasse. Wenn die Unterklasse die Methoden der übergeordneten Klasse nicht vollständig implementieren kann oder einige Methoden der übergeordneten Klasse in der Unterklasse verzerrt wurden, wird empfohlen, die Vererbungsbeziehung zu trennen und anstelle der Vererbung Abhängigkeit, Aggregation, Kombination und andere Beziehungen zu verwenden.

Beispiel: Die Methode für das Fliegen von Vögeln mit zwei Flügeln wurde definiert. Wenn Sie die Methode der übergeordneten Klasse überschreiben, was ist in der Methode enthalten? Fliegen mit zwei Flügeln? Wenn Sie es nicht tun, verstößt es gegen das Richter-Substitutionsprinzip und führt dazu, dass alle Vögel nicht fliegen können. Es sollten zwei grundlegende Vogelklassen nebeneinander geschaffen werden: fliegend und flugunfähig. Die Vorbedingungen sind lockerer und die Nachbedingungen sind strenger. Beispielsweise gibt die übergeordnete Klasse Map zurück und die Unterklasse akzeptiert HashMap-Formalparameter.

3. Abhängigkeitsinversionsprinzip

Zweck: Vermeidung übermäßiger Wartungsarbeiten aufgrund geänderter Anforderungen

Bedeutung: Hoch- Module auf niedriger Ebene sollten nicht von Modulen auf niedriger Ebene abhängen, beide sollten von ihren Abstraktionen abhängen; Details sollten von Abstraktionen abhängen.

Lösung: Schnittstellenorientierte Programmierung. Verwenden Sie Schnittstellen oder abstrakte Klassen, um Spezifikationen und Verträge zu formulieren, ohne dass bestimmte Operationen erforderlich sind, und überlassen Sie die Aufgabe, Details ihren Implementierungsklassen anzuzeigen. Fertig stellen.

Beispiel: Die Mutterklasse Mother verfügt über eine Storytelling-Methode TellStory, die auf der Eingabe einer Book-Klasse basiert und die getContent-Methode der Book-Klasse zum Erzählen von Geschichten verwendet. Wenn Sie Ihre Mutter dann das nächste Mal brauchen, um Geschichten aus Zeitungen oder Mobiltelefonen zu erzählen, ist die ursprüngliche Benutzeroberfläche machtlos. Zu diesem Zeitpunkt wird eine IReader-Basisklasse abstrahiert, die die getContent-Methode enthält, und Buch, Zeitung und Mobiltelefon werden separat implementiert. Die TellStory-Methode der Mutter akzeptiert eine IReader-Instanz und ruft die getContent-Methode auf.

4. Prinzip der Schnittstellentrennung

Zweck: Aufgeblähte Schnittstellen vermeiden

Bedeutung: Client Es sollte sich nicht auf Schnittstellen verlassen, die Es ist nicht erforderlich, dass die Abhängigkeit einer Klasse von einer anderen Klasse auf der kleinsten Schnittstelle basiert.

Lösung: Verfeinern Sie die Schnittstelle moderat und teilen Sie die aufgeblähte Schnittstelle in mehrere unabhängige Schnittstellen auf.

Beispiel: Prüfungsschnittstelle, einschließlich Methoden zum Testen von Sprache, Mathematik, Physik, Chemie, Biologie, Politik, Geschichte, Geographie usw. Die Schülerklasse implementiert die Prüfungsschnittstelle und legt die Prüfung ab. Die Studentenklasse für Geisteswissenschaften und die Studentenklasse für Naturwissenschaften sind von der Studentenklasse abgeleitet. Bei der Implementierung der Prüfungsschnittstelle müssen sie einige Methoden implementieren, die sie nicht benötigen (da Studenten der Geisteswissenschaften nicht an der Prüfung für Physik und Chemie teilnehmen, und Naturwissenschaften). Studierende legen nicht die Prüfung für Politik, Geschichte und Geographie ab). Zu diesem Zeitpunkt muss die Prüfungsschnittstelle verfeinert und in eine Schnittstelle für grundlegende Fachprüfungen, eine Schnittstelle für geisteswissenschaftliche Prüfungen und eine Schnittstelle für naturwissenschaftliche Prüfungen unterteilt werden Prüfungsschnittstelle.

5. Demeter-Prinzip

Zweck: Reduzierung der Kopplung zwischen Klassen

Bedeutung: Jede Softwareeinheit verfügt über minimale Kenntnisse über andere Einheiten und ist auf diejenigen Softwareeinheiten beschränkt, die eng mit der eigenen Einheit verbunden sind.

Lösung: Unbekannte Klassen, die keine Kopplungsbeziehungen wie Abhängigkeit, Assoziation, Kombination, Aggregation usw. haben, sollten innerhalb der Klasse nicht als lokale Variablen erscheinen.

Beispiel: Der Schulleiter verwaltet die Lehrer und die Lehrer verwalten die Schüler. Wenn der Schulleiter alle anrufen muss, sollte er zuerst die Lehrer anrufen. Es ist jedoch nicht notwendig, die Informationen der Schüler einzuholen und die Namensaufrufe über die Lehrer durchzuführen Andernfalls kommt es zu einer unnötigen Kopplung zwischen Schulleiter und Schülern. Wenn die Schülerklasse wechselt, müssen sowohl die Lehrerklasse als auch die Schulleiterklasse geändert werden.

6. Prinzip der zusammengesetzten Wiederverwendung

Zweck: Verhindern, dass das Klassensystem riesig wird

Bedeutung: Bei der Erweiterung der Funktionalität einer Klasse geben Sie der Zusammensetzung/Aggregation den Vorzug vor der Vererbung.

Lösung: Wenn die Beziehung zwischen den Klassen „Ist-A“ ist, verwenden Sie die Vererbung; wenn die Beziehung zwischen den Klassen „Hat-A“ ist, verwenden Sie die Kombination.

Beispiel: Zum Beispiel können Abstraktion und Implementierung unabhängig voneinander geändert werden. Wenn Sie Funktionen erweitern, fügen Sie beispielsweise nur eine Klasse hinzu um eine Klasse zu bilden. Um Anforderungen an die Grafikanzeige zu erfüllen, verwenden Sie die Grafik-Shape-Klasse und die Display-Paint-Klasse, um sie zu implementieren. Jede Shape-Klasse verfügt über einen Paint-Klassenzeiger, der für das Zeichnen und Anzeigen von Grafiken verantwortlich ist. Die Paint-Klasse leitet die RedPaint-Klasse und die BluePaint-Klasse ab und übergibt sie an die Shape-Klasse, um das Zeichnen von Grafiken in verschiedenen Farben zu realisieren, sodass die Grafikzeichnungslogik und die Grafikzeichnungsimplementierung unabhängig voneinander geändert werden können. Eines Tages steigt die Nachfrage und alle Zeichnungen müssen Rahmen hinzufügen. Sie können die PaintDecorator-Klasse hinzufügen, die von der Paint-Basisklasse abgeleitet ist. Fügen Sie die virtuelle Funktion AddedPaint hinzu und schreiben Sie die Paint-Zeichnungsmethode neu. und fügen Sie den Aufruf zur AddedPaint-Methode hinzu. Fügen Sie die BorderPaintDecorator-Klasse hinzu, die von der PaintDecorator-Klasse abgeleitet ist, die AddedPaint-Methode überschreibt und den Code zum Zeichnen des Rahmens hinzufügt. Auf diese Weise kann das Hinzufügen einer neuen Klasse die Funktionen aller ursprünglichen Pinselklassen erweitern.

7. Open-Close-Prinzip

Zweck: Skalierbarkeit verbessern und Wartung erleichtern

Bedeutung: Offen für Erweiterung, geschlossen für Änderung. Das heißt, eine Systemerweiterung wird gefördert, eine Änderung des vorhandenen Systemcodes wird jedoch nicht unterstützt. Mit anderen Worten: Wenn die Software neue Anforderungen und Änderungen hat, ist es lediglich erforderlich, das Software-Framework zu erweitern, um es an die neuen Anforderungen anzupassen, und nicht den Code innerhalb des Frameworks zu ändern.

Lösung: Die ersten 6 Prinzipien der Designmuster und die 23 Designmuster werden gut befolgt, und das Öffnungs- und Schließprinzip wird natürlich gut befolgt. Indem man vorausschauend und vorhersehbar bei Änderungen der Anforderungen bleibt, kann die Abstraktion umfassender anwendbar gemacht werden und die entworfene Softwarearchitektur kann relativ stabil sein. Variable Details in Softwareanforderungen werden durch die Ableitung von Implementierungsklassen aus Abstraktionen erweitert.

Anhängen: Beispielcode für das Prinzip der synthetischen Wiederverwendung unter Verwendung des Bridge-Modus und des Dekorationsmodus in Kombination

#include <iostream>

//绘制类
class Paint
{
public:
	virtual void Draw() = 0;
};

//红色绘制类
class RedPaint : public Paint
{
public:
	void Draw()
	{
		std::cout << "Color Red!" << std::endl;
	}
};

//蓝色绘制类
class BluePaint : public Paint
{
public:
	void Draw()
	{
		std::cout << "Color Blue!" << std::endl;
	}
};

//图形类，使用桥接模式，将图形绘制逻辑与绘制实现解耦
class Shape
{
public:
	Shape(Paint* pt) : m_pPt(pt)
	{	 
	}

	virtual void Show()
	{
		std::cout << "Shape Style:" << std::endl;
		m_pPt->Draw();
	}

protected:
	Paint* m_pPt;
};


//长方形类
class Rectangle : public Shape
{
public:
	Rectangle(Paint* pt) : Shape(pt)
	{
	}
};

//圆形类
class Circle : public Shape
{
public:
	Circle(Paint* pt) : Shape(pt)
	{

	}
};

//附加绘制类，使用装饰模式，对原有绘制类进行功能扩展
class PaintDecorator : public Paint
{
public:
	PaintDecorator(Paint* pt) : m_pPt(pt) { }
	
	void Draw()
	{
		m_pPt->Draw();
		AddedPaint();
	}
	virtual void AddedPaint() = 0;

protected:
	Paint* m_pPt;
};

//附加边框类，对绘制类添加边框绘制功能
class BoarderDecorator : public PaintDecorator
{
public:
	BoarderDecorator(Paint* pt) : PaintDecorator(pt)
	{
	}

	void AddedPaint()
	{
		std::cout << "With Boarder!" << std::endl;
	}
};

void main()
{
	Shape* pShape = new Circle(new BoarderDecorator(new RedPaint()));
	pShape->Show();

	return;
}

Verwandte Empfehlungen:

JavaScript Design Pattern Factory Muster- und Strukturkonverter mode_javascript skills

Eine vorläufige Studie zu JavaScript-Designmustern_javascript skills

Das obige ist der detaillierte Inhalt vonZusammenfassung der sieben Prinzipien von Designmustern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!