Interfaces vs. enums

Question

Between interfaces and enums, which is better for declaring constants? Why is it so?

Answer 1

Its always better to use Enums to declare constants as the objective of interfaces are on a totally different level. Yes, there are lots of interfaces which have a public static final constants, but I feel that enums exclusive job is to provide you these constants.

Answer 2

If there is a reason for your constants to have a specific type, if they need some kind of behavior (i.e., methods), or if they are composites of other values, enums are the way to go.

For example, let's assume you're implementing a card game and you want to represent values and suits:

enum Rank { 
    ACE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, 
    EIGHT, NINE, TEN, JACK, QUEEN, KING; 
}
enum Suit { SPADES, CLUBS, DIAMONDS, HEARTS } 

There, it's now impossible to create cards with bogus suits or ranks.

Sometimes, though, you are just interested in having a bunch of frequently used values declared somewhere. In that case, putting them in an enum would just be unnecessary effort, since these constants are just a tool to save us from remembering all the decimals of, say, π when we are calculating the circumference of a circle, or something. Which looks better?

// Using enum:
enum MathConstant { 
    PI(3.14159265358979323846), E(2.7182818284590452354);
    private final double value;
    MathConstant(double v) { value = v; }
    public double value() { return value; } 
}
// Usage:
double circumference = MathConstant.PI.value() * diameter;

// Using a constant class:
final class MathConstants { 
    private MathConstants() { throw new UnsupportedOperationException(); }
    public static final double PI = 3.14159265358979323846,
                               E = 2.7182818284590452354;
}
// Usage:
double circumference = MathConstants.PI * diameter;

As for interfaces: Never put constants in an interface. The "constant interface" pattern is bad (justification), and the only argument to use it has been rendered invalid since import static was added to Java.

Answer 3

Interfaces are designed to define common behaviours, enums to define common values.

Enum represents a real value which can be compared to another value, or stored in the database easily. You can also have a flag-enum (in C#, don't know in Java) which let you perform binary operations on enum's values (AND, OR, XOR, etc).

Answer 4

If you work with Java 5 or newer then Enum are the way to go. The only exception is if your list of const is open and can be extended. Enums can not be extended. Another exception is if it are single values like a MAX_INTEGER.

Answer 5

Just a code :

public interface InterfaceForConstants() {
    String **TOTO** = "Et voilà !";
    double **PI** = 3.14159265358979323846;
}

Using :

class ClasseName implements InterfaceForConstants () {

    String myString;

    if (myString.equals(**TOTO**) {
        // do something
    }

    double circumference = **PI** * diameter; // instead of MathConstants.PI * diameter;

}

Clean and simple. If something can do what you need, take the simplest one! Writing code by the rules is good, writing code that is easy to read is better, even if a rule is not respected. Think about when you have to read your code after a few months. If you want to be more specific, make a javadoc to explain it!