By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
425,719 Members | 1,046 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 425,719 IT Pros & Developers. It's quick & easy.

whats wrong with my code???

P: 5
Hi, I’m working on a solitaire game as my course assignment, and I am having trouble to dealing with Stock class, which consists of an upturned top card plus deck.
The code for Stock class:
Expand|Select|Wrap|Line Numbers
  1. import java.util.*;
  2. import java.awt.*;
  3. /**
  4.  * The Stock is the deck of unused cards. It is subtly different from the deck
  5.  * itself in several ways. Firstly, it does not come into existence until after
  6.  * the four cards have been extracted from the deck to form the start of the 
  7.  * foundation. Secondly, the deck is essentially just a list of cards, while
  8.  * the stock consists of an upturned top card plus the rest of the deck.
  9.  * Thirdly, the deck does not have any graphical representation whereas the stock
  10.  * provides methods that allow the user to interact with it via the mouse. At all 
  11.  * times, the top card on the stock is displayed face up, offset from the rest of 
  12.  * the stock which is displayed as a single face-down card.
  13.  */
  14.  
  15. public class Stock
  16. {
  17.     public java.util.List<Card> cards;
  18.     private Deck deck = new Deck(52);
  19.     private Card topCard;
  20.  
  21.     /**
  22.      * Constructor for objects of class Stock, when they are 
  23.      * not going to be displayed on a Graphics
  24.      * @param deck the deck of cards used to make Stock
  25.      */
  26.     public Stock(Deck deck)
  27.     {
  28.         this.deck = deck;
  29.     }
  30.  
  31.         X = x;
  32.         Y = y;
  33.     }
  34.  
  35.     /**
  36.      * Add the given card to the end of the stock of cards.
  37.      */
  38.     public void addAtEnd(Card card)
  39.     {
  40.         cards.add(card);
  41.     }
  42.  
  43.  
  44.     /**
  45.      * The number of cards in the stock(including the top card).
  46.      * @return the number of cards.
  47.      */
  48.     public int numCardsRemaining()
  49.     {
  50.         return deck.numCardsRemaining();
  51.     }
  52.  
  53.     /**
  54.      * Take the top card from the stock.
  55.      * @return the card that was on top of the stock or null if the stock was empty.
  56.      * A call to this method reduces the number of cards remaining in the stock by one.
  57.      */
  58.     public Card takeTop()
  59.     {
  60.         if(deck.numCardsRemaining()==0)
  61.         {
  62.             return null;
  63.         }
  64.         else
  65.         {
  66.              return this.deck.nextCard();
  67.         }
  68.  
  69.     }
  70.  
  71.     /**
  72.      * The top card of the stock.
  73.      * @return the top card of the stock, or null if the stock is empty.
  74.      * Acall to this method does not remove the card from the top but 
  75.      * just returns a reference to it.
  76.      */
  77.     public Card top()
  78.     {
  79.         if(deck.numCardsRemaining()==0)
  80.             {
  81.                 return null;
  82.             }
  83.             else  
  84.            {
  85.                 Card topCard = deck.nextCard();
  86.                 deck.addAtStart(topCard);
  87.            }
  88.             return topCard;
  89.         }
  90.  
  91.      }
  92.  
  93. }
In order to understand Stock class you need Deck class as well, but we’re not allowed to modify this class as assignment required.
Expand|Select|Wrap|Line Numbers
  1. import java.util.*;
  2. import java.awt.*;
  3.  
  4. /**
  5.  * A full deck of cards. It is shuffled when first constructed
  6.  * and thereafter cards are removed from the deck by calls to 
  7.  * nextCard until no further cards remain. Cards can also be
  8.  * placed back on the deck at either the start or the end.
  9.  */
  10. public class Deck
  11. {
  12.     private java.util.List<Card> cards;      // The list of cards
  13.     private static java.util.Random generator = null;
  14.  
  15.     /**
  16.      * Constructor for a shuffled deck of cards.
  17.      * @param seed the seed for the random number generator used to
  18.      * shuffle the deck. A different unique shuffle is obtained for
  19.      * each possible value of seed.
  20.      */
  21.     public Deck(long seed)
  22.     {
  23.         // Create a deck of cards in sorted order of suit then pip count.
  24.  
  25.         cards = new ArrayList<Card>();
  26.         for (int suit = Card.SPADES; suit <= Card.CLUBS; suit++) {
  27.             for (int pips = 1; pips <= Card.CARDS_IN_SUIT; pips++) {
  28.                 cards.add(new Card(suit, pips));
  29.             }
  30.         }
  31.  
  32.         // Now shuffle the deck, using a random number generator based
  33.         // on the seed value given as a parameter.
  34.  
  35.         java.util.Random generator = new java.util.Random(seed); 
  36.         java.util.Collections.shuffle(cards, generator);
  37.     }
  38.  
  39.     /**
  40.      * The number of cards still remaining in the deck.
  41.      * @return the number of cards left in the deck.
  42.      */
  43.     public int numCardsRemaining()
  44.     {
  45.         return cards.size();
  46.     }
  47.  
  48.     /**
  49.      * Get the next card from the deck, reducing the number of cards
  50.      * remaining in the deck by one.
  51.      * @return the "top" card in the deck
  52.      */
  53.     public Card nextCard()
  54.     {
  55.         return cards.remove(0);
  56.     }
  57.  
  58.     /**
  59.      * Add the given card to the start (front) of the current deck.
  60.      * @param card the card to be placed at the start of the deck
  61.      */
  62.     public void addAtStart(Card card)
  63.     {
  64.         cards.add(0, card);
  65.     }
  66.  
  67.     /**
  68.      * Add the given card to the end (back) of the current deck.
  69.      * @param card the card to be placed on the end of the deck
  70.      */
  71.     public void addAtEnd(Card card)
  72.     {
  73.         cards.add(card);
  74.     }
  75. }
So, my problem is in my “public Card top()” method in the “Stock” class, I defined 'topCard' as 'deck.nextCard()', then put it back, and return it, but it seems not right, can someone help me on this. As I’m just learning Java a month ago, please excuse me if I make no sense.

Thanks!
:D
May 18 '06 #1
Share this question for a faster answer!
Share on Google+

Post your reply

Sign in to post your reply or Sign up for a free account.