[JAVA] Entwurfsmuster ~ Brücke ~

1. Zuallererst

Hier ist eine Zusammenfassung des ** Brückenmusters ** im GoF-Entwurfsmuster.

2. Was ist ein Brückenmuster?

• Das englische Wort Bridge bedeutet ** Brücke **. ――Das Brückenmuster ist eine Methode, die zwei Orte ** verbindet, genau wie eine Brücke in der realen Welt diese Seite und die andere Seite des Flusses verbindet.
• Die beiden Stellen, an denen die Bridge-Musterbrücken die ** Feature-Class-Hierarchie ** und die ** Implementierungsklassen-Hierarchie ** sind.
• ** Funktionsklassenhierarchie ** ・ ・ ・ Dies ist die Hierarchie, wenn eine Superklasse Grundfunktionen hat und neue Funktionen in Unterklassen hinzugefügt werden.
• ** Implementierungsklassenhierarchie ** ・ ・ ・ Dies ist die Hierarchie, wenn die Schnittstelle durch die abstrakte Methode in der Superklasse definiert wird und die Schnittstelle durch die konkrete Methode in der Unterklasse implementiert wird.
• Das GoF-Entwurfsmuster wird als ** strukturelles Entwurfsmuster ** klassifiziert.

3. Beispielklassendiagramm

4. Beispielprogramm

Dieses Programm zeigt die eingegebene Zeichenfolge eine bestimmte Anzahl von Malen und eine zufällige Anzahl von Malen an.

4-1. Anzeigeklasse

Es wird zur Klassenhierarchie der Funktion. Diese Klasse wird für "Anzeige" verwendet. Das Impl-Feld dieser Klasse wird zur "Brücke" der beiden Klassenhierarchien.

Display.java

public class Display {

	private DisplayImpl impl;

	public Display(DisplayImpl impl) {
		this.impl = impl;
	}

	public void open() {
		impl.rawOpen();
	}

	public void print() {
		impl.rawPrint();
	}

	public void close() {
		impl.rawClose();
	}

	public final void display() {
		open();
		print();
		close();
	}
}

4-2. CountDisplay-Klasse

Es wird zur Klassenhierarchie der Funktion. Diese Klasse hat eine Funktion namens "Angegebene Anzahl von Malen anzeigen".

CountDisplay.java

public class CountDisplay extends Display {

	public CountDisplay(DisplayImpl impl) {
		super(impl);
	}

	public void multiDisplay(int times) {
		open();
		for (int i = 0; i < times; i++) {
			print();
		}
		close();
	}
}

4-3. RandomCountDisplay-Klasse

Es wird zur Klassenhierarchie der Funktion. Diese Klasse hat eine Funktion namens "Zufallszahlenanzeige".

RandomCountDisplay.java

import java.util.Random;

public class RandomCountDisplay extends CountDisplay {

    private Random random = new Random();

	public RandomCountDisplay(DisplayImpl impl) {
		super(impl);
	}

	public void randomDisplay(int times) {
        multiDisplay(random.nextInt(times));
	}
}

4-4. DisplayImpl-Klasse

Es ist die Klassenhierarchie der Implementierung. Eine Klasse, die eine Methode für "Anzeige" definiert.

DisplayImpl.java

public abstract class DisplayImpl {
	public abstract void rawOpen();
	public abstract void rawPrint();
	public abstract void rawClose();
}

4-5. StringDisplayImpl-Klasse

Es ist die Klassenhierarchie der Implementierung. Es ist eine Klasse, die "mit einer Zeichenfolge angezeigt wird".

StringDisplayImpl.java

public class StringDisplayImpl extends DisplayImpl {

	private String string;
	private int width;

	public StringDisplayImpl(String string) {
		this.string = string;
		this.width = string.getBytes().length;
	}

	public void rawOpen() {
		printLine();
	}

	public void rawPrint() {
		System.out.println("|" + string + "|");
	}

	public void rawClose() {
		printLine();
	}

	private void printLine() {
		System.out.print("+");
		for (int i = 0; i < width; i++) {
			System.out.print("-");
		}
		System.out.println("+");
	}
}

4-6 Hauptklasse

Diese Klasse führt die Hauptverarbeitung durch.

Main.java

public class Main {

	public static void main(String[] args) {
		Display d = new Display(new StringDisplayImpl("Display Test"));
		CountDisplay cd = new CountDisplay(new StringDisplayImpl("CountDisplay Test"));
		RandomCountDisplay rcd = new RandomCountDisplay(new StringDisplayImpl("RandomCountDisplay Test"));
		d.display();
		cd.multiDisplay(5);
		rcd.randomDisplay(10);
	}
}

4-7 Ausführungsergebnis

+------------+
|Display Test|
+------------+
+-----------------+
|CountDisplay Test|
|CountDisplay Test|
|CountDisplay Test|
|CountDisplay Test|
|CountDisplay Test|
+-----------------+
+-----------------------+
|RandomCountDisplay Test|
|RandomCountDisplay Test|
|RandomCountDisplay Test|
|RandomCountDisplay Test|
|RandomCountDisplay Test|
|RandomCountDisplay Test|
+-----------------------+

5. Vorteile

Wie oben erwähnt, besteht das Merkmal des Bridge-Musters darin, dass es die ** Funktionsklassenhierarchie ** und die ** Implementierungsklassenhierarchie ** trennt. Wenn Sie diese beiden Klassenhierarchien trennen, können Sie jede Klassenhierarchie unabhängig erweitern. Wenn Sie ein Feature hinzufügen möchten, fügen Sie die Klasse der Klassenhierarchie des Features hinzu. Zu diesem Zeitpunkt muss die Implementierungsklassenhierarchie überhaupt nicht geändert werden. Darüber hinaus ** wird die hinzugefügte Funktionalität in allen Implementierungen verfügbar sein **. Im Beispielprogramm ist das Hinzufügen der CountDisplay-Klasse und der RandomCountDisplay-Klasse die Funktionserweiterung. Auf diese Weise erhalten Sie über das Bridge-Muster einen klaren Überblick über die Klassenerweiterung.

6. GitHub

• https://github.com/i-tanaka730/design_pattern

7. Liste der Entwurfsmuster

• ** Zusammenfassung des GoF-Entwurfsmusters **

8. Referenz

Dieser Artikel und das Beispielprogramm wurden basierend auf den folgenden Büchern erstellt.

• ** Einführung in in Java gelernte Entwurfsmuster **

Es war sehr leicht zu verstehen und ich habe viel gelernt. Vielen Dank. Die detaillierten Erklärungen zu den Entwurfsmustern und Beispielprogrammen sind geschrieben. Schauen Sie sich also auch die Bücher an.