在确定在21点游戏的Java代码中执行方法的类时遇到问题。非常基本，编程新手

Question

我试图制作一个简单的用Java编写的21点游戏，包括21点（测试人员）、卡、牌组、庄家、玩家和游戏类。

我的代码仍然很不完整，但是我很难确定，一旦我创建了一副牌，我应该在哪一个类中发牌，以及我应该如何存储玩家和发牌者手中的牌对象(数组列表)。

例如，我认为我可以通过使用hand.add（deck.draw（））来解决这个问题；玩家类，从而将从我的数组卡片中抽取的卡片添加到数组列表手牌中。但是，为了做到这一点，我必须在我的玩家类中创建一个甲板对象，这与我在Game类中创建的甲板对象不同。但是，如果我使用deck.draw（）在Game类中绘制卡片，我不确定如何获取该值并将其存储在我的Player类中的数组列表手牌中。

希望这是有意义的！

本质上，我的问题是，如果我在Game类中使用我的deck.draw方法返回一张卡片，那么我如何将这张卡片存储在Player类中我的私有数组列表中？或者这是完全错误的方法？

感谢您提供的任何指导！！！

Answer 1

由于玩家手中的牌对它们没有固有的顺序，我认为使用某种Set（例如HashSet来存储它们）比像ArrayList这样的有序结构更有意义。我可能会写这样的东西。您会看到我假设Deck类的绘制方法在没有剩余牌的情况下返回null。

public class Player {
    private Set<Card> hand;
    private String name;

    public Player(String name) {
        this.name = name;
        this.hand = new HashSet<Card>();
    }

    public boolean takeCard(Deck toTakeFrom) {
        Card drawn = toTakeFrom.draw();
        if (drawn != null) {
            hand.add(drawn);
            return true;
        } else {
            System.out.format("Sorry, %s, no cards remain in the deck.%n", name);
            return false;
        }
    }
}

Answer 2

一种方法是在＜code＞Player

public class Player
{
    private ArrayList<Card> hand;

    public Player()
    {
        hand = new ArrayList<Card>();
    }

    public void AddCard(Card aCard)
    {
        hand.Add(aCard);
    }
}

Answer 3

首先，在编辑之前看到您的代码，我想指出，我认为对于一个新开发人员来说，您做得很好，请继续努力！

我认为你应该继续遵循你所走的路径……你已经使用了域语言来命名你的模型（牌组、卡、庄家等），并且你在基于模型命名这些类的行为方面也有了一个良好的开端（draw）。坚持这个。。。

无论如何，希望这有助于下文...这是伪代码(在这种情况下，我的说法是我没有在IDE上写这个，我没有验证代码...不过应该挺近的)=)

经销商应管理甲板，因此应存在聚合关系。由于庄家拥有牌组的实例（牌组由数组支持，其位置由整数记录，不需要集合类型）长度为52）。在html" target="_blank">构建时，52个卡实例被添加到阵列中。牌组确实有抽牌，增加牌位并返回牌。

//this interface will make sense a little later
public interface HandManager {

    Card draw();

}

public class Dealer implements HandManager {

    private Card[] deck;
    private int position;

    @Override
    public Card draw () {
         try {
             return deck[position];
         } catch (ArrayOutOfBoundsException ex) {
             //handle when you run out of cards in your deck...do you add another 52?
         } finally {
             position++;
         }
    }
}

庄家也有一种抽签方法，只需对玩家进行一次抽签（并将初始手牌分配给所有玩家）。

//also in Dealer
public void deal (Player... players) {
    for (Player p : players) {
        Hand hand = initializeHand(); //we'll get back to this in a bit
        p.addHand(hand);
    }
}

与此同时，玩家聚合了手......他们拥有并决定他们想用它做什么。手不应该是一个简单的数组，因为它应该能够轻松增长，所以列表或集合应该可以（集合在理论上可能更合适......但是因为你可能不需要在这里强制执行唯一性，所以真的不需要那个开销）。但是......为了将来证明它，所以如果你愿意，你可以稍后将其更改为Set，你应该对Collection接口进行编程（如果可以的话，你应该总是尝试针对最高的超类进行编程，更好地进行代码维护）。

public class Player {
    private Hand hand;

    //can be named "setHand" if you only want to support one Hand per player, named 
    //like this because it might be a fun exercise to enable n hands per player later
    public void addHand (Hand hand) {
        this.hand = hand;
    }
}

公共接口手{

/**
 * Returns the cards currently in the hand.
 *
 * Changes to the returned array are <b>NOT</b> reflected in the hand.
 */
public Card[] getCards();

public void hit();

public void split();

public void fold();

}

无论如何，玩家在手上行动，决定击中、分割、折叠等。这里最棒的是，理论上，玩家可以用这种方式管理n手；）无论如何...这是一些神奇的地方，可以让你的代码更干净：玩家和庄家之间的“交流”通过手实例发生。这允许玩家发号施令，但更重要的是，允许您的应用程序编排不关注从玩家到庄家和从庄家到玩家传递命令...而是它需要的方面：管理基于回合的游戏并知道何时结束游戏。

public class ManagedHand implements Hand {

    private Collection<Card> cards;
    private HandManager manager;

    public Hand (HandManager manager, Card[] cards) {
        this.manager = manager;
        cards = Arrays.asList(cards); //to make this a set, simply pass this into a HashSet constructor =)
    }

    /**
     * Returns the cards currently in the hand.
     *
     * Changes to the returned array are <b>NOT</b> reflected in the hand.
     */
    public Card[] getCards() {
        //bonus lesson: look up "defensive copy"
        return cards.toArray(new Card[cards.size()]);
    }

    @Override
    public void hit() {
        if (isBust()) {
            throw new BustException("Need to wait for next hand!");
        }
        //***RIGHT HERE, Dealer (the HandManager) gives the card on draw request****
        cards.add(manager.draw());
    }

    @Override
    public void split() {
        if (isBust()) {
            throw new BustException("Need to wait for next hand!");
        }
        //do split...beyond demo code scope =)
    }

    @Override
    public void fold() {
        //clean up, take money/car/happiness
    }

    @Override
    public String toString() {
        //pretty-print the current hand
    }

}


//the initializeHand method is Dealer that I promised
public Hand initializeHand() {
    Card[] initialHand = new Card[INIT_HAND_SIZE];
    for (int i =0; i<INIT_HAND_SIZE; i++) {
        initialHand[i] = draw();
    }

    //****Dealer registers itself as a HandManager to the Hand**********
    return new ManagedHand(this, initialHand);
}

由于庄家实例化（创建）手牌，它有机会为手牌上的玩家动作注册一个监听器（在本例中，它自己）。由于玩家得到了手牌的实例，在手牌上采取行动…手牌本身进行验证（即在请求更多牌之前检查自己是否失败）（只是因为让庄家这样做会是一个更复杂的例子），当需要更多牌时，经理会被“通知”。

旁注：这本可以做得更多一点，但总的来说，它有点遵循所谓的观察者模式。它可能不是这种模式的完美匹配......但是你应该去看看......并阅读所有关于设计模式的知识。在你职业生涯的早期学习这些，你会很快成为摇滚明星。