Implement extendable set of constants

Question

Hi!
I am trying to figure out what would be a suitable way of implementing a set of default constants that should be possible to extend with custom ones. I am creating an API that will have several sets of constant values but the user of the API should be able to extend/register/add additional constants to these sets. In my first attempt I have been looking at the enum type but its not straight forward to use enums since they cannot be extended. One solution that I discovered elsewhere was to define an interface for the constants and let the enum implement that interface. However I am not really sure I understand how this should look.
It would be great with some code examples on the enum solution mentioned above. Other suggestions are also appreciated!

Answer 1

Encephalopathic, thats a good question.
I guess it is because they actually are constants in the API and I want the user to treat them as constants.What do you mean in the part I underlined?
There are lots of ways to prevent the user to change a reference (the surest one being not to expose it at all, more on that later).
Moreover the user should have easy access to the values (like Substance.PO4).Which your DefaultSubstance attempt above achieves.
I also want to prevent multiple instances of the same value (substance).Can you elaborate why?
Often this "need" to have only one instance is overrated (if not plain wrong). For the occasions where it is valid (and countless discussions on whether it is or isn't), you can look at the Singleton design pattern, and the (unofficial name but easily derived) multiton variant.
Let's say that I implement a simple Substance class and then a DefaultSubstances class that defines the default set of values:Fine sketch.
It feels like I do not have enough control when the user subclass this class to implement new constants.Which kind of "control" do you want?
Most of what I can imagine can be achieved by doing checks in the constructor of a root superclass, e.g. Substance (if a user subclasses the class, the compiler/JVM will make sure his constructor invokes yours). e.g. if you want to make sure no-one redefines a substance named "PO4" that's easily done in the superclass' constructor.
And how do I make this class and all subclasses iterable over all defined constants?The root superclass can maintain a private static map of all known substances, populated by the constructor.
Remember the point about not exposing the reference? Well the root superclass could expose the known substances via a method call:
Substance po4 = Substance.get("PO4");
Perhaps it would be a good soultion to give up the enum classNot necessarily. But you sure can't extend enums, so you'd have to define an interface, as Joachim demonstrated; but with an interface you don't have the "veto" power of a mandatory superconstructor.
In general: can you elaborate on what the Substance class does? Which methods does it expose (you know enums can expose methods)?
How is it used (e.g. switch statements).
It is also possible that the code might be refactored into something completely different, leveraging polymorphism instead of if/switch based on constants, but that depends on the usage.
Edited by: jduprez on Mar 1, 2010 12:18 PM