When I try to compile my code, I get multiple errors, but I dont know what I\'m

ID: 3838851 • Letter: W

Question

When I try to compile my code, I get multiple errors, but I dont know what I'm doing wrong

errors:

./PJ4/VideoPoker.java:59: error: cannot find symbol
    private final Decks Decks(1);
                  ^
symbol:   class Decks
location: class VideoPoker
./PJ4/VideoPoker.java:62: error: cannot find symbol
    private List playerHand;
                 ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:63: error: cannot find symbol
    private HashMap playerCardsToKeepMap;
                            ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:59: error: cannot find symbol
    private final Decks Decks(1);
                                      ^
symbol:   class Decks
location: class VideoPoker
./PJ4/VideoPoker.java:154: error: cannot find symbol
       for(Card card : playerHand){
            ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:167: error: cannot find symbol
       for(Card card : playerHand){
            ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:173: error: cannot find symbol
       for(Card card : playerHand){
            ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:191: error: cannot find symbol
       for(Card card : playerHand){
            ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:215: error: cannot find symbol
       for(Card card : playerHand){
            ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:227: error: cannot find symbol
       for(Card card : playerHand){
            ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:244: error: cannot find symbol
       for(Card card : playerHand){
            ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:262: error: cannot find symbol
       for(Card card : playerHand){
            ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:281: error: cannot find symbol
       for(Card card : playerHand){
            ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:324: error: cannot find symbol
       catch(PlayingCardException e){
              ^
symbol:   class PlayingCardException
location: class VideoPoker
./PJ4/VideoPoker.java:346: error: cannot find symbol
               Card card = playerHand.get(position);
               ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:360: error: cannot find symbol
       for(Map.Entry card : playerCardsToKeepMap.entrySet()){
                               ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:489: error: cannot find symbol
           playerHand = new ArrayList();
                                       ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:492: error: cannot find symbol
       playerHand.add(new Card(3,1));
                           ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:493: error: cannot find symbol
       playerHand.add(new Card(3,10));
                           ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:494: error: cannot find symbol
       playerHand.add(new Card(3,12));
                           ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:495: error: cannot find symbol
       playerHand.add(new Card(3,11));
                           ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:496: error: cannot find symbol
       playerHand.add(new Card(3,13));
                           ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:502: error: cannot find symbol
       playerHand.set(0,new Card(3,9));
                             ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:508: error: cannot find symbol
       playerHand.set(4, new Card(1,8));
                              ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:514: error: cannot find symbol
       playerHand.set(4, new Card(3,5));
                              ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:524: error: cannot find symbol
       playerHand.add(new Card(4,8));
                           ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:525: error: cannot find symbol
       playerHand.add(new Card(1,8));
                           ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:526: error: cannot find symbol
       playerHand.add(new Card(4,12));
                           ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:527: error: cannot find symbol
       playerHand.add(new Card(2,8));
                           ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:528: error: cannot find symbol
       playerHand.add(new Card(3,8));
                           ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:534: error: cannot find symbol
       playerHand.set(4, new Card(4,11));
                              ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:540: error: cannot find symbol
       playerHand.set(2, new Card(2,11));
                              ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:546: error: cannot find symbol
       playerHand.set(1, new Card(2,9));
                              ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:552: error: cannot find symbol
       playerHand.set(0, new Card(2,3));
                              ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:558: error: cannot find symbol
       playerHand.set(2, new Card(4,3));
                              ^
symbol:   class Card
location: class VideoPoker
./PJ4/VideoPoker.java:564: error: cannot find symbol
       playerHand.set(2, new Card(4,6));
                              ^
symbol:   class Card
location: class VideoPoker

My code:

package PJ4;
import java.util.*;

/*
* Ref: http://en.wikipedia.org/wiki/Video_poker
*      http://www.freeslots.com/poker.htm
*
*
* Short Description and Poker rules:
*
* Video poker is also known as draw poker.
* The dealer uses a 52-card deck, which is played fresh after each playerHand.
* The player is dealt one five-card poker playerHand.
* After the first draw, which is automatic, you may hold any of the cards and draw
* again to replace the cards that you haven't chosen to hold.
* Your cards are compared to a table of winning combinations.
* The object is to get the best possible combination so that you earn the highest
* payout on the bet you placed.
*
* Winning Combinations
*
* 1. One Pair: one pair of the same card
* 2. Two Pair: two sets of pairs of the same card denomination.
* 3. Three of a Kind: three cards of the same denomination.
* 4. Straight: five consecutive denomination cards of different suit.
* 5. Flush: five non-consecutive denomination cards of the same suit.
* 6. Full House: a set of three cards of the same denomination plus
*    a set of two cards of the same denomination.
* 7. Four of a kind: four cards of the same denomination.
* 8. Straight Flush: five consecutive denomination cards of the same suit.
* 9. Royal Flush: five consecutive denomination cards of the same suit,
*    starting from 10 and ending with an ace
*
*/

/* This is the video poker game class.
* It uses Decks and Card objects to implement video poker game.
* Please do not modify any data fields or defined methods
* You may add new data fields and methods
* Note: You must implement defined methods
*/

public class VideoPoker {

    // default constant values
    private static final int startingBalance=100;
    private static final int numberOfCards=5;

    // default constant payout value and playerHand types
    private static final int[] multipliers={1,2,3,5,6,10,25,50,1000};
    private static final String[] goodHandTypes={
      "One Pair" , "Two Pairs" , "Three of a Kind", "Straight", "Flush   ",
      "Full House", "Four of a Kind", "Straight Flush", "Royal Flush" };

// must use only one deck
private final Decks Decks(1);

    // holding current poker 5-card hand, balance, bet
    private List playerHand;
    private HashMap playerCardsToKeepMap;
    private int playerBalance;
    private int playerBet;
    private Scanner scanner;
   boolean showPayoutTable = true;

    /** default constructor, set balance = startingBalance */
    public VideoPoker()
    {
   this(startingBalance);
   playerBalance = startingBalance;
   scanner = new Scanner(System.in);
   playerCardsToKeepMap = new HashMap<>();
    }

    /** constructor, set given balance */
    public VideoPoker(int balance)
    {
       this.playerBalance= balance;
        scanner = new Scanner(System.in);
       playerCardsToKeepMap = new HashMap<>();
    }

    /** This display the payout table based on multipliers and goodHandTypes arrays */
    private void showPayoutTable()
    {
   System.out.println(" ");
   System.out.println("Payout Table            Multiplier   ");
   System.out.println("=======================================");
   int size = multipliers.length;
   for (int i=size-1; i >= 0; i--) {
       System.out.println(goodHandTypes[i]+" | "+multipliers[i]);
   }
   System.out.println(" ");
    }

    /** Check current playerHand using multipliers and goodHandTypes arrays
     * Must print yourHandType (default is "Sorry, you lost") at the end of function.
     * This can be checked by testCheckHands() and main() method.
     */
    private void checkHands()
    {
        // implement this method!
        if(RoyalFlush()){
           System.out.println("Royal Flush!");
           playerBalance += multipliers[8] * playerBet;
       }
       else if(StraightFlush()){
           System.out.println("Straight Flush!");
           playerBalance += multipliers[7] * playerBet;
       }
       else if(Straight()){
           System.out.println("Straight!");
           playerBalance += multipliers[3] * playerBet;
       }
       else if(Flush()){
           System.out.println("Flush!");
           playerBalance += multipliers[4] * playerBet;
       }
       else if(FullHouse()){
           System.out.println("Full House");
           playerBalance += multipliers[5] * playerBet;
       }
       else if(OfAKind(4)){
           System.out.println("Four of a Kind!");
           playerBalance += multipliers[6] * playerBet;
       }
       else if(OfAKind(3)){
           System.out.println("Three of a Kind!");
           playerBalance += multipliers[2] * playerBet;
       }
       else if(TwoPair()){
           System.out.println("Two Pair!");
           playerBalance += multipliers[1] * playerBet;
       }
       else if(OnePair()){
           System.out.println("One Pair!");
           playerBalance += multipliers[0] * playerBet;
       }
       else
           System.out.println("Sorry, you lost!");
    }

    /*************************************************
     *   add new private methods here ....
     *
     *************************************************/
    private boolean RoyalFlush(){
       int firstCardSuit = playerHand.get(0).getSuit();
       List royalFlushRankList = Arrays.asList(1,10,11,12,13);

       for(Card card : playerHand){
           if(card.getSuit() != firstCardSuit || !royalFlushRankList.contains(card.getRank()))
               return false;
       }

return true;
}

    private boolean StraightFlush(){
       int firstCardSuit = playerHand.get(0).getSuit();
       List sortedCardRanks = new ArrayList<>();

       for(Card card : playerHand){
           sortedCardRanks.add(card.getRank());
       }

Collections.sort(sortedCardRanks);

       for(Card card : playerHand){
           if(card.getSuit() != firstCardSuit)
               return false;
       }

       for(int i = 0; i < 4; i++){
           if(!(sortedCardRanks.get(i) == (sortedCardRanks.get(i+1) - 1)))
               return false;
       }

return true;
}

   private boolean Straight(){
       int firstCardSuit = playerHand.get(0).getSuit();
       List sortedCardRanks = new ArrayList<>();
       List cardSuits = new ArrayList<>();

       for(Card card : playerHand){
           sortedCardRanks.add(card.getRank());
           cardSuits.add(card.getSuit());
       }

Collections.sort(sortedCardRanks);

Set suitSet = new HashSet<>(cardSuits);

if(suitSet.size() > cardSuits.size())
return false;

       for(int i = 0; i < 4; i++){
           if(!(sortedCardRanks.get(i) == (sortedCardRanks.get(i+1) - 1)))
               return false;
       }

return true;
}

private boolean Flush(){
int firstCardSuit = playerHand.get(0).getSuit();

       for(Card card : playerHand){
           if(card.getSuit() != firstCardSuit)
               return false;
       }

return true;
}

private boolean FullHouse(){
HashMap rankMap = new HashMap<>();

       for(Card card : playerHand){
           if(!rankMap.containsKey(card.getRank())){
               rankMap.put(card.getRank(), 1);
           }
           else{
               int value = rankMap.get(card.getRank());
               rankMap.put(card.getRank(), value+1);
           }
       }

return rankMap.containsValue(3) && rankMap.containsValue(2);
}

private boolean OfAKind(int kindType){
HashMap rankMap = new HashMap<>();

return rankMap.containsValue(kindType);
}

    private boolean TwoPair(){
       HashMap rankMap = new HashMap<>();
       int pairCounter = 0;

return pairCounter == 2 && rankMap.containsValue(1);
}

    private boolean OnePair(){
       HashMap rankMap = new HashMap<>();
       int pairCounter = 0;

       for(Card card : playerHand){
           if(!rankMap.containsKey(card.getRank())){
               rankMap.put(card.getRank(), 1);
               pairCounter = 1;
           }
           else{
               int value = rankMap.get(card.getRank());
               rankMap.put(card.getRank(), value+1);
               pairCounter++;
           }
       }

return pairCounter == 2 && rankMap.containsValue(1);
}

    private void getPlayerBet(){
       System.out.print("Enter bet: ");
       try{
           playerBet = scanner.nextInt();

           if(playerBet > playerBalance){
               System.out.println(" Bet is larger than balance, try again");
               getPlayerBet();
           }
       }
       catch(InputMismatchException e){
           System.out.println(" Please input integers only. Try again");
           getPlayerBet();
       }
    }

    private void updateBalance(){
       playerBalance -= playerBet;
    }

    private void dealHand(){
       try{
           playerHand = oneDeck.deal(numberOfCards);
       }
       catch(PlayingCardException e){
           System.out.println("PlayingCardException: " + e.getMessage());
       }
    }

private void getPlayerCardRetainingPositions(){
System.out.print("Enter positions of cards to keep (e.g. 1 4 5 ): ");

scanner = new Scanner(System.in);
String input = scanner.nextLine();

       if(input.isEmpty()){
           return;
       }

String[] positionsToKeep = input.trim().split("\s+");

try{
for(int i = 0; i < positionsToKeep.length; i++){

               int position = Integer.parseInt(positionsToKeep[i]) - 1;
               Card card = playerHand.get(position);
               playerCardsToKeepMap.put(position, card);
           }
       }
       catch(Exception e){
           System.out.println(" Please input integers 1-5 only. Try again");
           getPlayerCardRetainingPositions();
       }
    }

private void setAndDisplayNewPlayerHand(){
dealHand();

       for(Map.Entry card : playerCardsToKeepMap.entrySet()){
           playerHand.set(card.getKey(), card.getValue());
       }

       System.out.println(playerHand.toString());
    }

    private void checkToPlayNewGame(){
       System.out.println(" Do you want to play a new game? (y or n)");
       scanner = new Scanner(System.in);

       String input = scanner.nextLine();
       if(input.equals("y")){
           checkAndDisplayIfPlayerWantsCheckoutTable();
           play();
       }
       else if(input.equals("n")){
           exitGame();
       }
       else{
           System.out.println("Please enter (y or n)");
           checkToPlayNewGame();
       }
    }

    private void checkAndDisplayIfPlayerWantsCheckoutTable(){
       System.out.println(" Want to see payout table (y or n)");
       String input = scanner.nextLine();

       if(input.equals("n")){
           showPayoutTable = false;
       }
    }

    private void exitGame(){
       showBalance();
       System.out.println(" Bye!");
       System.exit(0);
    }

    private void showBalance(){
       System.out.println(" Balance: $" + playerBalance);
   }

    public void play()
    {
    /** The main algorithm for single player poker game
     *
     * Steps:
     *        showPayoutTable()
     *
     *        ++
     *        show balance, get bet
     *       verify bet value, update balance
     *       reset deck, shuffle deck,
     *       deal cards and display cards
     *       ask for positions of cards to replace
     *          get positions in one input line
     *       update cards
     *       check hands, display proper messages
     *       update balance if there is a payout
     *       if balance = O:
     *           end of program
     *       else
     *           ask if the player wants to play a new game
     *           if the answer is "no" : end of program
     *           else : showPayoutTable() if user wants to see it
     *           goto ++
     */

        // implement this method!
        if(showPayoutTable){
           showPayoutTable();
       }

System.out.println(" -----------------------------------");
showBalance();

//user input
getPlayerBet();

//Update balance
updateBalance();

       //reset/shuffle
       oneDeck.reset();
       oneDeck.shuffle();

       //deal hand and display
       dealHand();
       System.out.println(playerHand.toString());

//get card position user wants to retain
getPlayerCardRetainingPositions();

//display new cards to user
setAndDisplayNewPlayerHand();

//Check hand type user has and adjust balance
checkHands();

       //show balance
       showBalance();

       //user can exit or play another game
       if(playerBalance == 0){
           exitGame();
       }
       else{
           checkToPlayNewGame();
       }
    }

    /*************************************************
     *   Do not modify methods below
    /*************************************************

    /** testCheckHands() is used to test checkHands() method
     * checkHands() should print your current hand type
     */

    public void testCheckHands()
    {
         try {
           playerHand = new ArrayList();

       // set Royal Flush
       playerHand.add(new Card(3,1));
       playerHand.add(new Card(3,10));
       playerHand.add(new Card(3,12));
       playerHand.add(new Card(3,11));
       playerHand.add(new Card(3,13));
       System.out.println(playerHand);
           checkHands();
       System.out.println("-----------------------------------");

       // set Straight Flush
       playerHand.set(0,new Card(3,9));
       System.out.println(playerHand);
           checkHands();
       System.out.println("-----------------------------------");

       // set Straight
       playerHand.set(4, new Card(1,8));
       System.out.println(playerHand);
           checkHands();
       System.out.println("-----------------------------------");

       // set Flush
       playerHand.set(4, new Card(3,5));
       System.out.println(playerHand);
           checkHands();
       System.out.println("-----------------------------------");

// "Royal Pair" , "Two Pairs" , "Three of a Kind", "Straight", "Flush ",
// "Full House", "Four of a Kind", "Straight Flush", "Royal Flush" };

       // set Four of a Kind
       playerHand.clear();
       playerHand.add(new Card(4,8));
       playerHand.add(new Card(1,8));
       playerHand.add(new Card(4,12));
       playerHand.add(new Card(2,8));
       playerHand.add(new Card(3,8));
       System.out.println(playerHand);
           checkHands();
       System.out.println("-----------------------------------");

       // set Three of a Kind
       playerHand.set(4, new Card(4,11));
       System.out.println(playerHand);
           checkHands();
       System.out.println("-----------------------------------");

       // set Full House
       playerHand.set(2, new Card(2,11));
       System.out.println(playerHand);
           checkHands();
       System.out.println("-----------------------------------");

       // set Two Pairs
       playerHand.set(1, new Card(2,9));
       System.out.println(playerHand);
           checkHands();
       System.out.println("-----------------------------------");

       // set One Pair
       playerHand.set(0, new Card(2,3));
       System.out.println(playerHand);
           checkHands();
       System.out.println("-----------------------------------");

       // set One Pair
       playerHand.set(2, new Card(4,3));
       System.out.println(playerHand);
           checkHands();
       System.out.println("-----------------------------------");

       // set no Pair
       playerHand.set(2, new Card(4,6));
       System.out.println(playerHand);
           checkHands();
       System.out.println("-----------------------------------");
         }
         catch (Exception e)
         {
       System.out.println(e.getMessage());
         }
    }

    /* Quick testCheckHands() */
    public static void main(String args[])
    {
   VideoPoker pokergame = new VideoPoker();
   pokergame.testCheckHands();
    }
}

Explanation / Answer