[JAVA] Strategiemuster

Was ist das Strategiemuster?

Jedes Programm ist geschrieben, um ein Problem zu lösen. Und bestimmte Algorithmen werden implementiert, um das Problem zu lösen. Im Strategiemuster kann der Teil, der den Algorithmus implementiert, ausgetauscht werden. Ein Muster, das es einfach macht, Algorithmen zu wechseln und dasselbe Problem unterschiedlich zu lösen.

Die Rolle der Strategie

Die Rolle, die die Schnittstelle für die Verwendung der Strategie definiert.

package strategy;

public interface Strategy {
	//Entscheiden Sie, was als nächstes zu tun ist
	public abstract Hand nexHand();
	//Erfahren Sie, ob Sie mit dem letzten Zug gewonnen haben
	public abstract void study(boolean win);
}

Die Rolle der konkreten Strategie

Die Rolle, die die Schnittstelle der Strategierolle tatsächlich implementiert. Hier wird die Strategie (Strategie, Methode, Richtlinie, Algorithmus) tatsächlich programmiert.

package strategy;

import java.util.Random;

public class WinningStrategy implements Strategy{
	private Random random;
	private boolean won = false;
	private Hand prevHand;

	public WinningStrategy(int seed) {
		random = new Random(seed);
	}

	/**
	 *Wenn Sie das letzte Mal gewinnen, machen Sie den gleichen Zug. Wenn Sie verlieren, entscheiden Sie den Zug nach dem Zufallsprinzip
	 */
	@Override
	public Hand nextHand() {
		if (!won) {
			prevHand = Hand.getHand(random.nextInt(3));
		}
		return prevHand;
	}

	@Override
	public void study(boolean win) {
		won = win;
	}
}

package strategy;

import java.util.Random;

public class ProbStrategy implements Strategy {
	private Random random;
	private int prevHandValue = 0;
	private int currentHandValue = 0;
	//Tabelle zur Wahrscheinlichkeitsberechnung, die vergangene Gewinne und Verluste widerspiegelt
	//[Die letzte Hand][Hände zum Löschen dieses Mal]
	private int[][] history = {
			{1,1,1,},
			{1,1,1,},
			{1,1,1,},
	};

	public ProbStrategy(int seed) {
		random = new Random(seed);
	}

	/**
	 *Berechnen Sie mit Wahrscheinlichkeit aus dem Wert der Geschichte
	 *Zum Beispiel Geschichte[0][0]Der Wert von ist 3, Geschichte[0][1]Der Wert von ist 5, Geschichte[0][2]Wenn der Wert von 7 ist
	 *Goo, Choki, Par 3:5:Bestimmen Sie den nächsten Zug als 7.
	 *0 oder mehr und weniger als 15(15 ist 3+5+Gesamtwert von 7)Holen Sie sich den zufälligen Wert von
	 *Goo wenn 0 oder mehr und weniger als 3
	 *Choki wenn 3 oder mehr und weniger als 8
	 *Par wenn 8 oder mehr und weniger als 15
	 *Zu
	 */
	@Override
	public Hand nextHand() {
		int bet = random.nextInt(getSum(currentHandValue));
		int handValue = 0;
		if (bet < history[currentHandValue][0]) {
			handValue = 0;
		} else if (bet < history[currentHandValue][0] + history[currentHandValue][1]) {
			handValue = 1;
		} else {
			handValue = 2;
		}

		prevHandValue = currentHandValue;
		currentHandValue = handValue;
		return Hand.getHand(handValue);
	}

	private int getSum(int hv) {
		int sum = 0;
		for (int i = 0; i < 3; i++) {
			sum += history[hv][i];
		}
		return sum;
	}

	/**
	 *Aktualisieren Sie den Inhalt des Verlaufsfelds basierend auf dem Gewinn oder Verlust der von der nextHand-Methode zurückgegebenen Hand
	 *
	 */
	@Override
	public void study(boolean win) {
		if (win) {
			history[prevHandValue][currentHandValue]++;
		} else {
			history[prevHandValue][(currentHandValue + 1) % 3]++;
			history[prevHandValue][(currentHandValue + 2) % 3]++;
		}
	}
}

Die Rolle des Kontexts

Eine Rolle, die die Strategie-Rolle verwendet. Verfügen Sie über eine Instanz der ConcreateStrategy-Rolle und verwenden Sie sie nach Bedarf. Es ist die Schnittstelle, die die Rolle der Strategie spielt.

package strategy;

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 Hand nextHand() {
		//Es ist Ihre "Strategie", die tatsächlich über Ihren nächsten Schritt entscheidet
		return strategy.nextHand();
	}

	public void win() {
		//Ändern Sie den internen Status der Strategie
		strategy.study(true);
		winCount++;
		gameCount++;
	}

	public void lose() {
		//Ändern Sie den internen Status der Strategie
		strategy.study(false);
		loseCount++;
		gameCount++;
	}

	public void even() {
		gameCount++;
	}

	public String toString() {
		return "[" + name + ":" + gameCount + " games, " + winCount + " win, " +
	loseCount + " lose" + "]";
	}
}

Anrufer

package strategy;

public class Main {
	public static void main(String[] args) {
		if (args.length != 2) {
			System.out.println("Usage: java Main randmeseed1 randomeseed2");
			System.out.println("Example: java Main 314 15");
			System.exit(0);
		}

		int seed1 = Integer.parseInt(args[0]);
		int seed2 = Integer.parseInt(args[1]);
		Player p1 = new Player("Jiro", new WinningStrategy(seed1));
		Player p2 = new Player("Taro", new ProbStrategy(seed2));
		for (int i = 0; i < 10000; i++) {
			Hand nexHand1 = p1.nextHand();
			Hand nexHand2 = p2.nextHand();
			if (nexHand1.isStrongerThan(nexHand2)) {
				System.out.println("Winner:" + p1);
				p1.win();
				p2.lose();
			} else if (nexHand2.isStrongerThan(nexHand1)) {
				System.out.println("Winner:" + p2);
				p1.lose();
				p2.win();
			} else {
				System.out.println("Even…");
				p1.even();
				p2.even();
			}
		}

		System.out.println("Total result:");
		System.out.println(p1);
		System.out.println(p2);

	}
}

Ausführungsergebnis

https://github.com/aki0207/strategy

Ich habe dies als Referenz verwendet. Erweiterte überarbeitete Ausgabe Einführung in in Java gelernte Entwurfsmuster