Question

I am working on a little pinball-game project for a hobby and am looking for a pattern to encapsulate constant variables.

I have a model, within which there are values which will be constant over the life of that model e.g. maximum speed/maximum gravity etc. Throughout the GUI and other areas these values are required in order to correctly validate input. Currently they are included either as references to a public static final, or just plain hard-coded. I’d like to encapsulate these ‘constant variables’ in an object which can be injected into the model, and retrieved by the view/controller.

To clarify, the value of the ‘constant variables’ may not necessarily be defined at compile-time, they could come from reading in a file; user input etc. What is known at compile time is which ones are needed. A way which may be easier to explain it is that whatever this encapsulation is, the values it provides are immutable.

I’m looking for a way to achieve this which:

• has compile time type-safety (i.e. not mapping a string to variable at runtime)
• avoids anything static (including enums, which can’t be extended)

I know I could define an interface which has the methods such as:

 public int getMaximumSpeed();  public int getMaximumGravity(); 

… and inject an instance of that into the model, and make it accessible in some way. However, this results in a lot of boilerplate code, which is pretty tedious to write/test etc (I am doing this for funsies :-)).

I am looking for a better way to do this, preferably something which has the benefits of being part of a shared vocabulary, as with design patterns.

Is there a better way to do this?

P.S. I’ve thought some more about this, and the best trade-off I could find would be to have something like:

public class Variables {    enum Variable {        MaxSpeed(100),        MaxGravity(10)         Variable(Object variableValue) {           // assign value to field, provide getter etc.        }    }     public Object getVariable(Variable v) { // look up enum and get member }  } // end of MyVariables 

I could then do something like:

Model m = new Model(new Variables()); 

Advantages: the lookup of a variable is protected by having to be a member of the enum in order to compile, variables can be added with little extra code
Disadvantages: enums cannot be extended, brittleness (a recompile is needed to add a variable), variable values would have to be cast from Object (to Integer in this example), which again isn’t type safe, though generics may be an option for that… somehow

Answer 1

Are you looking for the Singleton or, a variant, the Monostate? If not, how does that pattern fail your needs?

Of course, here’s the mandatory disclaimer that Anything Global Is Evil.

UPDATE: I did some looking, because I’ve been having similar debates/issues. I stumbled across a list of ‘alternatives’ to classic global/scope solutions. Thought I’d share.