简单Blackjack实现

Question

继续我以前的职位，我已经完成了我的游戏Blackjack，简单的版本。我知道时间很长。我没有包括以前对Deck实现和涉及的其他类建议的一些更改。

这很简单，因为我省略了一些规则(我计划在将来执行这些规则)：

• 双倍
• 分裂(我认为这是最难的)
• 退休
• 当第一张卡是Ace或数字时，经销商检查第二张卡

关于Player和Dealer类：

我几乎很想创建一个超类，因为它们共享了太多的类属性和方法。但我认为“经销商”和“玩家”的概念是非常不同的概念，即使在这种情况下，他们有许多共同的特点。此外，我不知道如何命名超类。

我想知道如何使这个游戏更好的建议，并接近缺失的功能。

代码在巴斯丁。

import java.util.Stack;
import java.util.Random;
import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Iterator;

public class Blackjack {

    public static String capitalizeFirstLetter(String str) {
        return str.substring(0, 1).toUpperCase() + str.substring(1).toLowerCase();
    }

    public static class Rank {

        private int value;
        private static final String[] string_values = {
            "Ace",
            "Two",
            "Three",
            "Four",
            "Five",
            "Six",
            "Seven",
            "Eight",
            "Nine",
            "Ten",
            "Jack",
            "Queen",
            "King"
        };

        public Rank(int value) throws IllegalArgumentException {
            if (value < 1 || value > 13) {
                throw new IllegalArgumentException("Invalid card value (must be between 1 and 13).");
            }
            this.value = value;
        }

        public Rank(String value) throws IllegalArgumentException {
            int i = 0;
            String r = capitalizeFirstLetter(value);

            while (i < string_values.length && !r.equals(string_values[i])) {
                i++;
            }

            if (i == string_values.length) {
                throw new IllegalArgumentException("Invalid card rank.");
            } else {
                this.value = i + 1;
            }
        }

        public int getValue() {
            return value;
        }

        public boolean isAce() {
            return value == 1;
        }

        public String toString() {
            return string_values[value - 1];
        }

        public String simpleString() {
            String str = new String();

            if (value == 1) {
                str += "A";
            } else if (value > 10) {
                if (value == 11) {
                    str += "J";
                } else if (value == 12) {
                    str += "Q";
                } else {
                    str += "K";
                }
            } else {
                str += value;
            }
            return str;
        }
    }

    public static class Suit {

        private String name;
        private static final String[] string_names = {
            "Hearts",
            "Diamonds",
            "Clubs",
            "Spades"
        };

        public Suit(String name) throws IllegalArgumentException {
            int i = 0;
            String n = capitalizeFirstLetter(name);

            while (i < string_names.length && !n.equals(string_names[i])) {
                i++;
            }

            if (i == string_names.length) {
                throw new IllegalArgumentException("Invalid suit name.");
            } else {
                this.name = n;
            }
        }

        public String toString() {
            return name;
        }

        public String symbolString() {
            switch(name) {
                case "Hearts": return "\u2665";
                case "Diamonds": return "\u2666";
                case "Clubs": return "\u2663";
                case "Spades": return "\u2660";
                default: return null;
            }
        }
    }

    public static class Card {

        private Rank rank;
        private Suit suit;

        public Card(Rank rank, Suit suit) {
            this.rank = rank;
            this.suit = suit;
        }

        public Card(int rank, String suit) {
            this.rank = new Rank(rank);
            this.suit = new Suit(suit);
        }

        public Card(String rank, String suit) {
            this.rank = new Rank(rank);
            this.suit = new Suit(suit);
        }

        public Rank getRank() {
            return rank;
        }

        public String toString() {
            String str = rank.simpleString() + suit.symbolString() + " " + rank + " of " + suit;
            return str;
        }
    }

    public static class Deck {

        private Stack<Card> deck;
        private static final int number = 52;

        public Deck() {
            deck = new Stack<Card>();
            Suit hearts, diamonds, clubs, spades;

            hearts = new Suit("hearts");
            diamonds = new Suit("diamonds");
            clubs = new Suit("clubs");
            spades = new Suit("spades");

            Suit[] suits = { hearts, diamonds, clubs, spades };

            for (int i = 0; i < suits.length; i++) {
                for (int j = 1; j <= 13; j++) {
                    deck.push(new Card(new Rank(j), suits[i]));
                }
            }
        }

        public void shuffle() {
            long seed = System.nanoTime();
            Collections.shuffle(deck, new Random(seed));
        }

        public void add(Card card) {
            deck.push(card);
        }

        public void add(List<Card> cards) {
            for (int i = 0; i < cards.size(); i++) {
                deck.push(cards.get(i));
            }
        }

        public Card draw() {
            return deck.pop();
        }

        public boolean isEmpty() {
            return deck.isEmpty();
        } 

        public String toString() {
            String str = new String();

            for (int i = 0; i < deck.size(); i++) {
                str += deck.get(i) + "\n";
            }
            return str;
        }
    }

    public static class Hand {

        private List<Card> cards;

        public Hand() {
            cards = new ArrayList<Card>();
        }

        public void add(Card card) {
            cards.add(card);
        }

        public List<Card> cards() {
            return cards;
        }

        public int size() {
            return cards.size();
        }

        public void clear() {
            cards.clear();
        }

        public String toString() {
            String str = new String();

            for (int i = 0; i < cards.size(); i++) {
                str += "\t" + cards.get(i) + "\n";
            }
            return str;
        }

    }

    public static class Player {

        private String name;
        private int money;
        private int bet;
        private Hand hand;
        private State state;

        public static enum State { PLAYING, TWENTYONE, BLACKJACK, STAND, BUSTED, RETIRED, RUINED };

        public Player(String name, int money) {
            this.name = name;
            this.money = money;
            bet = 0;
            hand = new Hand();
            state = State.PLAYING;
        }

        public int getMoney() {
            return money;
        }

        public void setMoney(int money) {
            this.money = money;
        }

        public int getBet() {
            return bet;
        }

        public void setBet(int bet) {
            this.bet = bet;
        }

        public Hand hand() {
            return hand;
        }

        public Play choosePlay() {
            char choice;
            do {
                p(name + ", choose your play; (H)IT, (S)TAND, (D)OUBLE, S(P)LIT OR S(U)RRENDER:");
                pnln("> ");
                choice = Character.toLowerCase(in.next().charAt(0));
            } while (!(choice == 'h' || choice == 's' || choice == 'd' || choice == 'p' || choice == 'u' ));

            switch(choice) {
                case 'h': return Play.HIT;
                case 's': return Play.STAND;
                case 'd': return Play.DOUBLE;
                case 'p': return Play.SPLIT;
                case 'u': return Play.SURRENDER;
                default: return null;
            }
        }

        // public void double() {

        // }

        // public void split() {

        // }

        // public void surrender() {
        //  money =/ 2; 
        // }

        public boolean bet(int quantity) {
            int remainder = money - quantity;

            if (remainder >= 0) {
                money = remainder;
                return true;
            } else {
                return false;
            }
        }

        public void startsTurn() {
            state = State.PLAYING;
        }

        public void stand() {
            state = State.STAND;
        }

        public void busted() {
            state = State.BUSTED;
        }

        public void blackjack() {
            state = State.BLACKJACK;
        }

        public void twentyoneScore() {
            state = State.TWENTYONE;
        }

        public State getState() {
            return state;
        }

        public boolean hasBlackjack() {
            return state == State.BLACKJACK;
        }

        public boolean hasTwentyone() {
            return state == State.TWENTYONE;
        }

        public boolean isPlaying() {
            return state == State.PLAYING;
        }

        public boolean isBusted() {
            return state == State.BUSTED;
        }

        public String toString() {
            return name;
        }
    }

    public static class Dealer {

        private String name;
        private Hand hand;
        private State state;

        public static enum State { PLAYING, TWENTYONE, BLACKJACK, BUSTED };

        public Dealer() {
            name = "Dealer";
            hand = new Hand();
            state = State.PLAYING;
        }

        public Hand hand() {
            return hand;
        }

        public void startsTurn() {
            state = State.PLAYING;
        }

        public void busted() {
            state = State.BUSTED;
        }

        public void blackjack() {
            state = State.BLACKJACK;
        }

        public void twentyoneScore() {
            state = State.TWENTYONE;
        }

        public boolean isBusted() {
            return state == State.BUSTED;
        }

        public boolean hasBlackjack() {
            return state == State.BLACKJACK;
        }

        public boolean hasTwentyone() {
            return state == State.TWENTYONE;
        }

        public String toString() {
            return name;
        }

        public String initialHandString() {
            return "\t" + hand.cards().get(0) + "\n" + "\t?\n";
        }
    }

    private Deck deck;
    private Dealer dealer;
    private List<Player> players;
    private List<Card> usedCards;

    private static Scanner in = new Scanner(System.in);

    private static enum Play { HIT, STAND, DOUBLE, SPLIT, SURRENDER };

    public Blackjack(Player[] players, Deck deck) throws IllegalArgumentException {
        if (players.length < 1 || players.length > 6) {
            throw new IllegalArgumentException("Number of players must be 1-6.");
        }
        this.deck = deck;
        dealer = new Dealer();
        this.players = new ArrayList<Player>(Arrays.asList(players));
        usedCards = new ArrayList<Card>();
    }

    private boolean playersFinished() {
        for (int i = 0; i < players.size(); i++) {
            if (players.get(i).isPlaying()) {
                return false;
            }
        }
        return true;
    }

    private void resetPlayersStates() {
        for (int i = 0; i < players.size(); i++) {
            players.get(i).startsTurn();
        }
        dealer.startsTurn();
    }

    private void feedDeckIfEmpty() {
        if (deck.isEmpty()) {
            p("\nShuffling new deck...\n");
            resetDeck();
        }
    }

    private void resetDeck() {
        deck.add(usedCards);
        deck.shuffle();
        usedCards.clear();
    }

    private void placeBets() {
        p("\nPlayers, place your bets!\n");

        for (int i = 0; i < players.size(); i++) {
            Player player = players.get(i);
            int bet;
            boolean betIsPossible = false;
            do {
                pnln(player + ", place your bet: ");
                bet = in.nextInt();
                if (bet <= 0) {
                    p("Incorrect amount! Should be a possitive amount.");
                } else {
                    boolean hasMoney = player.bet(bet);
                    if (hasMoney) {
                        betIsPossible = true;
                    } else {
                        p("Incorrect amount! You don't have that much money (max. " + player.getMoney() + ").");
                    }
                }
            } while(!betIsPossible);

            player.setBet(bet);
        }
    }

    private void dealCards() {
        p("\nDealer dealing cards...\n");

        for (int i = 0; i < 2*players.size(); i++) {
            feedDeckIfEmpty();
            Card card = deck.draw();
            Player player = players.get(i % players.size());
            player.hand().add(card);
            p(player + " gets " + card);

            if ((i + 1) % players.size() == 0) {
                feedDeckIfEmpty();
                card = deck.draw();
                if (i + 1 == players.size()) {
                    p(dealer + " gets " + card);
                } else {
                    p(dealer + " gets a second card; face down");
                }
                dealer.hand().add(card);
            }
        }
    }

    private boolean isBlackjack(Hand hand) {
        if (hand.size() != 2) {
            return false;
        }
        Card card1, card2;
        card1 = hand.cards().get(0);
        card2 = hand.cards().get(1);

        boolean card1_is_ace, card2_is_ace;
        card1_is_ace = card1.getRank().isAce();
        card2_is_ace = card2.getRank().isAce();

        if (card1_is_ace && card2_is_ace) {
            return false;
        } else if (card1_is_ace) {
            return cardValue(card2) == 10;
        } else if (card2_is_ace) {
            return cardValue(card1) == 10;
        } else {
            return false;
        }
    }

    private int cardValue(Card card) {
        int rank = card.getRank().getValue();
        if (rank == 1) {
            int v;
            do {
                pnln("Choose rank for " + card + ", (1) or (11): ");
                v = in.nextInt();
                if (v == 1 || v == 11) {
                    return v;
                } else {
                    p("Invalid rank, you must choose 1 or 11.");
                }
            } while (!(v == 1 || v == 11));
        } else if (rank == 11 || rank == 12 || rank == 13) {
            return 10;
        } else {
            return rank;
        }
        return 0;
    }

    private int handValue(Hand hand) {
        List<Integer> hand_values = handValues(hand);

        if (hand_values.size() == 1) {
            return hand_values.get(0);
        } else {
            int first = hand_values.get(0), second = hand_values.get(1);
            if (first > 21 && second > 21) {
                if (first <= second) {
                    return first;
                } else {
                    return second;
                }
            } else if (first > 21) {
                return second;
            } else if (second > 21) {
                return first;
            } else if (first >= second) {
                return first;
            } else {
                return second;
            }
        }
    }

    private List<Integer> handValues(Hand hand) {
        List<Card> cards = hand.cards();
        boolean has_ace = false;
        List<Integer> hand_values = new ArrayList<Integer>();

        for (int i = 0; i < cards.size(); i++) {
            if (cards.get(i).getRank().isAce()) {
                has_ace = true;
            }
        }

        if (!has_ace) {
            int value = 0;
            for (int i = 0; i < cards.size(); i++) {
                value += cardValue(cards.get(i));
            }
            hand_values.add(value);
        } else {
            int value1 = 0, value2 = 0;

            for (int i = 0; i < cards.size(); i++) {
                Card card = cards.get(i);

                if (card.getRank().isAce()) {
                    value1 += 1;
                    value2 += 11;
                } else {
                    int val = cardValue(card);
                    value1 += val;
                    value2 += val;
                }
            }

            if (value1 <= 21 && value2 <= 21) {
                hand_values.add(value1);
                hand_values.add(value2);
            } else {
                if (value1 <= value2) {
                    hand_values.add(value1);
                } else {
                    hand_values.add(value2);
                }
            }
        }
        return hand_values;
    } 

    private String handValueString(Hand hand) {
        List<Integer> hand_values = handValues(hand);
        if (hand_values.size() == 1) {
            return Integer.toString(hand_values.get(0));
        } else {
            return hand_values.get(0) + " or " + hand_values.get(1);
        }
    }

    private void printTurnsSummary() {
        if (playersFinished()) {
            p("Dealer's hand:\n" + dealer.hand());
        } else {
            p("Dealer's hand:\n" + dealer.initialHandString());
        }
        for (int i = 0; i < players.size(); i++) {
            Player player = players.get(i);
            Hand hand = player.hand();

            p("\n< " + player + " >\nCurrent hand:\n" + hand + "\nBet: " + player.getBet() + "\n");

            switch(player.getState()) {
                case PLAYING:
                    p("This player is still on the game.");
                    break;
                case STAND:
                    p("This player chose to stand. Waiting for the end of the game.");
                    break;
                case TWENTYONE:
                    p("This played got a score of 21.");
                    break;
                case BLACKJACK:
                    p("This player got blackjack!");
                    break;
                case BUSTED:
                    p("This player was busted!");
                    break;
                case RETIRED:
                    p("This player has retired, will walk out of the game at the end with half bet back.");
                    break;
            }
            p("---------------");
        }
    }

    private void printPlayersMoney() {
        p("Players' money:\n");

        for (int i = 0; i < players.size(); i++) {
            Player player = players.get(i);
            p(player + ": " + player.getMoney());
        }
    }

    private void printPlayersHands() {
        p("\n\n---------------\nPlayers' hands:\n");

        for (int i = 0; i < players.size(); i++) {
            Player player = players.get(i);
            p(player + ":\n" + player.hand());
        }
        p("---------------\n");
    }

    private void payOutWins() {
        p("\n------------- Players Payouts ---------------\n");

        for (int i = 0; i < players.size(); i++) {
            Player player = players.get(i);
            int bet = player.getBet();

            if (dealer.hasBlackjack()) {
                if (player.hasBlackjack()) {
                    player.setMoney(player.getMoney() + bet);
                    p("Both dealer and " + player + " have blackjacks, which results in a push. Player gets back " + bet + ".");
                } else {
                    p("The dealer has blackjack, " + player + " loses bet (" + bet + ").");
                }
            } else if (player.hasBlackjack()) {
                int win = bet + bet*3/2;
                player.setMoney(player.getMoney() + win);
                p(player + " has blackjack, gets paid at 3:2, winning " + win + ".");
            } else if (player.isBusted()) {
                p(player + " got busted, loses bet (" + bet + ").");
            } else if (dealer.isBusted()) {
                p("Dealer got busted, player gets paid at 1:1, winning " + 2*bet + ".");
                player.setMoney(player.getMoney() + 2*bet);
            } else if (handValue(player.hand()) > handValue(dealer.hand())) {
                p(player + " has a higher scoring hand (" + handValue(player.hand()) + ") than dealer's " + handValue(dealer.hand()) + " , player gets paid at 1:1, winning " + 2*bet + ".");
                player.setMoney(player.getMoney() + 2*bet);
            } else if (handValue(player.hand()) < handValue(dealer.hand())) {
                p(player + " has a lower scoring hand (" + handValue(player.hand()) + ") than dealer's " + handValue(dealer.hand()) + " , player loses bet, " + bet + ".");
            } else {
                p(player + " has a the same scoring hand (" + handValue(player.hand()) + ") than dealer's " + handValue(dealer.hand()) + " , gets bet back, " + bet + ".");
                player.setMoney(player.getMoney() + bet);
            }

            p(player + "'s current money: " + player.getMoney() + "\n");
        }

        for (int i = 0; i < players.size(); i++) {
            players.get(i).setBet(0);
        }
    }

    private void clearHands() {
        for (int i = 0; i < players.size(); i++) {
            players.get(i).hand().clear();
        }
        dealer.hand().clear();
    }

    private void expelRuinedPlayers() {
        for (Iterator<Player> iterator = players.iterator(); iterator.hasNext(); ) {
            Player player = iterator.next();
            if (player.getMoney() == 0) {
                p(player + " has no money left and got kicked out of the game!");
                iterator.remove();
            }
        }
    }

    private void pressAnyKeyToContinue() {
        p("Press any key to continue...");
        try {
            System.in.read();
        } catch(Exception e) {}
    }

    public void play() {

        p("\n\n#############################\n\n   WELCOME TO BLACKJACK 21\n\n#############################\n");

        deck.shuffle();

        while (!players.isEmpty()) {

            p("\n\n--------------- NEW ROUND ---------------\n");

            printPlayersMoney();

            resetPlayersStates();

            placeBets();

            dealCards();
            printPlayersHands();
            pressAnyKeyToContinue();

            while (!playersFinished()) {

                p("\n\n--------------- NEW ROUND OF TURNS ---------------");

                for (int i = 0; i < players.size(); i++) {

                    Player player = players.get(i);

                    if (player.isPlaying()) {

                        feedDeckIfEmpty();

                        p("\n< " + player + "'s turn > | Money " + player.getMoney() + " | Bet " + player.getBet());

                        p("\nDealer's hand:\n" + dealer.initialHandString() + "\n" + player + "'s hand:\n" + player.hand());

                        if (isBlackjack(player.hand())) {
                            player.blackjack();
                            p("\nYou have blackjack!!");
                        } else {
                            Hand player_hand = player.hand();

                            p("Hand value: " + handValueString(player_hand) + "\n");

                            Play play = player.choosePlay();
                            p("");

                            switch(play) {
                                case HIT:
                                    feedDeckIfEmpty();
                                    Card card = deck.draw();
                                    p(player + " draws " + card + ".");
                                    player_hand.add(card);
                                    p("Resulting hand value: " + handValueString(player_hand));
                                    break;
                                case STAND:
                                    p(player + " stands.");
                                    player.stand();
                                    break;
                                case DOUBLE:
                                    p(player + " doubles bet.");
                                    break;
                                case SPLIT:
                                    p(player + " splits hand.");
                                    break;
                                case SURRENDER:
                                    p(player + " gives up half the bet and retires from the game.");
                                    break;
                            }

                            if (player.isPlaying()) {
                                int hand_value = handValue(player_hand);
                                if (hand_value > 21) {
                                    player.busted();
                                    p("\nYou have been busted!");
                                } else if (hand_value == 21) {
                                    player.twentyoneScore();
                                    p("\nYou got a score of 21");
                                }
                            }
                        }

                        p("\n------------------------------");
                        pressAnyKeyToContinue();
                    }
                }

                p("--------------- END OF ROUND OF TURNS --------------- \n");
                p("\n----- SUMMARY -----\n");
                printTurnsSummary();
                pressAnyKeyToContinue();
            }

            p("\n--------------------------------------\n");
            p("\n\n<<<<<<<<<<<<<<< END OF ROUND >>>>>>>>>>>>>> \n");

            Hand dealer_hand = dealer.hand();
            p("\nDealer's hand:\n" + dealer_hand);

            if (isBlackjack(dealer_hand)) {
                dealer.blackjack();
                p("\nThe dealer got blackjack!");
            } else {
                int hand_value = handValue(dealer_hand);

                while (hand_value < 17) {
                    feedDeckIfEmpty();
                    Card card = deck.draw();
                    p(dealer + " draws " + card + ".");
                    dealer_hand.add(card);
                    hand_value = handValue(dealer_hand);
                }
                p("\nDealer's final hand:\n" + dealer_hand + "\nDealer's hand value: " + hand_value + "\n");

                if (hand_value > 21) {
                    dealer.busted();
                    p("\nThe dealer got busted!");
                } else if (hand_value == 21) {
                    dealer.twentyoneScore();
                    p("\nThe dealer got a score of 21.");
                }
            }
            payOutWins();
            clearHands();
            expelRuinedPlayers();
            resetDeck();
            pressAnyKeyToContinue();
        }
    }

    public static <T> void p(T output) {
        System.out.println(output);

    }

    public static <T> void pnln(T output) {
        System.out.print(output);
    }

    public static void main(String[] args) {

        Player player1, player2, player3;
        player1 = new Player("Player 1", 500);

        Player[] players = { player1 };
        Deck deck = new Deck();

        Blackjack blackjack = new Blackjack(players, deck);

        blackjack.play();
    }
}

Answer 1

您没有提到为什么没有遵循上一篇文章中关于使用enum值而不是自定义类的建议。注意，您可以自定义一个enum。

总的来说，我认为你过多地利用了内部类。有时会这样做，但这似乎不是其中之一。请注意，Deck、Suit、Value和Card都是存在于blackjack之外的更通用的概念。Hand也存在于其他游戏中，但是规则是不同的。也许Hand应该留在Blackjack。将每个类放在一个名为tld.domain.blackjack之类的公共包中的单独文件中会更常见。

Player player1, player2, player3; player1 = new Player("Player 1", 500); Player[] players = { player1 };

您从不使用player2或player3。你其实不需要他们中的任何一个。你可以直接说

        Player[] players = { new Player("Player 1", 500) };

一般来说，如果你给变量编号，你可能做错了什么。

private static final int number = 52;

我猜你打算把这当成一张牌的数目。更直观的名称是类似于CARDS_PER_DECK或DECK_SIZE的名称。但当然，你从不使用这个常量，所以你可以去掉它。

Suit hearts, diamonds, clubs, spades; hearts = new Suit("hearts"); diamonds = new Suit("diamonds"); clubs = new Suit("clubs"); spades = new Suit("spades"); Suit[] suits = { hearts, diamonds, clubs, spades }; for (int i = 0; i < suits.length; i++) { for (int j = 1; j <= 13; j++) { deck.push(new Card(new Rank(j), suits[i])); } }

这里有一个幻数(13)。你应该摆脱它。显而易见的解决办法是一个常数，但我们可以做得更好，对西装和军衔的枚举。

            for (Suit suit : Suit.values()) {
                for (Rank rank : Rank.values()) {
                    deck.push(new Card(rank, suit));
                }
            }

这不仅更地道，而且更短。如果你真的愿意，你可以用数组代替。但enums恰恰适合这种情况。

public static class Player { private String name; private int money; private int bet; private Hand hand; private State state;

state和bet变量应该是Hand的特性，而不是Player的特征。无论是每个播放器都应该有一个手集合，或者Hand根本不应该是Player的一部分。无论做哪一件事，都会使实现拆分更加容易。

这也是为什么Player和Dealer类共享这么多方法的原因。您可以将一堆方法放在属于Hand的方法上。我不确定你是否需要一个Dealer类。跟踪一个Table可能更有意义，它将有一个播放器或手的集合(或两者兼备)。

public void busted() { state = State.BUSTED; }

如果它被称为bust而不是busted，这就更有意义了。但是在一只手中添加一张卡片应该改变手的状态，而不是外部的呼叫。也就是说，您不需要这样做，因为Hand应该在内部更改状态。

char choice; do { p(name + ", choose your play; (H)IT, (S)TAND, (D)OUBLE, S(P)LIT OR S(U)RRENDER:"); pnln("> "); choice = Character.toLowerCase(in.next().charAt(0)); } while (!(choice == 'h' || choice == 's' || choice == 'd' || choice == 'p' || choice == 'u' )); switch(choice) { case 'h': return Play.HIT; case 's': return Play.STAND; case 'd': return Play.DOUBLE; case 'p': return Play.SPLIT; case 'u': return Play.SURRENDER; default: return null; }

如果将switch移动到循环中，则可以简化事情并使其更易于扩展。

            while (true) {
                System.out.println(name + ", choose your play; (H)IT, (S)TAND, (D)OUBLE, S(P)LIT OR S(U)RRENDER:");
                System.out.print("> ");
                char choice = Character.toLowerCase(in.next().charAt(0));

                switch (choice) {
                    case 'h': return Play.HIT;
                    case 's': return Play.STAND;
                    case 'd': return Play.DOUBLE;
                    case 'p': return Play.SPLIT;
                    case 'u': return Play.SURRENDER;
                }
            }

这样，添加或删除一个选项只需要在一个地方进行更改。

我感到困惑的是，p调用System.out.println，而pnln调用System.out.print。

Answer 2

我很想知道如何让这个游戏更好.

• 遵循上一篇文章中的来自@h.j.k的建议
• 特别是enum的使用
• 覆盖Equals中的Card
• 覆盖Equals中的Hand
• Card应该知道(计算)它自己的值
  • enums让这很简单

• Hand应该知道(计算)它自己的值
  • 只需“问”每一张卡的价值是什么，并把它们加起来！
  • 知道这个值是否是敲击，崩溃，21等等，这些都是不同的分数。

• enums让这很简单
• Player应该知道它自己的手值
  • 只要“问”Hand它的价值是什么

• Dealer应该知道Players的每一只手是
  • 只要“问”Player它的价值是什么

• 用户提示字符串建议输入大写字母，但代码只检查小写。
• 如果使用cardValue() S，则不必使用enum。
• isBlackjack()是惊人的复杂。使用enums将极大地简化这段代码。

..。同时也探讨了缺失的特征。

正确地做好基础--上面的内容；然后，基于这些的代码将更容易。

但我认为“庄家”和“玩家”的概念是截然不同的。

同意。但另一方面，经销商也在玩。但他可以用不同的规则玩，不是吗？

Answer 3

而不是字符串连接(包括不必要的变量)：

    String str = rank.simpleString() + suit.symbolString() + " " + rank + " of " + suit;
    return str;

您可以更简单地编写：

    return String.format("%s%s %s of %s",
        rank.simpleString(), suit.symbolString(), rank, suit);

这也使得得到的字符串的结构一目了然。