[JAVA] Modèle de stratégie

Quel est le modèle de stratégie?

Chaque programme est écrit pour résoudre un problème. Et certains algorithmes sont mis en œuvre pour résoudre le problème. Dans le modèle Stratégie, la partie qui implémente l'algorithme peut être échangée. Un modèle qui permet de changer d'algorithme facilement et de résoudre le même problème différemment.

Le rôle de la stratégie

Le rôle qui définit l'interface d'utilisation de la stratégie.

package strategy;

public interface Strategy {
	//Décidez quoi faire ensuite
	public abstract Hand nexHand();
	//Découvrez si vous avez gagné avec le dernier coup
	public abstract void study(boolean win);
}

Le rôle de la stratégie concrète

Le rôle qui implémente réellement l'interface du rôle Stratégie. Ici, la stratégie (stratégie, méthode, politique, algorithme) est en fait programmée.

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);
	}

	/**
	 *Si vous gagnez la dernière fois, faites le même coup, si vous perdez, décidez le coup au hasard
	 */
	@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;
	//Tableau de calcul des probabilités reflétant les victoires et les pertes passées
	//[La dernière main][Mains à éteindre cette fois]
	private int[][] history = {
			{1,1,1,},
			{1,1,1,},
			{1,1,1,},
	};

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

	/**
	 *Calculer avec probabilité à partir de la valeur de l'histoire
	 *Par exemple, histoire[0][0]La valeur de est 3, histoire[0][1]La valeur de est 5, histoire[0][2]Si la valeur de est 7
	 *Goo, choki, par 3:5:Déterminez le coup suivant comme 7.
	 *0 ou plus et moins de 15(15 est 3+5+Valeur totale de 7)Obtenez la valeur aléatoire de
	 *Goo si 0 ou plus et moins de 3
	 *Choki si 3 ou plus et moins de 8
	 *Par si 8 ou plus et moins de 15
	 *À
	 */
	@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;
	}

	/**
	 *Mettre à jour le contenu du champ d'historique en fonction de la victoire ou de la perte de la main retournée par la méthode nextHand
	 *
	 */
	@Override
	public void study(boolean win) {
		if (win) {
			history[prevHandValue][currentHandValue]++;
		} else {
			history[prevHandValue][(currentHandValue + 1) % 3]++;
			history[prevHandValue][(currentHandValue + 2) % 3]++;
		}
	}
}

Le rôle du contexte

Un rôle qui utilise le rôle Stratégie. Ayez une instance du rôle ConcreateStrategy et utilisez-la si nécessaire. C'est l'interface qui joue le rôle de stratégie.

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() {
		//C'est votre "stratégie" qui décide de votre prochain mouvement
		return strategy.nextHand();
	}

	public void win() {
		//Changer l'état interne de la stratégie
		strategy.study(true);
		winCount++;
		gameCount++;
	}

	public void lose() {
		//Changer l'état interne de la stratégie
		strategy.study(false);
		loseCount++;
		gameCount++;
	}

	public void even() {
		gameCount++;
	}

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

Votre interlocuteur

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);

	}
}

Résultat d'exécution

https://github.com/aki0207/strategy

Je l'ai utilisé comme référence. Édition révisée augmentée Introduction aux modèles de conception appris en langage Java