I favour lazy initialization combined with self-encapsulation:
private Object getObject() {
Object o = this.object;
if( o == null ) {
o = createObject();
this.object = o;
}
return o;
}
This is thread-safe and allows injecting new behaviour via polymorphism (overriding the "create" methods in a subclass), which adheres to the Open-Closed Principle. It also eliminates the possibility of accidentally dereferencing nulls.
It could even be implemented as a language feature:
public class C {
nullsafe String name;
public void greeting() {
System.out.printf( "Hello, %s\n", getName() );
}
}
Where the "nullsafe" keyword automatically generates a private accessor and corresponding protected creation method.
Just put a `synchronized` on it and call it good. The JVM is so damn fast, _nearly_ all the stuff in the Haggar book (Practical Java) is not applicable anymore.
3 comments
[ 3.1 ms ] story [ 14.0 ms ] threadI often see code such as:
I favour lazy initialization combined with self-encapsulation: This is thread-safe and allows injecting new behaviour via polymorphism (overriding the "create" methods in a subclass), which adheres to the Open-Closed Principle. It also eliminates the possibility of accidentally dereferencing nulls.It could even be implemented as a language feature:
Where the "nullsafe" keyword automatically generates a private accessor and corresponding protected creation method.Just put a `synchronized` on it and call it good. The JVM is so damn fast, _nearly_ all the stuff in the Haggar book (Practical Java) is not applicable anymore.