[JAVA] Entwurfsmuster ~ Strategie ~

1. Zuallererst

Wir werden das ** Strategiemuster ** im GoF-Entwurfsmuster zusammenfassen.

2. Wie ist das Strategiemuster?

• Das englische Wort Strategie bedeutet ** Strategie **. Bei der Programmierung können Sie sich das als ** Algorithmus ** vorstellen.
• Jedes Programm wurde geschrieben, um ein Problem zu lösen. Bestimmte Algorithmen wurden implementiert, um das Problem zu lösen. Das Strategiemuster ist eine Methode, mit der Sie den Teil austauschen können, der den Algorithmus implementiert.
• Die GoF-Entwurfsmuster werden als ** Verhaltensentwurfsmuster ** klassifiziert.

3. Beispielklassendiagramm

4. Beispielprogramm

Es ist ein Programm, um Stein-Papier-Scheren zu machen. Es gibt eine Strategie, um sich zufällig zu bewegen, und eine Strategie, um nur Goo zu bewegen.

4-1. Handklasse

Dies ist eine Klasse, die die Hände von Janken repräsentiert.

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) {
		//wahr, wenn dies stärker als h ist
		return fight(h) == 1;
	}

	private int fight(Hand h) {
		if (this == h) {
			//zeichnen
			return 0;
		} else if ((this.handvalue + 1) % 3 == h.handvalue) {
			//dieser Sieg
			return 1;
		} else {
			//h gewinnen
			return -1;
		}
	}
}

4-2. Spielerklasse

Diese Klasse repräsentiert den Spieler, der das Spiel spielt.

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. Strategie-Schnittstelle

Es ist eine Schnittstelle, die die "Strategie" von Janken darstellt.

Strategy.java

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

4-4. RandomStrategy-Klasse

Diese Klasse stellt eine Strategie dar, um zufällige Bewegungen auszuführen.

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. GuuStrategy-Klasse

Diese Klasse stellt eine Strategie dar, die nur Goo ausführen kann.

GuuStrategy.java

public class GuuStrategy implements Strategy {

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

4-6 Hauptklasse

Diese Klasse führt die Hauptverarbeitung durch.

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 Ausführungsergebnis

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. Vorteile

Das Strategiemuster trennt den Algorithmus-Teil bewusst vom Rest. Dann wird nur der Teil der Schnittstelle mit dem Algorithmus angegeben, und der Algorithmus wird von der Delegierung verwendet. Dies scheint das Programm zu komplizieren, ist es aber nicht. Wenn Sie beispielsweise den Algorithmus verbessern möchten, um ihn schneller zu machen, und das Strategiemuster verwenden, können Sie den Algorithmus einfach hinzufügen oder ändern, ohne die Schnittstelle der Strategierolle zu ändern. Es wird eine lose Delegationsbindung verwendet, sodass Sie problemlos zwischen Algorithmen wechseln können. Es kann auch verwendet werden, um den Schwierigkeitsgrad entsprechend der Auswahl des Benutzers in Spielprogrammen zu ändern.

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 der Entwurfsmuster und Beispielprogramme sind geschrieben. Schauen Sie sich also auch die Bücher an.