“To call doStaticMethod we simply invoke it via the class: StaticClass.doStaticMethod()”

charles.

If the design calls for “at most one instance” in the environment use the Singleton pattern.

If the design calls for a class (with possibly multiple instances) closely associated with the enclosing class (or the programmer is too lazy to creat another file) use “static.

A class that is both would be “static Singleton”.

The internal data type distinctions above are possible “propritary” guidelins but somewhat articfical to me.

What am I missing?

This is called out in Section 12.4.1 of the Java2 Language Spec, which also defines “first access” as being creation of an instance (“new”), usage of any static method, or access to any non-constant static field. Certain reflective operations also can cause class initialization.

Per the spec, “A class or interface will not be initialized under any other circumstance.”

Section 12.4.1 can be found at http://java.sun.com/docs/books/jls/second_edition/html/execution.doc.html#57946

Because the ‘B’ class is loaded in the ‘A’ constructor, ‘B’ statically initializes it’s ‘A’ variable. The singleton object hasn’t been created yet (it hasn’t returned from the original call to the constructor), therefore ‘A’s instance variable is still null. End result is you get two ‘A’ objects in memory.

The better way to do it is like this:

....
private static A instance = new A();
public static A getInstance() {

return instance;
}
....

You still get a “false” printing out, because the references are different. However, only one object is created – this preserves the singleton.

// Main.java
class A {

// A is a singleton. The getInstance() method is even synchronized.
private static A instance;
public synchronized static A getInstance() {
return (instance null) ? (instance = new A()) : instance;
}

// A uses B
private B b;
private A() {
b = new B();
}
}

class B {

// B caches the only instance of A
public static A a = A.getInstance();
}

class Main {

public static void main(String[] args) {
System.out.println(A.getInstance() B.a);
}
}