Accessor methods on enum

[Jon Camilleri]

I'm trying to create a Poker game, starting off from the objects:

public class Card {
	
	public Card (suit _suit, _card) {
		
	}
	
	public String getSuit {
		switch (this.suit) {
			case HEARTS : return "Hearts"; //I can't call HEARTS because my interpreter does not recognize suit, although it's declared as a private enum
			break;
		}
	}
	
	private enum suit {HEARTS, DIAMONDS, SPACES, CLUBS}
	private enum cardnumber {ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE}
}

So I extended my imagination ...

public class Poker {
	public enum suit {HEARTS, DIAMONDS, SPACES, CLUBS}
	public enum cardnumber {ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE}
}

4 suits of cards, 14 cards for each suit, however, I want the enum to be available globally within the application.
I'm also worried that by having enums declared within the Card class, and, within the Poker class - which in theory will call the card class as required since this is the "testing class" where my main method for calling the card class will reside, and, is the start of a spaghetti logic...

Further reading
1. Enum types at http://download.oracle.com/javase/tutorial/java/javaOO/enum.html.
2. Poker basics at http://en.wikipedia.org/wiki/Poker.
3. Card suits at http://en.wikipedia.org/wiki/Suit_(cards).
4. Encapsulation is described as "Under this definition, encapsulation means that the internal representation of an object is generally hidden from view outside of the object's definition. Typically, only the object's own methods can directly inspect or manipulate its fields.", as quoted on http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming).

[Unnar Björnsson]

First off the variable suit in line 8 does not exist so you can't compare the constant HEART to it.
The break in line 10 is unreachable since a return statement is called before it, you should let the switch case assign a value to a String variable and leave the return statement until you are out of the switch.

If you make the enum types public you can access them from anywhere by calling them through the Card class, like so: Card.suit.HEARTS.

Personally I usually give a class a number of public static constants:

public class Card
{
public final static int HEARTS = 0;
public final static int DIAMONDS = 1;
public final static int SPACES = 2;
public final static int CLUBS = 3;
}

And refer to it's suit and number with integers

[Henry Wong]

//I can't call HEARTS because my interpreter does not recognize suit, although it's declared as a private enum

It doesn't recognize "suit", because it is expecting a variable for the switch statement. In this case, suit is a enum type, and not a variable. You need to declare a variable of that type to use.

You also have a ton of syntax errors too, that needs to be fixed.

Henry

[Rob Spoor]

Jon Camilleri wrote:4 suits of cards, 14 cards for each suit, however, I want the enum to be available globally within the application.

So make the enum public, like Unnar suggested. Card.suit will then be the name for the enum. Although you should of course change it to Card.Suit (and Card.Number instead of Card.cardnumber).

Unnar Björnsson wrote:Personally I usually give a class a number of public static constants:

public class Card
{
public final static int HEARTS = 0;
public final static int DIAMONDS = 1;
public final static int SPACES = 2;
public final static int CLUBS = 3;
}

And refer to it's suit and number with integers

Which allows me to create a card with suite 13 and value 481, unless you check and throw an IllegalArgumentException. This example is a good application for enums, with a small fixed set of values.

[Jon Camilleri]

Thanks, however, I needed to flag cards according to the suit and the cardnumber, so I coded as follows, after trying to initialize a boolean[] [] card unsuccessfully:

public class Poker {
	public static void main(String[] args) {
		
		try {
			
			short suit = Card.SPADES;
			short card = Card.ACE;
			Card myCard = new Card(suit, card);
			System.out.println(myCard.getCard());
		}
		catch (NullPointerException e)
		{ System.out.println(e.getMessage());}
		
	}	
}



public class Card {
	
	public Card (short _suit, short _card) {
		card[_suit] [_card] = true;  //does not happen?
	}
	
	public String getCard() {
		
		if (card [0][0] == true) return "Ace of Hearts";
		else if (card [0][1] == true) return "One of Hearts";
		else if (card [0][2] == true) return "Two of Hearts";
		else if (card [0][3] == true) return "Three of Hearts";
		else if (card [0][4] == true) return "Four of Hearts";
		else if (card [0][5] == true) return "Five of Hearts";
		else if (card [0][6] == true) return "Six of Hearts";
		else if (card [0][7] == true) return "Seven of Hearts";
		else if (card [0][8] == true) return "Eight of Hearts";
		else if (card [0][9] == true) return "Nine of Hearts";
		else if (card [0][10] == true) return "Ten of Hearts";
		else if (card [0][11] == true) return "Jack of Hearts";
		else if (card [0][12] == true) return "Queen of Hearts";
		else if (card[0][13] == true) return "King of Hearts";
		
		else if (card[1][0] == true) return "Ace of Diamonds";
		else if (card[1][1] == true) return "One of Diamonds";
		else if (card[1][2] == true) return "Two of Diamonds";
		else if (card[1][3] == true) return "Three of Diamonds";
		else if (card[1][4] == true) return "Four of Diamonds";
		else if (card[1][5] == true) return "Five of Diamonds";
		else if (card[1][6] == true) return "Six of Diamonds";
		else if (card[1][7] == true) return "Seven of Diamonds";
		else if (card[1][8] == true) return "Eight of Diamonds";
		else if (card[1][9] == true) return "Nine of Diamonds";
		else if (card[1][10] == true) return "Ten of Diamonds";
		else if (card[1][11] == true) return "Jack of Diamonds";
		else if (card[1][12] == true) return "Queen of Diamonds";
		else if (card[1][13] == true) return "King of Diamonds";
		
		else if (card[2][0] == true)return "Ace of Spades";
		else if (card[2][1] == true) return "One of Spades";
		else if (card[2][2] == true) return "Two of Spades";
		else if (card[2][3] == true) return "Three of Spades";
		else if (card[2][4] == true) return "Four of Spades";
		else if (card[2][5] == true) return "Five of Spades";
		else if (card[2][6] == true) return "Six of Spades";
		else if (card[2][7] == true) return "Seven of Spades";
		else if (card[2][8] == true) return "Eight of Spades";
		else if (card[2][9] == true) return "Nine of Spades";
		else if (card[2][10] == true) return "Ten of Spades";
		else if (card[2][11] == true) return "Jack of Spades";
		else if (card[2][12] == true) return "Queen of Spades";
		else if (card[2][13] == true) return "King of Spades";
		
		else if (card[3][0] == true) return "Ace of Clubs";
		else if (card[3][1] == true) return "One of Clubs";
		else if (card[3][2] == true) return "Two of Clubs";
		else if (card[3][3] == true) return "Three of Clubs";
		else if (card[3][4] == true) return "Four of Clubs";
		else if (card[3][5] == true) return "Five of Clubs";
		else if (card[3][6] == true) return "Six of Clubs";
		else if (card[3][7] == true) return "Seven of Clubs";
		else if (card[3][8] == true) return "Eight of Clubs";
		else if (card[3][9] == true) return "Nine of Clubs";
		else if (card[3][10] == true) return "Ten of Clubs";
		else if (card[3][11] == true) return "Jack of Clubs";
		else if (card[3][12] == true) return "Queen of Clubs";
		else if (card[3][13] == true) return "King of Clubs";
		
		else return "Unknown card"; //should never occur
	}
	
	private boolean[][] card = null;
	
	public final static short HEARTS = 0;
	public final static short DIAMONDS = 1;
	public final static short SPADES = 2;
	public final static short CLUBS = 3;
	
	public final static short ACE = 0;
	public final static short ONE = 1;
	public final static short TWO = 2;
	public final static short THREE = 3;
	public final static short FOUR = 4;
	public final static short FIVE = 5;
	public final static short SIX = 6;
	public final static short SEVEN = 7;
	public final static short EIGHT = 8;
	public final static short NINE = 9;
	public final static short TEN = 10;
	public final static short JACK = 11;
	public final static short QUEEN = 12;
	public final static short KING = 13;
}

Further reading
Bug #7037278 on http://bugreport.sun.com/bugreport/submit_intro.do - not accessible.

[Matthew Brown]

That's a shame - because the enum approach is so much better than that. Shorter, clearer, and type safe (which that isn't).

[Jon Camilleri]

Matthew Brown wrote:That's a shame - because the enum approach is so much better than that.

How do you mean?


My code includes enums for ease of reference, and, I cannot use a static variable since typically a deck of 52 cards must be unique - thus shared variables would not be useful for representing the card value, which means that a Deck will inherit the Card class, once I have this class working

short suit = Card.SPADES;
short card = Card.ACE;
Card myCard = new Card(suit, card);

[Matthew Brown]

You aren't using enums in that code - you're using shorts. Which means, as Rob pointed out, there's nothing stopping someone creating the 67 of Spades (or, indeed, the 67 of some new made up suit).

Usnig the boolean[][] is pretty strange as well, as it means that conceptually your Card can actually be more than one card at a time. And that massive if/else statement is completely unnecessary.

Try this. It probably doesn't match exactly what you're trying to do, but it's a starting point.

public class Poker {
    public static void main(String[] args) {
        Card myCard = new Card(Card.Suit.SPADES, Card.Number.ACE);
        System.out.println(myCard);
    }
} 

public class Card {
	public enum Suit {
        CLUBS("Clubs"), DIAMONDS("Diamonds"), HEARTS("Hearts"), SPADES("Spades");
        
        private String name;
        Suit(String name) { this.name = name; }
        public String getName() { return name; }
    }
    
    public enum Number {
        ACE("Ace"), TWO("Two"), THREE("Three"), FOUR("Four"), FIVE("Five"),
        SIX("Six"), SEVEN("Seven"), EIGHT("Eight"), NINE("Nine"), TEN("Ten"),
        JACK("Jack"), QUEEN("Queen"), KING("King");
        
        private String name;
        Number(String name) { this.name = name; }
        public String getName() { return name; }
    }
    
    private Suit suit;
    private Number number;
    
    public Card(Suit suit, Number number) {
        this.suit = suit;
        this.number = number;
    }
    
    public Suit getSuit() {
        return suit;
    }
    
    public Number getNumber() {
        return number;
    }
    
    @Override
    public String toString() {
        return number.getName() + " of " + suit.getName();
    }
}

[Hauke Ingmar Schmidt]

Jon Camilleri wrote:
My code includes enums for ease of reference

Where?

Card myCard = new Card(127,128);

[Jon Camilleri]

Hauke Ingmar Schmidt wrote:

Jon Camilleri wrote:
My code includes enums for ease of reference

Where?

Card myCard = new Card(127,128);

Scroll up..

[Hauke Ingmar Schmidt]

Jon Camilleri wrote:

Hauke Ingmar Schmidt wrote:

Jon Camilleri wrote:
My code includes enums for ease of reference

Where?

Scroll up..

I will just quote Matthew:

Matthew Brown wrote:You aren't using enums in that code - you're using shorts.

[Unnar Björnsson]

Your cards are defined by two things, cardnumber and suit, it's name is therefore of the following format: "<cardnumber>of<suit>". The number and suit need to have a string representation. I'm not sure if you insist on using enums I don't use them much myself
Regardless you need to return a string which you could store in parts in an array or use enum, I'll show you the array version:

String[] SUIT = {"Hearts","Diamonds","Spades","Clubs"};
String[] CARD = {"Ace","One","Two","Three","Four","Five","Six","Seven","Eight","Nine","Jack","Queen","King"};

I don't know why on earth you would instantiate a card object of suit 13 and number 481 but, yes it's better to be safe than sorry so be sure that the constructor checks if the arguments are within reasonable bounds.

Now instead of your long block of if-else inside your getCard() method you can simply do:

return CARD[card]+" of "+SUIT[suit];

You would ofcourse need to make constants for ease of reference, which is perhaps where this method falls short of enum.