[JAVA] Modèle de conception ~ Stratégie ~

1.Tout d'abord

Nous résumerons le ** modèle de stratégie ** dans le modèle de conception du GoF.

2. Quel est le modèle de stratégie?

• Le mot anglais Stratégie signifie ** Stratégie **. Dans le cas de la programmation, vous pouvez la considérer comme un ** algorithme **.
• Tout programme est écrit pour résoudre un problème. Certains algorithmes ont été mis en œuvre pour résoudre le problème. Le modèle de stratégie est une méthode qui vous permet d'échanger la partie qui implémente l'algorithme.
• Les modèles de conception du GoF sont classés comme des ** modèles de conception comportementale **.

3. Exemple de diagramme de classes

4. Exemple de programme

C'est un programme pour faire des ciseaux à papier-pierre. Il existe une stratégie pour se déplacer au hasard et une stratégie pour ne déplacer que Goo.

4-1. Classe de main

C'est une classe qui représente les mains de Janken.

Hand.java

public class Hand {

	public static final int HANDVALUE_GUU = 0;
	public static final int HANDVALUE_CHO = 1;
	public static final int HANDVALUE_PAA = 2;

	public static final Hand[] hand = {
			new Hand(HANDVALUE_GUU),
			new Hand(HANDVALUE_CHO),
			new Hand(HANDVALUE_PAA),
	};

	private int handvalue;

	private Hand(int handvalue) {
		this.handvalue = handvalue;
	}

	public static Hand getHand(int handvalue) {
		return hand[handvalue];
	}

	public boolean isStrongerThan(Hand h) {
		//vrai quand c'est plus fort que h
		return fight(h) == 1;
	}

	private int fight(Hand h) {
		if (this == h) {
			//dessiner
			return 0;
		} else if ((this.handvalue + 1) % 3 == h.handvalue) {
			//cette victoire
			return 1;
		} else {
			//h gagner
			return -1;
		}
	}
}

4-2. Classe de joueur

Cette classe représente le joueur qui joue le jeu.

Player.java

public class Player {

	private String name;
	private Strategy strategy;
	private int wincount;
	private int losecount;
	private int gamecount;

	public Player(String name, Strategy strategy) {
		this.name = name;
		this.strategy = strategy;
	}

	public String getName() {
		return name;
	}

	public Hand nextHand() {
		return strategy.nextHand();
	}

	public void win() {
		wincount++;
		gamecount++;
	}

	public void lose() {
		losecount++;
		gamecount++;
	}

	public void even() {
		gamecount++;
	}

	public String toString() {
		return "[" + name + "] " + gamecount + " gemes, " + wincount + " win, " + losecount + " lose";
	}
}

4-3. Interface de stratégie

C'est une interface qui représente la «stratégie» de Janken.

Strategy.java

public interface Strategy {
	public abstract Hand nextHand();
}

4-4. Classe RandomStrategy

Cette classe représente une stratégie pour effectuer des mouvements aléatoires.

RandomStrategy.java

import java.util.Random;

public class RandomStrategy implements Strategy {

	public Hand nextHand() {
		Random random = new Random();
		return Hand.getHand(random.nextInt(3));
	}
}

4-5. Classe GuuStrategy

Cette classe représente une stratégie que seul Goo peut faire.

GuuStrategy.java

public class GuuStrategy implements Strategy {

	public Hand nextHand() {
		return Hand.getHand(Hand.HANDVALUE_GUU);
	}
}

4-6. Classe principale

Cette classe effectue le traitement principal.

Main.java

public class Main {

	public static void main(String[] args) {

		Player player1 = new Player("Taro", new RandomStrategy());
		Player player2 = new Player("Hana", new GuuStrategy());
		for (int i = 0; i < 5; i++) {
			Hand nextHand1 = player1.nextHand();
			Hand nextHand2 = player2.nextHand();
			if (nextHand1.isStrongerThan(nextHand2)) {
				System.out.println("Winner:" + player1.getName());
				player1.win();
				player2.lose();
			} else if (nextHand2.isStrongerThan(nextHand1)) {
				System.out.println("Winner:" + player2.getName());
				player1.lose();
				player2.win();
			} else {
				System.out.println("Even...");
				player1.even();
				player2.even();
			}
		}

		System.out.println("----- Total result -----");
		System.out.println(player1.toString());
		System.out.println(player2.toString());
	}
}

4-7. Résultat de l'exécution

Winner:Taro
Winner:Hana
Even...
Winner:Hana
Even...
----- Total result -----
[Taro] 5 gemes, 1 win, 2 lose
[Hana] 5 gemes, 2 win, 1 lose

5. Avantages

Le modèle de stratégie sépare consciemment la partie algorithme du reste. Ensuite, seule la partie de l'interface avec l'algorithme est spécifiée, et l'algorithme est utilisé par délégation. Cela semble compliquer le programme, mais ce n'est pas le cas. Par exemple, si vous souhaitez améliorer l'algorithme pour le rendre plus rapide, si vous utilisez le modèle Stratégie, vous pouvez simplement ajouter ou modifier l'algorithme sans changer l'interface du rôle Stratégie. Il utilise un lien de délégation lâche, vous pouvez donc facilement basculer entre les algorithmes. Il peut également être utilisé pour changer le niveau de difficulté en fonction de la sélection de l'utilisateur dans les programmes de jeu.

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 l'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.