[JAVA] Modèle de conception ~ Pont ~

1.Tout d'abord

Voici un résumé du ** modèle de pont ** dans le modèle de conception du GoF.

2. Qu'est-ce que le modèle Bridge?

• Le mot anglais Bridge signifie ** bridge **. ――Le modèle Bridge est une méthode qui relie deux endroits **, tout comme un pont dans le monde réel relie ce côté et ce côté de la rivière.
• Les deux endroits où les ponts du modèle Bridge sont la ** hiérarchie de classes d'entités ** et la ** hiérarchie de classes d'implémentation **.
• ** Hiérarchie des classes de fonctions ** ・ ・ ・ Il s'agit de la hiérarchie lorsqu'une super classe a des fonctions de base et de nouvelles fonctions sont ajoutées dans les sous-classes.
• ** Hiérarchie des classes d'implémentation ** ・ ・ ・ Il s'agit de la hiérarchie lorsque l'interface est définie par la méthode abstraite dans la super classe et que l'interface est implémentée par la méthode concrète dans la sous-classe.
• Le modèle de conception du GoF est classé comme ** modèle de conception structurelle **.

3. Exemple de diagramme de classes

4. Exemple de programme

Ce programme affiche la chaîne de caractères saisie un nombre spécifié de fois et un nombre aléatoire de fois.

4-1. Classe d'affichage

Cela devient la hiérarchie de classe de la fonction. Cette classe est utilisée pour "afficher". Le champ impl de cette classe devient le "pont" des deux hiérarchies de classes.

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. Classe CountDisplay

Cela devient la hiérarchie de classe de la fonction. Cette classe a une fonction appelée "Afficher le nombre de fois spécifié".

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. Classe RandomCountDisplay

Cela devient la hiérarchie de classe de la fonction. Cette classe a une fonction appelée "affichage de nombres aléatoires".

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. Classe DisplayImpl

C'est la hiérarchie de classes de l'implémentation. Une classe qui définit une méthode pour "afficher".

DisplayImpl.java

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

4-5. Classe StringDisplayImpl

C'est la hiérarchie de classes de l'implémentation. C'est une classe qui "s'affiche à l'aide d'une chaîne de caractères".

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. Classe principale

Cette classe effectue le traitement principal.

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. Résultat de l'exécution

+------------+
|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. Avantages

Comme mentionné ci-dessus, la caractéristique du modèle Bridge est qu'il sépare la ** hiérarchie de classes fonctionnelles ** et la ** hiérarchie de classes d'implémentation **. Si vous séparez ces deux hiérarchies de classes, vous pouvez étendre chaque hiérarchie de classes indépendamment. Si vous souhaitez ajouter une entité, ajoutez la classe à la hiérarchie des classes de l'entité. À ce stade, la hiérarchie des classes d'implémentation n'a pas du tout besoin d'être modifiée. De plus, ** la fonctionnalité ajoutée sera disponible dans toutes les implémentations **. Dans l'exemple de programme, l'ajout de la classe CountDisplay et de la classe RandomCountDisplay est l'ajout de fonction. De cette façon, le modèle Bridge vous donne une vue claire de l'expansion des classes.

6. GitHub

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

7. Liste des modèles de conception

• ** Résumé du modèle de conception du GoF **

8. Référence

Cet article et exemple de programme ont été créés à partir des livres suivants.

• ** Introduction aux modèles de conception appris en langage Java **

C'était très facile à comprendre et j'ai beaucoup appris. Je vous remercie. Les explications détaillées des modèles de conception et des exemples de programmes sont écrites, veuillez donc également consulter les livres.