Why is this not working??? Help Please!!!!!!!!

Question

I am creating a deck class.
What I have so far, does compile and runs, but it doesn't swith cards. When I am dealing a card, it always returns the same card.
Also I am using Jokers and Ace = 1 or Ace = 14(depending on what the user wants), but they aren't working either.
public class Deck {
//instance Variables
private Card[] DeckOfCards;
private int[] JokerValue;
private boolean [] jokerInDeck;
private int cardsUsed;
public boolean AceHigh;
boolean hasJokers;
private int value;// The value of this card, from 1 to 15.
private int suit;// The suit of this card, one of the constants
// SPADES, HEARTS, DIAMONDS, CLUBS.
//Names for suits
private final int Clubs = 0;
private final int Diamonds = 1;
private final int Hearths = 2;
private final int Spades = 3;
private final int Jokers= 4;
//Names for values
private final int Ace = 1;
private final int Two = 2;
private final int Three = 3;
private final int Four = 4;
private final int Five = 5;
private final int Six = 6;
private final int Seven = 7;
private final int Eight = 8;
private final int Nine = 9;
private final int Ten = 10;
private final int Jack = 11;
private final int Queen = 12;
private final int King = 13;
private final int HighAce = 14;
private final int Joker = 15;
//constructor deck of cards
public Deck() {
// Create an unshuffled deck of cards.
DeckOfCards = new Card[54];
int cardCt = 0;// How many cards have been created so far.
JokerValue = new int[2];//create joker
for(int j = 0; j<2;j++){
JokerValue[j] = 13;
//jokerInDeck[j] = true;// would this work
for (int suit = 0; suit < 4; suit++)
for ( int value = 1; value <= 13; value++ ) {
DeckOfCards[cardCt] = new Card(value,suit);
cardCt++;
cardsUsed = 0;
/*public Deck(boolean Jokers, boolean aceHigh) {
DeckOfCards = new Card[54];
int cardCt = 0;
hasJokers = Jokers;
AceHigh =aceHigh;
JokerValue = new int[2];
for(int j = 0; j<2;j++){
JokerValue[j] = 13;
jokerInDeck[j] = true;
for (int suit = 0; suit < 4; suit++){
for ( int value = 1; value <= 13; value++ ) {
DeckOfCards[cardCt] = new Card(value,suit);
cardCt++;
AceHigh = true;
cardsUsed = 0;
public void shuffle(){
// Put all the used cards back into the deck, and shuffle it into
// a random order.
for(int i = 53; i > 0; i--){
int rand = (int)(Math.random()*(i+1));
Card temp = DeckOfCards;
DeckOfCards[i] = DeckOfCards[rand];
DeckOfCards[rand] = temp;
cardsUsed = 0;
System.out.println("\nYour cards have been shuffled in a random order");
public Card dealCard(){
// Deals one card from the deck and returns it.
if (cardsUsed == 54)
shuffle();
cardsUsed++;
return DeckOfCards[cardsUsed - 1];
//New inner Class
class Card {
// Construct a card with the specified value and suit.
// Value must be between 1 and 13. Suit must be between
// 0 and 3. If the parameters are outside these ranges,
// the constructed card object will be invalid.
public Card(int Value, int Suit){
value = Value;
suit = Suit;
// Return the int that codes for this card's suit.
public int getValue(){
return value;
// Return the int that codes for this card's value.
public int getSuit() {
return suit;
// Return a String representing the card's value
// (If the card's suit is invalid, "??" is returned.)
public String getValueAsString(){
switch(value){
case Ace: return "A";
case Two: return "2";
case Three: return "3";
case Four : return "4";
case Five: return "5";
case Six: return "6";
case Seven: return "7";
case Eight: return "8";
case Nine: return "9";
case Ten: return "T";
case Jack: return "J";
case 12: return "Q";
case 13: return "K";
default: return "*";
//Return a string representing the cards value
//but with Aces set as high
public String setAceHigh(){
AceHigh = true;
switch(value){  
case HighAce: return "A";
case 2: return "2";
case 3: return "3";
case 4: return "4";
case 5: return "5";
case 6: return "6";
case 7: return "7";
case 8: return "8";
case 9: return "9";
case 10: return "T";
case 11: return "J";
case 12: return "Q";
case 13: return "K";
default: return "J";
} //would this set a value of an Ace as 14???
// Return a String representing the card's suit.
// (If the card's suit is invalid, "??" is returned.)
public String getSuitAsString(){
switch(suit) {
case 0: return "C";
case 1: return "D";
case 2: return "H";
case 3: return "S";
case 4: return "J";
default: return "";
// Return a String representation of this card, such as
public String toString(){
if (AceHigh = true){
return(setAceHigh() + "" + getSuitAsString());
}else{
return (getValueAsString() + "" + getSuitAsString());

Answer 1

> public class Deck {
>
//instance Variables
private Card[] DeckOfCards;It is almost universal in Java to write class names with upper case initial and variables with lower case; adopt it.
Currently I also favour using a trailing underscore to denote fields, but that is less universal.
>    private int[] JokerValue;
private boolean [] jokerInDeck;these are never used; what are they for?
>    private int cardsUsed;I'd call that cardsDealt: the deck deals them, but if they're put to any use it doesn't know ;).
>    public boolean AceHigh;
boolean hasJokers;
private int value;// The value of this card, from 1 to 15.
private int suit;// The suit of this card, one of the constantsWhat do you mean this card? These are the fields for the Deck class not for the Card class.
>    //Names for suits
//Names for valuesThese aren't names, they're values.
>    private final int King = 13;This is a final instance field with a constant value. Shouldn't it be a static field of the class, rather than taking up storage in every instance?
>    private final int HighAce = 14;No card appears to ever have this value
>    //constructor deck of cards
public Deck() {
// Create an unshuffled deck of cards.
DeckOfCards = new Card[54];
int cardCt = 0;// How many cards have been created so far.
JokerValue = new int[2];
for(int j = 0; j<2;j++){
JokerValue[j] = 13;
//jokerInDeck[j] = true;
}This can be better written using a static array assignment.
>    for (int suit = 0; suit < 4; suit++)
for ( int value = 1; value <= 13; value++ ) {
DeckOfCards[cardCt] = new Card(value,suit);
cardCt++;
}This passes the correct value and suit to each call to the Card constructor.
>       cardsUsed = 0;You now have an array of length 54 containing 52 Cards and 2 nulls.
>    }
>
public void shuffle(){Contrary to popular belief, this works fine. Though using Random.nextInt(deckSize) would be more efficient. The efficiency lost creating a double, then converting to int is greater than the gain in using a decrement.
>    public Card dealCard(){OK.
>     //New inner ClassIs this a meaningful comment? It's obviously an inner class, and 'New' doen;t mean anything here
>    class Card {
>
// Construct a card with the specified value and suit.
// Value must be between 1 and 13. Suit must be between
// 0 and 3. If the parameters are outside these ranges,
// the constructed card object will be invalid.Don't just put up with invalid inputs that cause unspecified behaviour later on. Make a fuss! Throw an exception.
>       public Card(int Value, int Suit){
value = Value;
suit = Suit;This constructor has no effect on the state of the Class object. The inner class does not declare any fields with these names, so these assignments set the field values in the outer class.
At the end of the outer loop in the constructor, the fields 'value' and 'suit' in the Deck object will be set to '13' and '3'.
>       }
>
// Return the int that codes for this card's suit.
public int getValue(){
return value;
}This method returns the value of the value field in the outer class instance; the Card class does not declare a field. The value returned will be the same for every class instance.
> // Return the int that codes for this card's value.Same bug as before.
>      // Return a String representing the card's value
// (If the card's suit is invalid, "??" is returned.)That's just a lie. The value returned has nothing to do with the suit.
>       public String getValueAsString(){
switch(value){
case Ace: return "A";...
default: return "*";} 
Stylistically I tend to do this sort of thing with arrays.
But that's not a big deal.       > //Return a string representing the cards value
//but with Aces set as high
public String setAceHigh(){
AceHigh = true;This is plain bad.
The aceHigh_ field is a property of the Deck, not the card; the method to set it should be in the Deck and getValueAsString should do what it says whether aces are high or not.
> // Return a String representing the card's suit.
// (If the card's suit is invalid, "??" is returned.)Again, the returned string is based on the suit field of the outer class, and the stated default value is not what the method returns.
> // Return a String representation of this card, such as
public String toString(){
if (AceHigh = true){
return(setAceHigh() + "" + getSuitAsString());
}else{
return (getValueAsString() + "" + getSuitAsString());
} The toString method of the inner class should not invoke methods which set fields in the outer class (even if it only sets them to the value they had before).
As the values of the srting returned is dependent onto on the state of the field in the outer class, this will return the same string for every class in the pack.
> }Fixing these, you might get something like:
import java.util.Random;
public class Deck {
  // class constants
  private static final int JOKER = 15;
  // essential instance state
  private final Card[] deckOfCards_;
  private final int jokers_;
  private final boolean aceHigh_;
  // mutable instance state
  private int cardsDealt_;
  // constructor deck of cards
  public Deck (int jokers, boolean aceHigh) {
    // complain if the number of jokers is invalid
    if ((jokers<0) || (jokers>2)) {
      throw new RuntimeException(jokers + " jokers? you must be joking!");
    jokers_ = jokers;
    aceHigh_ = aceHigh;
    // Create an unshuffled deck of cards.
    deckOfCards_ = new Card[52 + jokers];
    int cardCt = 0; // How many cards have been created so far.
    for (int suit = 0; suit < 4; suit++) {
      for ( int value = 1; value <= 13; value++ ) {
        deckOfCards_[cardCt] = new Card(value, suit);
        cardCt ++;
    // create some jokers
    for (int i=0; i<jokers; i++) {
      deckOfCards_[cardCt] = new Card();
      cardCt ++;
    cardsDealt_ = 0;
  public void shuffle(){
    Random random = new Random();
    // Put all the used cards back into the deck, and shuffle it into
    // a random order.
    int deckSize = deckOfCards_.length;
    for(int i = deckSize-1; i > 0; i--){
      int rand = random.nextInt(deckSize);
      Card temp = deckOfCards_;
deckOfCards_[i] = deckOfCards_[rand];
deckOfCards_[rand] = temp;
cardsDealt_ = 0;
System.out.println("\nYour cards have been shuffled in a random order");
public Card dealCard(){
// Deals one card from the deck and returns it.
if (cardsDealt_ >= deckOfCards_.length) {
shuffle();
cardsDealt_++;
return deckOfCards_[cardsDealt_ - 1];
// Card
class Card {
// fields for the value and suit
private final int value_;
private final int suit_;
// Construct a card with the specified value and suit.
// Value must be between 1 and 13. Suit must be between
// 0 and 3. If the parameters are outside these ranges,
// an exception will be thrown.
public Card (int value, int suit) {
if ((value<1) || (value>13) ||
(suit<0) || (suit>3)) {
throw new RuntimeException("Illegal Card");
value_ = value;
suit_ = suit;
// constructor for Jokers
public Card () {
value_ = JOKER;
suit_ = 4;
// Return the int that codes for this card's suit.
public int getValue(){
return value_;
// Return the int that codes for this card's value.
public int getSuit() {
return suit_;
// Return a String representing the card's value
// (If the card's suit is invalid, "??" is returned.)
public String getValueAsString(){
return VALUES[value_];
// Return a String representing the card's suit.
// (If the card's suit is invalid, "??" is returned.)
public String getSuitAsString(){
return SUITS[suit_];
// Return a String representation of this card, such as
public String toString(){
return getSuitAsString() + " " + getValueAsString();
// Names of suits and cards
static final String[] SUITS = {"H", "C", "D", "S", "J"};
static final String[] VALUES = {"?", "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "+"};
// test
public static void main (String[] args) {
Deck deck = new Deck(2, true);
deck.shuffle();
for (int i=0; i<10; i++) {
System.out.println(deck.dealCard());
Pete