通过静态方法访问单例字段

Question

I have a singleton class.

When accessing the methods of the class I have the choice of two possibilities.

1. Create those methods as instance specific and then get the instance and invoke them
2. Create those methods as static and invoke them and they will get the instance

For example:

Class Test{

 private int field1;

 Test instance;

 private Test(){};

 private Test getInstance(){
    if (instance == null)
       instance = new Test();
    return instance;
 }

 public int method1() { return field1;}
 public static int method2() {return getInstance().field1;}
}

Now, elsewhere I can write

 int x = Test.getInstance().method1();
 int y = Test.method2();

Which is better? I can think of a 3rd alternative where I use "instance" directly in the static method and then capture the exception if it is null and instantiate it and then re-invoke itself.

I could, in theory, just make the whole lot static. However, this will create me problems when saving the state at activity close since the serialization doesn't save static.

Answer 1

You should avoid making everything static. Some people would even say that a singleton is not done.

Answer 2

I think the first one is cleaner.

However, keep in mind that under some extreme cases, Android may kill your static instances. See this for example: http://code.google.com/p/acra/ .

A workaround I've found somewhere for this, is to keep a reference to your singleton from the Application class, as well. I don't know how problem-proof this is, though.

Answer 3

The whole point of the singleton pattern is that you can change the implementation . In most cases you use it to keep the possibility open to "hook" in some other implementations of this functionality later.

Read: when deciding in favor of singleton plan for a setInstance method too, not just for a getInstance . - If this does not make sense, just use a plain static class.

In the other hand singletons are out of season, if you want to be hip and all that. Do a search for " eliminating global state ". There are some Google-sponsored talks about it too. In short: your code will be more testable and helps you avoid some dependency chaos. (Besides being hip and all, it is definitely a step into the right direction).

Answer 4

In my personal opinion having static methods is bad design in the first place. It, of course, depends on the program itself, but allowing a class to have static method will have impact on the whole design. Some reasoning behind my statement:

1. If static method can easily change state of some object, sooner or later bugs will emerge
2. If you publish static method with your program, every client that will use it will have a very strong dependency on your code. If you decide to remove or change this method someday - you will break every single client that used your class.

So, if you can - avoid it .

If, from any reason, you will insist on having static method, I guess the first solution is better . That's how singleton should work. You should obtain a reference to a SINGLETON OBJECT via static method, but this object should be then used according to all principles from Object Oriented Programming .