Re: Singletons?

Mark Space wrote:


The static keyword for classes has a different meaning to 'only allow
one instance of this class'

And so static can not be used for 'top level' classes. It can be used
for nested classes.

For clarification on the different levels and behaviors of classes, see
http://java.sun.com/docs/books/tutorial/java/javaOO/nested.html


This is not a singleton - this would be an implementation of the
MonoState design pattern [*]


Yes


No, they are completely different 'Instances' of the class 'anAPI'

The two static methods do not belong to any object instance of the
class. They are Class methods.

There are various ways of creating singletons in Java, the other posters
link to articles about concurrency are highly recommended reading.

To summarize though....

Simple singleton, where the sole instance will be created at ClassLoad
time (normally right at the beginning of the program's run)

All class variables (statics) create when Class is loaded into memory by
JVM - usually at program start time.

public class Singleton {

   private static Singleton theInstance = new Singleton();

   public static Singleton getInstance() {
      return theInstance;
   }

   // Instance methods - not class methods.
   public void methodA();
   public void methodB();
}

For most cases this approach is probably the best. Its only issue is one
of resource management, which you might want to lazy load.

In that case, we simple don't create the single instance class when
declaring it, we create it the first time 'getInstance()' is called.

public class Singleton {

   private static Singleton theInstance = null;

   public static synchronized Singleton getInstance() {
      if (theInstance == null) {
    theInstance = new Singleton();
      }
      return theInstance;
   }

   // Instance methods - not class methods.
   public void methodA();
   public void methodB();
}

The last remaining choice you'd need to make, is how to prevent (at
least indicate) that no instances of the class should be create or used
that haven't come from the Class's factory method 'getInstance()'.

The typical approach is as other posters have pointed out, to create a
Private default no argument constructor.

public class Singleton {
   ....
   private Singleton() {}
}

This will cause a compile time error should someone attempt the
following any where else in the code base:

Singleton another instance = new Singleton();

However, this is easily over come using reflection, so it can't be
relied upon as a prevent mechanism. Its merely a good indicator to
other developers.

Another approach to get the same (limited) level of protection is to
simply mark the class as being Abstract.

public abstract class Singleton {
   ...
}

This also prevents people from new-ing an instance and causes a compile
time error.

There's a whole argument about which is more likely or not to be
circumvented by people, which normally boils down to a question on how
much do we trust the team to use the singleton properly.

Personally, as the only users of Singletons should be the development
team who create them, I trust them to not circumvent them. I'd never
let a Singleton be used in an API library. I'd ensure the API library
had the same abilities, without exposing the singleton class, thereby
safeguarding against circumvention.

[*] What is a MonoState?

A MonoState class is simply a class which has all static variables and
static methods.

Whilst we can create numerous instances of the MonoState class, there
are no instance member variables nor methods and so the state is shared
amongst all instances.

MonoStates can be thought of as being similar to Singletons. However,
their usage is different.

public class MonoStateCounter {
    private static int counter = 0;

    public static void increment() {
      counter++;
    }

    public static counterValue() {
      return counter;
    }
}

With this MonoStateCounter, we can create numerous instances that all
share the same countervalue.

public class Test {

   public static main(String[] args) {
     MonoStateCounter c1 = new MonoStateCounter();
     MonoStateCounter c2 = new MonoStateCounter();

     int startValue = c1.counterValue();

     c2.increment();

     int endValue = c1.counterValue();

     System.out.println(startValue);
     System.out.println(endValue);
   }

}

---------------

This would print out:

0
1

There are numerous pros and cons of using MonoStates vs Singletons,
probably best described here:

http://www.objectmentor.com/resources/articles/SingletonAndMonostate.pdf