Re: Updates to a single class instance

unlikeablePorpoise@gmail.com wrote:


     ... effectively making all of them "global variables."
Global variables are very convenient when you start to write
a program, but they have drawbacks that tend to become more
and more troublesome as the program grows and changes. Be
warned! Global variables deserve their ill repute.

     ... but if you're sure this is what you want, it sounds
like you should use what's called a "singleton:" a class with
exactly one instance (you can enforce this by making the only
constructor private and calling it exactly once from within
the class). You could make that one instance be a member of
the class:

    public class Global {
        private Global() { }
        public static final Global INSTANCE = new Global();
    }

.... or you could keep the instance private and use an accessor
method to provide it to the rest of the program:

    public class Global {
        private Global() { }
        private static final Global INSTANCE = new Global();
        public static Global getInstance() {
            return INSTANCE;
        }
    }

     For the variables the Global instance contains you have a
similar choice: Make them public, or keep them private and
write methods to set and retrieve their values. Usually the
latter is the better choice, because it allows for much more
flexibility: it's easy to make validity checks on the values
that are set, it's easy to keep valueB up to date when valueA
changes, and so on.

     You can even do without the Global instance altogether,
making all the variables static members of the Global class
itself:

    public class Global {
        private Global() { }

        private static int valueA;
        public static int getValueA() { return valueA; }
        public void setValueA(int newValue) {
            if (newValue < 42)
                throw new IllegalArgumentException(...);
            valueA = newValue;
        }
        ...
    }

     Keep in mind, though, that all of these techniques are
just variations on the global variable, a construct that is
capable of causing a surprising amount of trouble.

--
Eric Sosman
esosman@ieee-dot-org.invalid