Java - Create a Card object without enum, with compilation time type checking

Question

I want to create a class that would provide me with a card i.e

Card c = new Card(1) // where the builder should get values 1 to 4, representing 1=spade, 2=heart, 3=diamond, 4=clubs 
c.getType() // spade

I want the class to check during compilation time whether the card is of type spade, heart, diamond or club, and if not - it'll raise an error and won't let me compile. The class should NOT use enum

Edit: This question is asked solely for the purpose of understanding how would one answer that kind of question in the pre-enum era. I was asked this question during a job interview a couple of years ago

Answer 1

Thank you all for your answers, and thank you @JoachimSauer, I checked the link you gave me about pre 1.5 and the Type Safe Enum Pattern and I managed to get an answer I like:

class Solution {

    public static class Card {

        public static Card SPADE = new Card();
        public static Card HEART = new Card();
        public static Card DIAMOND = new Card();
        public static Card CLUB = new Card();

        public Card() {
        }

    }
    public static void main(String[] args) {
        Card c = new Card().SPADE; // Only Spade, Heart, Diamond, Club can be "manufactured"
    }
}

I know that it's not exactly what I've described, but only upon reading I understood what exactly I had in mind

of course thanks to @Mike for giving me the answer for what I managed to describe

Answer 2

Update: there is no good way to enforce the value being between 1 and 4 (perhaps using some custom complex compile time annotation would work but I doubt it) as has been pointed out. This is just one way to enforce not allowing Card to be instantiated without using enums, and it implicitly keeps the value between 1 and 4 since each subclass sets its own value.

One way would be to make Card abstract (could also use an interface):

public abstract class Card {

    // should be 1 to 4
    protected int value;

    public int getValue() {
        return value;
    }
}

Then create child classes for each type:

public class Spade extends Card {
    public Spade() {
        this.value = 1;
    }
}

public class Heart extends Card {
    public Spade() {
        this.value = 2;
    }
}

This would throw a compile time error if someone tried to create a Card directly:

Card c = new Card();

Before enums existed, this is how most Java code handled enumerations: using a preset list of integers that were very error prone and not easily enforceable. It was a dark time, let's not go back :)

Answer 3

Java has no features to make new Card(4) compile fine, and new Card(5) to cause a compile-time failure. Can't be done.

The obvious thing to use here is enums. If you have some crazy requirement that prevents you from using it, well, do the usual thing when faced with crazy requirements: Accept that code style and tooling is going to suffer.

You could make subtypes for each suit (as shown by the answer from @Mike), but that isn't really suitable. subclasses are meant to represent different behaviour, and there is nothing different about a Hearts vs. a Spade.

Just so we're clear, let me repeat that: What you ask for is impossible.