OOP Design per le classi di giochi di carte

Question

Quale sarebbe l'approccio migliore quando si progettano le seguenti classi applicando modelli di progettazione?

• Deck-AggiungeCarta, affare, shuffle, getTopCard, removeTopCard, removeAllCards
• mano-AggiungeCarta, RimuoviCarta, getCard, removeAllCards
• DiscardPile-AggiungeCarta, getTopCard , removeTopCard, removeAllCards
• MeldPile-AggiungeCarta, removeAllCards

(Il MeldPile detiene tutte le combinazioni nella tabella.)

Per quanto mi riguarda, penso che il getTopCard e removeTopCard sono solo un involucro di getCard e removeCard, come basta prendere la prima posizione di una carta e poi passarla a getCard o removeCard.

Devo usare la composizione? modello di strategia? o semplicemente creare un'altra classe chiamata CardPile e usarla come classe base della classe precedente? Apprezzo davvero se tu potessi fornire un codice di esempio su questo.

Answer 1

Penso che tu possa ottenere quello che vuoi con una classe single deck come di seguito che è essenzialmente un wrapper attorno a Stack, non vedo perché nessun mazzo/pila/mano particolare non vorrebbe più se non tutto lo stesso metodi.

class Deck { 
    private Stack<Card> cards = new Stack<Card>(); 

    public Deck() { } 

    public Deck(int numberOfCards) { 
     for (int i=0; i<numberOfCards; i++) { 
      cards.push(CardFactory.createCard(i)); 
     } 
    } 

    private void shuffle() { 
     Collections.shuffle(this.cards); 
    } 

    public void sort() { 
     Collections.sort(this.cards); 
    } 

    public void removeAllCards() { 
     this.cards.removeAllElements(); 
    } 

    public void removeCard(Card c) { 
     int i = this.cards.search(c); 
     this.cards.remove(i);    
    } 

    public Card getCard(Card c) { 
     int i = this.cards.search(c); 
     return this.cards.get(i); 
    } 

    public Card getTopCard() { 
     return this.cards.pop(); 
    } 

    public Card getNthCard(int i) { 
     return this.cards.get(i); 
    } 

    public Card addCard(Card c) { 
     this.cards.push(c); 
    } 

} 

L'unico vero problema che vedo è il metodo deal() e se questo dovrebbe essere la responsabilità di un ponte? Personalmente io non la penso così, questo mi porta a pensare che forse si potrebbe avere una classe Player e una classe del rivenditore che si estende Player e implementa la logica di affrontare un mazzo

class Player() { 
    protected String name; 
    protected Deck hand = new Deck(); 

    public void addCard(Card c) { 
     this.hand.addCard(c); 
    } 

    // ..... 
} 

class Dealer() extends Player { 
    private Deck deck; 

    public Dealer(int deckSize) { 
     this.deck = new Deck(deckSize); 
    } 

    public void deal(Player[] players, int numberOfCards) { 
     for (player in players) { 
      for (int i=0; i<numberOfCards; i++) { 
       player.addCard(this.deck.getTopCard()); 
      } 
     } 
    } 

    // ..... 
}