Faites un blackjack avec Java

TL;DR J'ai recréé le blackjack créé avec TypeScript en Java pendant la période GW l'année dernière, donc ça marche mémo.

Dépôt public

GitHub

documentation doxygen

doxygen

Divers cours

Card

////////////////////////////////////////////////////////////////////////////////
///	@file			Card.java
///	@brève classe de carte
///	@author			Yuta Yoshinaga
///	@date			2019.04.27
///	$Version:		$
///	$Revision:		$
///
/// (c) 2019 Yuta Yoshinaga.
///
/// -Copie (copie) de tout ou partie de ce logiciel sans autorisation
///Ceci est une violation du droit d'auteur et est interdit.
/// -Concernant la violation ou la violation des droits de brevet ou d'autres droits causés par l'utilisation de ce produit
///Nous ne prennons aucune responsabilité.
///
////////////////////////////////////////////////////////////////////////////////

package jp.gr.java_conf.yuta_yoshinaga.java_trumpcards;

////////////////////////////////////////////////////////////////////////////////
///	@class		Card
///	@brève classe de carte
///
////////////////////////////////////////////////////////////////////////////////
public class Card {
	public static final int DEF_CARD_TYPE_JOKER = 0;
	public static final int DEF_CARD_TYPE_SPADE = 1;
	public static final int DEF_CARD_TYPE_CLOVER = 2;
	public static final int DEF_CARD_TYPE_HEART = 3;
	public static final int DEF_CARD_TYPE_DIAMOND = 4;
	public static final int DEF_CARD_TYPE_MIN = DEF_CARD_TYPE_JOKER;
	public static final int DEF_CARD_TYPE_MAX = DEF_CARD_TYPE_DIAMOND;

	public static final int DEF_CARD_VALUE_JOKER = 0;
	public static final int DEF_CARD_VALUE_MIN = 0;
	public static final int DEF_CARD_VALUE_MAX = 13;

	private int type; //!<Type de carte
	private int value; //!<Valeur de la carte
	private boolean drowFlag; //!<Indicateur de paiement par carte
	private String ext; //!<Informations d'extension de carte, etc.(Lors de l'envoi d'un message pour chaque carte, etc.)

	////////////////////////////////////////////////////////////////////////////////
	///	@constructeur bref
	///	@fn				public Card()
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public Card() {
		this.type = DEF_CARD_TYPE_JOKER;
		this.value = DEF_CARD_VALUE_JOKER;
		this.drowFlag = false;
		this.ext = "";
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				public int getType()
	///	@type de carte de retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public int getType() {
		return type;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setType(int type)
	///	@param[in]type int Type de carte
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setType(int type) {
		if(DEF_CARD_TYPE_MIN <= type && type <= DEF_CARD_TYPE_MAX){
			this.type = type;
		}
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				public getValue(): number
	///	@valeur de la carte de retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public int getValue() {
		return value;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setValue(int value)
	///	@param[in]valeur de la carte int value
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setValue(int value) {
		if(DEF_CARD_VALUE_MIN <= value && value <= DEF_CARD_VALUE_MAX){
			this.value = value;
		}
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				public boolean getDrowFlag()
	///	@indicateur de paiement de la carte de retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public boolean getDrowFlag() {
		return drowFlag;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setDrowFlag(boolean drowFlag)
	///	@param[in]booléen drowFlag drapeau de paiement
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setDrowFlag(boolean drowFlag) {
		this.drowFlag = drowFlag;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				public String getExt()
	///	@indicateur de paiement de la carte de retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public String getExt() {
		return ext;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setExt(String ext)
	///	@param[in]Informations d'extension de carte d'extension de chaîne, etc.(Lors de l'envoi d'un message pour chaque carte, etc.)
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setExt(String ext) {
		this.ext = ext;
	}

}

Une classe qui contient les informations de la carte Trump.

TrumpCards

////////////////////////////////////////////////////////////////////////////////
///	@file			TrumpCards.java
///	@brève classe de carte Trump
///	@author			Yuta Yoshinaga
///	@date			2019.04.27
///	$Version:		$
///	$Revision:		$
///
/// (c) 2019 Yuta Yoshinaga.
///
/// -Copie (copie) de tout ou partie de ce logiciel sans autorisation
///Ceci est une violation du droit d'auteur et est interdit.
/// -Concernant la violation ou la violation des droits de brevet ou d'autres droits causés par l'utilisation de ce produit
///Nous ne prennons aucune responsabilité.
///
////////////////////////////////////////////////////////////////////////////////
package jp.gr.java_conf.yuta_yoshinaga.java_trumpcards;

import java.util.ArrayList;
import java.util.Collections;

////////////////////////////////////////////////////////////////////////////////
///	@class		TrumpCards
///	@brève classe de carte Trump
///
////////////////////////////////////////////////////////////////////////////////
public class TrumpCards {
	public static final int DEF_CARD_CNT = (13 * 4);
	private ArrayList<Card> deck; //!<Plate-forme
	private int deckDrowCnt; //!<Nombre de cartes distribuées
	private int deckCnt; //!<Nombre de ponts

	////////////////////////////////////////////////////////////////////////////////
	///	@constructeur bref
	///	@fn				public TrumpCards(int jokerCnt)
	///	@param[in]int jokerCnt Nombre de jokers
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public TrumpCards(int jokerCnt) {
		this.deckCnt = DEF_CARD_CNT + jokerCnt;
		this.cardsInit();
		this.deckInit();
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				public ArrayList<Card> getDeck()
	///	@pont retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public ArrayList<Card> getDeck() {
		return deck;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setDeck(ArrayList<Card> deck)
	///	@param[in]		ArrayList<Card>pont de pont
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setDeck(ArrayList<Card> deck) {
		this.deck = deck;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				public int getDeckDrowCnt()
	///	@return Nombre de decks distribués
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public int getDeckDrowCnt() {
		return deckDrowCnt;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setDeckDrowCnt(int deckDrowCnt)
	///	@param[in]int deckDrowCnt Nombre de decks distribués
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setDeckDrowCnt(int deckDrowCnt) {
		this.deckDrowCnt = deckDrowCnt;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				public int getDeckCnt()
	///	@return Nombre de platines
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public int getDeckCnt() {
		return deckCnt;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setDeckCnt(int deckCnt)
	///	@param[in]int deckCnt Nombre de platines
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setDeckCnt(int deckCnt) {
		this.deckCnt = deckCnt;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@brève initialisation de la carte
	///	@fn				private void cardsInit()
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	private void cardsInit() {
		this.deck = new ArrayList<Card>();
		for (int i = 0; i < this.deckCnt; i++) {
			Card curCard = new Card();
			curCard.setDrowFlag(false);
			if (0 <= i && i <= 12) {
				// ***bêche*** //
				curCard.setType(Card.DEF_CARD_TYPE_SPADE);
				curCard.setValue(i + 1);
			} else if (13 <= i && i <= 25) {
				// ***Trèfle*** //
				curCard.setType(Card.DEF_CARD_TYPE_CLOVER);
				curCard.setValue((i - 13) + 1);
			} else if (26 <= i && i <= 38) {
				// ***cœur*** //
				curCard.setType(Card.DEF_CARD_TYPE_HEART);
				curCard.setValue((i - 26) + 1);
			} else if (39 <= i && i <= 51) {
				// ***diamant*** //
				curCard.setType(Card.DEF_CARD_TYPE_DIAMOND);
				curCard.setValue((i - 39) + 1);
			} else {
				// ***Joker*** //
				curCard.setType(Card.DEF_CARD_TYPE_JOKER);
				curCard.setValue((i - 52) + 1);
			}
			this.deck.add(curCard);
		}
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@brève Initialisation du deck
	///	@fn				private void deckInit()
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	private void deckInit() {
		this.deckDrowFlagInit();
		this.deckDrowCnt = 0;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@brève Initialisation du drapeau de pioche
	///	@fn				private deckDrowFlagInit(): void
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	private void deckDrowFlagInit() {
		for (int i = 0; i < this.deckCnt; i++) {
			this.deck.get(i).setDrowFlag(false);
		}
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@brève lecture de Deck shuffle
	///	@fn				public shuffle(): void
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void shuffle() {
		Collections.shuffle(this.deck);
		this.deckDrowFlagInit();
		this.deckDrowCnt = 0;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref Distribuez le deck
	///	@fn				public drowCard(): Card
	///	@classe de carte de retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public Card drowCard() {
		Card res = null;
		if (this.deckDrowCnt < this.deckCnt) {
			this.deck.get(this.deckDrowCnt).setDrowFlag(true);
			res = this.deck.get(this.deckDrowCnt++);
		}
		return res;
	}

}

Une classe qui gère des jeux de cartes à jouer.

Player

////////////////////////////////////////////////////////////////////////////////
///	@file			Player.java
///	@brève classe de joueur
///	@author			Yuta Yoshinaga
///	@date			2019.04.27
///	$Version:		$
///	$Revision:		$
///
/// (c) 2019 Yuta Yoshinaga.
///
/// -Copie (copie) de tout ou partie de ce logiciel sans autorisation
///Ceci est une violation du droit d'auteur et est interdit.
/// -Concernant la violation ou la violation des droits de brevet ou d'autres droits causés par l'utilisation de ce produit
///Nous ne prennons aucune responsabilité.
///
////////////////////////////////////////////////////////////////////////////////
package jp.gr.java_conf.yuta_yoshinaga.java_trumpcards;

import java.util.ArrayList;

////////////////////////////////////////////////////////////////////////////////
///	@class		Player
///	@brève classe de joueur
///
////////////////////////////////////////////////////////////////////////////////
public class Player {
	private ArrayList<Card> cards; //!<Carte de joueur
	private int cardsCnt; //!<Nombre de cartes de joueur
	private int score; //!<Score du joueur

	////////////////////////////////////////////////////////////////////////////////
	///	@constructeur bref
	///	@fn				public Player()
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public Player() {
		this.cards = new ArrayList<Card>();
		this.cardsCnt = 0;
		this.score = 0;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				ArrayList<Card> getCards()
	///	@retour de la carte de joueur
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public ArrayList<Card> getCards() {
		return cards;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setCards(ArrayList<Card> cards)
	///	@param[in]		ArrayList<Card>cartes cartes de joueur
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setCards(ArrayList<Card> cards) {
		this.cards = cards;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				public int getCardsCnt()
	///	@retour Nombre de cartes de joueur
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public int getCardsCnt() {
		return cardsCnt;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setCardsCnt(int cardsCnt)
	///	@param[in]int cardsCnt Nombre de cartes de joueur
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setCardsCnt(int cardsCnt) {
		this.cardsCnt = cardsCnt;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				public int getScore()
	///	@retourne le score du joueur
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public int getScore() {
		return score;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setScore(int score)
	///	@param[in]score int score du joueur
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setScore(int score) {
		this.score = score;
	}

}

Classe qui contient des informations sur les joueurs pour le Blackjack

BlackJack

////////////////////////////////////////////////////////////////////////////////
///	@file			BlackJack.java
///	@bref cours de Blackjack
///	@author			Yuta Yoshinaga
///	@date			2019.04.27
///	$Version:		$
///	$Revision:		$
///
/// (c) 2019 Yuta Yoshinaga.
///
/// -Copie (copie) de tout ou partie de ce logiciel sans autorisation
///Ceci est une violation du droit d'auteur et est interdit.
/// -Concernant la violation ou la violation des droits de brevet ou d'autres droits causés par l'utilisation de ce produit
///Nous ne prennons aucune responsabilité.
///
////////////////////////////////////////////////////////////////////////////////
package jp.gr.java_conf.yuta_yoshinaga.java_trumpcards;

import java.util.ArrayList;

////////////////////////////////////////////////////////////////////////////////
///	@class		BlackJack
///	@bref cours de Blackjack
///
////////////////////////////////////////////////////////////////////////////////
public class BlackJack {
	public static final int DEF_SHUFFLE_CNT = 10;
	private TrumpCards trumpCards; //!<atout
	private Player player; //!<joueur
	private Player dealer; //!<Marchand
	private boolean gameEndFlag; //!<Drapeau de fin de partie

	////////////////////////////////////////////////////////////////////////////////
	///	@constructeur bref
	///	@fn				public BlackJack()
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public BlackJack() {
		this.trumpCards = new TrumpCards(0);
		this.player = new Player();
		this.dealer = new Player();
		this.gameInit();
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				TrumpCards getTrumpCards()
	///	@retourner la carte Trump
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public TrumpCards getTrumpCards() {
		return trumpCards;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setTrumpCards(TrumpCards trumpCards)
	///	@param[in]TrumpCards TrumpCards Cartes Trump
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setTrumpCards(TrumpCards trumpCards) {
		this.trumpCards = trumpCards;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				public Player getPlayer()
	///	@joueur de retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public Player getPlayer() {
		return player;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setPlayer(Player player)
	///	@param[in]Joueur joueur joueur
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setPlayer(Player player) {
		this.player = player;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				public Player getDealer()
	///	@retour revendeur
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public Player getDealer() {
		return dealer;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setDealer(Player dealer)
	///	@param[in]Concessionnaire joueur
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setDealer(Player dealer) {
		this.dealer = dealer;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref getter
	///	@fn				public boolean getGameEndFlag()
	///	@retour revendeur
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public boolean getGameEndFlag() {
		return gameEndFlag;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref setter
	///	@fn				public void setGameEndFlag(boolean gameEndFlag)
	///	@param[in]booléen gameEndFlag Drapeau de fin de jeu
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void setGameEndFlag(boolean gameEndFlag) {
		this.gameEndFlag = gameEndFlag;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@brève initialisation du jeu
	///	@fn				public void gameInit()
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void gameInit() {
		this.gameEndFlag = false;
		// ***Mélange de deck*** //
		for (int i = 0; i < DEF_SHUFFLE_CNT; i++) {
			this.trumpCards.shuffle();
		}
		// ***Initialisation joueur / croupier*** //
		this.player.setCards(new ArrayList<Card>());
		this.player.setCardsCnt(0);
		this.dealer.setCards(new ArrayList<Card>());
		this.dealer.setCardsCnt(0);
		// ***Distribuez 2 joueurs / croupiers chacun*** //
		for (int i = 0; i < 2; i++) {
			this.player.getCards().add(this.trumpCards.drowCard());
			this.player.setCardsCnt(this.player.getCardsCnt() + 1);
			this.dealer.getCards().add(this.trumpCards.drowCard());
			this.dealer.setCardsCnt(this.dealer.getCardsCnt() + 1);
		}
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref joueur touché
	///	@fn				public void playerHit()
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void playerHit() {
		if (this.gameEndFlag == false) {
			this.player.getCards().add(this.trumpCards.drowCard());
			this.player.setCardsCnt(this.player.getCardsCnt() + 1);
			int score = this.getScore(this.player.getCards(), this.player.getCardsCnt());
			if (22 <= score)
				this.playerStand(); //Résiliation forcée parce qu'elle a éclaté
		}
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref stand de joueur
	///	@fn				public void playerStand()
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void playerStand() {
		this.dealerHit();
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref coup de croupier
	///	@fn				private void dealerHit()
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	private void dealerHit() {
		for (;;) {
			int score = this.getScore(this.dealer.getCards(), this.dealer.getCardsCnt());
			if (score < 17) {
				// ***Croupiers jusqu'à ce que le nombre total de cartes qu'ils possèdent soit égal ou supérieur à «17»*** //
				// ***Continuez à frapper (continuez à dessiner des cartes)*** //
				this.dealer.getCards().add(this.trumpCards.drowCard());
				this.dealer.setCardsCnt(this.dealer.getCardsCnt() + 1);
			} else {
				// ***Lorsque le nombre total de cartes en main est de «17» ou plus*** //
				// ***Restez (ne tirez pas de carte).*** //
				this.dealerStand();
				break;
			}
		}
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref stand du concessionnaire
	///	@fn				private void dealerStand()
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	private void dealerStand() {
		this.gameEndFlag = true;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref Obtenez le score actuel de votre main
	///	@fn				public int getScore(ArrayList<Card> cards,int cardsCnt)
	///	@param[in]		ArrayList<Card>main de cartes
	///	@param[in]int cardsCnt Nombre de cartes en main
	///	@retour Score actuel
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public int getScore(ArrayList<Card> cards, int cardsCnt) {
		int res = 0;
		boolean aceFlag = false;
		for (int i = 0; i < cardsCnt; i++) {
			if (2 <= cards.get(i).getValue() && cards.get(i).getValue() <= 10) {
				// *** 2～10 *** //
				res += cards.get(i).getValue();
			} else if (11 <= cards.get(i).getValue() && cards.get(i).getValue() <= 13) {
				// *** 11～13 *** //
				res += 10;
			} else {
				if (aceFlag) {
					// ***Le deuxième as est converti de force en 1.*** //
					res += 1;
				} else {
					// ***L'as sera calculé plus tard*** //
					aceFlag = true;
				}
			}
		}
		if (aceFlag) {
			// ***Calcul de l'as*** //
			var tmpScore1 = res + 1;
			var tmpScore2 = res + 11;
			var diff1 = 21 - tmpScore1;
			var diff2 = 21 - tmpScore2;
			if ((22 <= tmpScore1) && (22 <= tmpScore2)) {
				// ***1 as si les deux éclatent*** //
				res = tmpScore1;
			} else if ((22 <= tmpScore1) && (tmpScore2 <= 21)) {
				// ***Si l'as éclate à 1, alors l'as est 11*** //
				res = tmpScore2;
			} else if ((tmpScore1 <= 21) && (22 <= tmpScore2)) {
				// ***Si l'as éclate à 11, 1 as*** //
				res = tmpScore1;
			} else {
				// ***Si ni l'un ni l'autre n'éclate, utilisez celui avec la plus petite différence par rapport à 21.*** //
				if (diff1 < diff2)
					res = tmpScore1;
				else
					res = tmpScore2;
			}
		}
		return res;
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@Bref jugement de victoire / perte de jeu
	///	@fn				public int gameJudgment()
	///	@retour du jugement de victoire / perte du jeu
	///					- 1 :Victoire du joueur
	///					- 0 :dessiner
	///					- -1 :Défaite du joueur
	///
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public int gameJudgment() {
		int res = 0;
		int score1 = this.getScore(this.player.getCards(), this.player.getCardsCnt());
		int score2 = this.getScore(this.dealer.getCards(), this.dealer.getCardsCnt());
		int diff1 = 21 - score1;
		int diff2 = 21 - score2;
		if (22 <= score1 && 22 <= score2) {
			// ***Perdre parce que les joueurs et les croupiers éclatent*** //
			res = -1;
		} else if (22 <= score1 && score2 <= 21) {
			// ***Perdre parce que le joueur éclate*** //
			res = -1;
		} else if (score1 <= 21 && 22 <= score2) {
			// ***Gagnez parce que le croupier éclate*** //
			res = 1;
		} else {
			if (diff1 == diff2) {
				// ***Dessiner si le score est le même*** //
				res = 0;
				if (score1 == 21 && this.player.getCardsCnt() == 2 && this.dealer.getCardsCnt() != 2) {
					// ***Si seulement le joueur est pur blackjack, le joueur gagne*** //
					res = 1;
				}
			} else if (diff1 < diff2) {
				// ***Le joueur est plus proche de 21 donc il gagne*** //
				res = 1;
			} else {
				// ***Le croupier est plus proche de 21, donc je perds*** //
				res = -1;
			}
		}
		return res;
	}

}

Blackjack Une classe qui gère le jeu et le statut du joueur.

BlackJackMain

////////////////////////////////////////////////////////////////////////////////
///	@file			BlackJackMain.java
///	@brève classe principale de Blackjack
///	@author			Yuta Yoshinaga
///	@date			2019.04.27
///	$Version:		$
///	$Revision:		$
///
/// (c) 2019 Yuta Yoshinaga.
///
/// -Copie (copie) de tout ou partie de ce logiciel sans autorisation
///Ceci est une violation du droit d'auteur et est interdit.
/// -Concernant la violation ou la violation des droits de brevet ou d'autres droits causés par l'utilisation de ce produit
///Nous ne prennons aucune responsabilité.
///
////////////////////////////////////////////////////////////////////////////////
package jp.gr.java_conf.yuta_yoshinaga.java_trumpcards;

import java.util.ArrayList;
import java.util.Scanner;

////////////////////////////////////////////////////////////////////////////////
///	@class		BlackJackMain
///	@brève classe principale de Blackjack
///
////////////////////////////////////////////////////////////////////////////////
public class BlackJackMain {

	////////////////////////////////////////////////////////////////////////////////
	///	@brève méthode principale
	///	@fn				public static void main(String[] args)
	///	@param[in]		String[] args
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public static void main(String[] args) {
		BlackJackMain blackJackMain = new BlackJackMain();
		BlackJack blackJack = new BlackJack();
		Scanner sc = new Scanner(System.in);
		while (true) {
			System.out.println("Please enter a command.");
			System.out.println("q ・ ・ ・ quitter");
			System.out.println("r ・ ・ ・ réinitialiser");
			System.out.println("h ・ ・ ・ frappé");
			System.out.println("s ・ ・ ・ stand");
			blackJackMain.showStatus(blackJack);
			String inputStr = sc.nextLine();
			switch (inputStr) {
			case "q":
			case "quit":
				// quit
				System.out.println("bye.");
				sc.close();
				System.exit(0);
				break;
			case "r":
			case "reset":
				// reset
				blackJack.gameInit();
				break;
			case "h":
			case "hit":
				// hit
				blackJack.playerHit();
				break;
			case "s":
			case "stand":
				// stand
				blackJack.playerStand();
				break;
			default:
				// Unsupported command
				System.out.println("Unsupported command.");
				break;
			}
		}

	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref affichage de l'état
	///	@fn				public void showStatus(BlackJack blackJack)
	///	@param[in]		BlackJack blackJack
	///	@non-retour
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public void showStatus(BlackJack blackJack) {
		System.out.println("----------");
		// dealer
		ArrayList<Card> dc = blackJack.getDealer().getCards();
		int dcc = blackJack.getDealer().getCardsCnt();
		System.out.println("dealer score " + (blackJack.getGameEndFlag() ? blackJack.getScore(dc, dcc) : ""));
		String cardStr = "";
		if (blackJack.getGameEndFlag()) {
			for (int i = 0; i < dcc; i++) {
				if (i != 0)
					cardStr += ",";
				cardStr += getCardStr(dc.get(i));
			}
		} else {
			cardStr = getCardStr(dc.get(0)) + ",*";
		}
		System.out.println(cardStr);
		System.out.println("----------");
		// player
		ArrayList<Card> pc = blackJack.getPlayer().getCards();
		int pcc = blackJack.getPlayer().getCardsCnt();
		System.out.println("player score " + blackJack.getScore(pc, pcc));
		cardStr = "";
		for (int i = 0; i < pcc; i++) {
			if (i != 0)
				cardStr += ",";
			cardStr += getCardStr(pc.get(i));
		}
		System.out.println(cardStr);
		System.out.println("----------");
		if (blackJack.getGameEndFlag()) {
			if (blackJack.gameJudgment() == 1) {
				System.out.println("You are the winner.");
			} else if (blackJack.gameJudgment() == 0) {
				System.out.println("It is a draw.");
			} else {
				System.out.println("It is your loss.");
			}
			System.out.println("----------");
		}
	}

	////////////////////////////////////////////////////////////////////////////////
	///	@bref Obtenir la chaîne d'informations sur la carte
	///	@fn				public String getCardStr(Card card)
	///	@param[in]		Card card
	///	@return Obtenir la chaîne d'informations sur la carte
	///	@author			Yuta Yoshinaga
	///	@date			2019.04.27
	///
	////////////////////////////////////////////////////////////////////////////////
	public String getCardStr(Card card) {
		String res = "";
		switch (card.getType()) {
		case Card.DEF_CARD_TYPE_SPADE:
			res = "SPADE ";
			break;
		case Card.DEF_CARD_TYPE_CLOVER:
			res = "CLOVER ";
			break;
		case Card.DEF_CARD_TYPE_HEART:
			res = "HEART ";
			break;
		case Card.DEF_CARD_TYPE_DIAMOND:
			res = "DIAMOND ";
			break;
		default:
			res = "Unsupported card";
			break;
		}
		res = res + card.getValue();
		return res;
	}
}

Une classe pour jouer à des jeux de blackjack sur console. Exécutez l'action correspondante en réponse à l'entrée de la console.

Impressions

• La classe a été conçue pour être aussi orientée objet que possible. ―― Puisque je suis actuellement impliqué dans les applications de console Java, je l'ai créé avec des applications de console. ――Si possible, j'aimerais créer une version de servlet et en faire une application Web à l'avenir. «Le premier jour des vacances consécutives du GW10, j'ai commencé à travailler avec une tension étrange qui me faisait trop faire une sieste et ne pouvait pas dormir la nuit. ――Le temps de travail est d'environ 2 heures. C'est bien car vous pouvez facilement créer une application console.