I prefer Guice generally, but this will work great in simple situations.

It’s very useful not just for this, but also for utility methods that are designed to operate on the interface. For example, I don’t know about you, but in my book, “Collections.sort(someList);” is just an ugly ugly hack. List.sort(someList) would have been better. someList.sort() would have been best. But, because that last one is a lot more difficult to accomplish, List.sort(someList) seems the best for now. But you can’t write that, because you can’t have static methods in interfaces.

The rules would be simple:

1. static methods in interfaces -must- be defined, and

2. If there is a call ambiguity, it’s a compile time error to call it at all.

#2 exists for an unfortunate coincidence: With defined methods in an interface, combined with the unfortunate rule that in java, even static methods exhibit a certain amount of inheritance (if you extend class X, where X.foobar() is a valid method, than Y.foobar() will also ‘find’ X.foobar), you can create multiple inheritance annoyances.

e.g:

public interface X { public static void foobar() {} }

public interface Y { public static void foobar() {} }

public class Z implements X, Y {}

Which foobar is triggered by Z.foobar()?

That’s what #2 is for. It’s very rare because there aren’t many good reasons to call foobar by invoking Z instead of the real X or Y. It won’t change depending on the runtime instance.

@Caoyuan: Gotcha, won’t work for that. I’ve been meaning to try out that ServiceLoader stuff for a while….if only I was on Java 6.

Your method is suitable for these singletons. What I encounter is bit a different, the interface and the implementation should be separated in different packages based on in NetBeans Module mechanism, or someting called super package, which is also under a JSP.

public interface Foo
{
// methods for interface Foo …

static class Singleton
{
private static Foo instance;

public static void set( final Foo foo )
{
if( instance == null )
instance = foo;
}

public static Foo get()
{
return instance;
}
}
}

Then, somewhere in bootstrapping of the app (say a ServletContextListener in a webapp):

Foo.Singleton.set( new FooImpl() );