Re: Updates to a single class instance
Thanks for your replies. I tried to use a singleton, but for some
reason each attempt to create the singleton from different classes
says the object is null (the second and subsequent calls should say
that the object has been created). Here's the test code:
package org.collector;
public class Collector{
private Collector() {}
private static Collector ref;
public static synchronized Collector getCollectorObject()
{
if(ref == null)
{
System.out.println("ref is null");
ref = new Collector();
}
else
{
System.out.println("ref exists");
}
return ref;
}
}
When I call 'Collector col = Collector.getCollectorObject();' twice in
two different classes, it returns "ref is null". However, if I do this
twice in the same class method, ie
Collector col = Collector.getCollectorObject();
Collector col2 = Collector.getCollectorObject();
I get the expected result:
"ref is null"
"ref exists"
Just to clarify, the Collector singleton is in its own package, and
the methods that have to access it are in different packages.
Am I missing something here? Or is the singleton limited to use one
class or package?
Thanks for your help!
Sarah
On Aug 18, 1:40 pm, Eric Sosman <esos...@ieee-dot-org.invalid> wrote:
unlikeablePorpo...@gmail.com wrote:
I hope you guys can help me.
I am planning to write a program with multiple packages and one of
these packages will have a class with storage variables that I would
like to update from any other class. I would like to know whether
there is a way to "point" to a single instance of this class so that I
can update the variables from anywhere in the program.
... 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
esos...@ieee-dot-org.invalid