Dealing with cards in a deck

[Shawn Gordian]

I have the following code and what I want to figure out is when I deal out the card and face them down I want to take the top card and show its value and suit. I already know how to deal the cards to the players and flip the cards. Just need help/advice on showing that card.


Here is deck class

package wargame;
import java.util.Random;

public class Deck 
{
   final int SIZE = 52;
   private Card[] deck;
   private int topCard;
   
   public Deck()
   {
     deck = new Card[SIZE];
     
     for (int i = 0; i < SIZE; i++)
     {
        int suit = i/13;         // for suits clubs - hearts
        Card.Suit theSuit = Card.Suit.diamonds;
        switch(suit)
        {
           case 0: theSuit = Card.Suit.diamonds; break;
           case 1: theSuit = Card.Suit.hearts; break;
           case 2: theSuit = Card.Suit.spades; break;
           case 3: theSuit = Card.Suit.clubs; break;
        }
        int val = (i % 13) + 2;  // for values 2 - A
        deck[i] = new Card(val, theSuit);
        
     }
     
   }
    /**
     * 
     * @return the entire 52 cards of the deck as one string
     */
    public String toString()
    {
        String sDeck = "";
        
        for (int i = 0; i < 52; i++)
        {
            if ( i % 4 == 0)
            {
                sDeck += "\n";
            }
            sDeck += ("\t" + deck[i]);
        }
        sDeck += "\n";
        return sDeck;
    }
    /**
     * shuffle()  -- mixes up the cards in the deck
     * preconditions: none
     * postconditions:  mixes up the cards (shuffles them) and reset
     *                  topCard to 0
     */
    public void shuffle()
    {
        Random rand = new Random();
        Card temp = new Card();
        
        for (int i = 0; i < 3; i++)
        {
            for ( int c = 0; c< SIZE; c++)
            {
              int itemp = rand.nextInt(SIZE);
              temp = deck[c];
              deck[c] = deck[itemp];
              deck[itemp] = temp;
            }
        }
        topCard = 0;
    }
 /**
    * dealACard
    * @return top card from the deck
    * preconditions:  we haven't exhausted the deck...topCard < NUMCARDS
    * postconditions: return the top Card from the deck and increment topCard
    */ 
    public Card dealACard()
    {
       if (topCard >= SIZE)
          shuffle();
      return deck[topCard++];  
    }   
}

Here is card class

package wargame;


public class Card 
{
  public enum Suit { diamonds, hearts, spades, clubs}
  public enum Color {red, black}
  private Suit suit;   // Card's suit
  private Color color; // Card's color
  private int value;   // Card's value (2 .. 14)
  public static final char diamondsChar = ('\u2666');
  public static final char heartsChar = ('\u2665');
  public static final char spadesChar = ('\u2660');
  public static final char clubsChar = ('\u2663');
  public static final String red = (char)27 + "[31m";
  public static final String reset = (char)27 + "[0m";
 
/**
 * default constructor -- Creates a 7 of hearts
 */  
  public Card()
  {
      value = 7;
      suit = Suit.hearts;
      color = Color.red;
  }
  
/**
 * conversion constructor 
 * preconditions: input v is 2..14 and (valid Suit)
 * postconditions: set the value to input v if valid and suit to input s
 *                 otherwise exit the program
 */  
 public Card(int v, Suit s)
 {
   if ( v < 15 && v > 1)
   {
       value = v;
       suit = s;
       if (suit == Suit.clubs || suit == Suit.spades)
           color = Color.black;
       else
           color = Color.red;
   }
   else
   {
       System.out.println(" Invalid card construction attempted");
       System.exit(1);
   }
 }
 /**
  * void setValue():  mutator method
  * @param v is input value for the Card (range must be 2 - 14)
  * preconditions: input v  is 2 .le. v .le. 14 
  * postconditions: if v is valid; change the value, otherwise ignore input
  */
  public void setValue(int v)
  {
    if (2 <= v && v <= 14)
    {
        value = v;
    }
    
  }
/**
 * int getValue(): Accessor
 * @return int value -- face value of the card (2..10) J:11, Q:12, K:13, A:14
 */
 public int getValue()
 {
     return value;
 }
 /**
  * void setSuit(): Mutator: used to change a Card's suit
  * @param s suit for card {must be Suit. hearts, diamonds, spades, or clubs)
  * preconditions: none
  * postconditions: changes the suit of the card to input s
  */
 public void setSuit( Suit s)
 {
    suit = s; 
    if (suit == Suit.clubs || suit == Suit.spades)
           color = Color.black;
       else
           color = Color.red;
 }
/**
 * Suit getSuit(): Accessor - returns a copy of the Card's suit
 * @return suit of the card
 * preconditions: none
 * postconditions: returns the suit of the card to caller
 */          
 public Suit getSuit()
 {
     return suit;
 }
 /**
 * Suit getColor(): Accessor - returns a copy of the Card's color (red/black)
 * @return Color of the card
 * preconditions: none
 * postconditions: returns the color of the card to caller
 */          
 public Color getColor()
 {
     return color;
 }
 
/**
 * String toString() : Accessor
 * @return A String output for the Card..
 */  
 public String toString()
 {
     String cVal = "";
     switch(value)
     {
         case 11: cVal += "J"; break;
         case 12: cVal += "Q"; break;
         case 13: cVal += "K"; break;
         case 14: cVal += "A"; break;
         default: cVal += value; break;        
     }
     String cSuit = "";
     if (suit == Suit.hearts) cSuit += red + heartsChar + reset;
     else if (suit == Suit.diamonds) cSuit += red + diamondsChar + reset;
     else if (suit == Suit.spades) cSuit += spadesChar;
     else // suit is clubs
         cSuit += clubsChar;
    cVal += cSuit;  return cVal;  
   //  return (cVal.concat(cSuit));
 }
 /** Accessor: equals()
  * if the comp card and the current card have the same value
  * return true; otherwise return false
  * @param comp card to compare for equal value
  * @return boolean true or false
  */
 public boolean equals(Card comp)
 {
    if (value == comp.getValue())
       return true;
    else
       return false;
 }
          
}

Here is where my problem is

package wargame;


public class Player 
{
    private int score,  // number of tricks won so far
                hCount; // number of cards in hand so far
    private Card[] hand; // player's cards
    private String name; // player's name
   
    /**
     * C O N S T R U C T O R
     */
    public Player()
    {
        hCount = 0;
        score = 0;
        hand = new Card[26];
        for ( int i = 0; i < 26; i++)
        {
            hand[i] = new Card();
        }
    }
    /**
     * Mutator: acceptACard()
     * @param c is the card dealt to the player, which he/she adds to hand
     * preconditions: none
     * postconditions: hand now has the input Card and the hCount is
     *                 incremented
     */
    public void acceptACard(Card c)
    {
        hand[hCount++] = c;
    }
    /**
     * Accessor:  flip()
     * @return value of the flipped card
     * preconditions: hand[] has at least one dealt card
     * postconditions: returns the value of the top card in player hand
     */
    public int flip()
    {
        return hand[--hCount].getValue();
    }
    /**
     * Mutator: incrementScore()
     * @param add input number of opponent cards won this round of War
     * preconditions: none
     * postconditions: the add input (number of cards won) is added to
     *                 the player's score
     */
    public void incrementScore(int add)
    {
        score += add;
    }
    /**
     * Accessor: getScore()
     * @return player's current number of tricks
     * preconditions: none
     * postconditions: returns a copy of the player's current score
     */
    public int getScore()
    {
        return score;
    }
    /**
     * Accessor: getNumberOfCardsInHand()
     * @return number of Cards the player has left to play
     * preconditions: none
     * postconditions: returns the number of cards left to play with
     */
    public int getNumberOfCardsInHand()
    {
        return hCount;
    }

    /**
     * Accessor: showTopCard()
     * preconditions: none
     * postconditions: shows the top card corresponding to the "flip" card
     */
    public void showTopCard()
    {
       
         //SHOW THE TOP CARD THAT GOT FLIPPED"S VALUE AND SUIT
        
    }

}

[Junilu Lacar]

The player's cards are in the hand array right? Which element of that array represents the top card? Then doesn't a card have a toString() method?

Why are you doing this in the Player constructor?
for ( int i = 0; i < 26; i++) { hand[i] = new Card(); }
This code is saying "The player will initially have a hand with 26 blank Cards".

Did you really mean to do that? If this were a real card game and you dealt me a hand with 26 blank cards, I'd be all

Lastly, while it's admirable that you are trying to write JavaDocs, you should read this document: http://www.oracle.com/technetwork/articles/java/index-137868.html so you know how to write them properly. When it comes to JavaDocs, you should conform to the conventions given in that document and yours don't.