Initialization Blocks -- Practical Example.

Question

I am curious about I topic that I have just recently learned about and would like to post it for discussion.
Does anyone know of a practical example of the use of an initialization block? Why would one want to use an initialization block? What can be accomplished with an initialization block that you cannot accomplish with a constructor that doesn't accept any parameters?

Answer 1

Hi Robert,
Initializers are used in initialization of object and classes. They can also be used to define constants in Interfaces.
Here I am explaning by corelating the Constructor with Initialization.
In what order is initialization code executed? What should I put where ?
Instance variable initialization code can go in three places within a class:
In an instance variable initializer for a class (or a superclass).
class C {
String var = "val";
In a constructor for a class (or a superclass).
public C() { var = "val"; }
In an object initializer block. This is new in Java 1.1; its just like a static initializer block but without the keyword static.
{ var = "val"; }
The order of evaluation (ignoring out of memory problems) when you say new C() is:
1.Call a constructor for C's superclass (unless C is Object, in which case it has no superclass). It will always be the no-argument constructor, unless the programmer explicitly coded super(...) as
the very first statement of the constructor.
2.Once the super constructor has returned, execute any instance variable initializers and object initializer blocks in textual (left-to-right) order. Don't be confused by the fact that javadoc and
javap use alphabetical ordering; that's not important here.
3.Now execute the remainder of the body for the constructor. This can set instance variables or do anything else.
In general, you have a lot of freedom to choose any of these three forms. My recommendation is to use instance variable initailizers in cases where there is a variable that takes the same value
regardless of which constructor is used. Use object initializer blocks only when initialization is complex (e.g. it requires a loop) and you don't want to repeat it in multiple constructors. Use a constructor
for the rest.
Here's another example:
Program:
class A {
String a1 = ABC.echo(" 1: a1");
String a2 = ABC.echo(" 2: a2");
public A() {ABC.echo(" 3: A()");}
class B extends A {
String b1 = ABC.echo(" 4: b1");
String b2;
public B() {
ABC.echo(" 5: B()");
b1 = ABC.echo(" 6: b1 reset");
a2 = ABC.echo(" 7: a2 reset");
class C extends B {
String c1;
{ c1 = ABC.echo(" 8: c1"); }
String c2;
String c3 = ABC.echo(" 9: c3");
public C() {
ABC.echo("10: C()");
c2 = ABC.echo("11: c2");
b2 = ABC.echo("12: b2");
public class ABC {
static String echo(String arg) {
System.out.println(arg);
return arg;
public static void main(String[] args) {
new C();
Output:
1: a1
2: a2
3: A()
4: b1
5: B()
6: b1 reset
7: a2 reset
8: c1
9: c3
10: C()
11: c2
12: b2
When should I use constructors, and when should I use other methods?
The glib answer is to use constructors when you want a new object; that's what the keyword new is for. The infrequent answer is that constructors are often over-used, both in when they are called and
in how much they have to do. Here are some points to consider
Modifiers: As we saw in the previous question, one can go overboard in providing too many constructors. It is usually better to minimize the number of constructors, and then provide modifier
methods, that do the rest of the initialization. If the modifiers return this, then you can create a useful object in one expression; if not, you will need to use a series of statements. Modifiers are
good because often the changes you want to make during construction are also changes you will want to make later, so why duplicate code between constructors and methods.
Factories: Often you want to create something that is an instance of some class or interface, but you either don't care exactly which subclass to create, or you want to defer that decision to
runtime. For example, if you are writing a calculator applet, you might wish that you could call new Number(string), and have this return a Double if string is in floating point format, or a Long if
string is in integer format. But you can't do that for two reasons: Number is an abstract class, so you can't invoke its constructor directly, and any call to a constructor must return a new instance
of that class directly, not of a subclass. A method which returns objects like a constructor but that has more freedom in how the object is made (and what type it is) is called a factory. Java has no
built-in support or conventions for factories, but you will want to invent conventions for using them in your code.
Caching and Recycling: A constructor must create a new object. But creating a new object is a fairly expensive operation. Just as in the real world, you can avoid costly garbage collection by
recycling. For example, new Boolean(x) creates a new Boolean, but you should almost always use instead (x ? Boolean.TRUE : Boolean.FALSE), which recycles an existing value rather than
wastefully creating a new one. Java would have been better off if it advertised a method that did just this, rather than advertising the constructor. Boolean is just one example; you should also
consider recycling of other immutable classes, including Character, Integer, and perhaps many of your own classes. Below is an example of a recycling factory for Numbers. If I had my choice, I
would call this Number.make, but of course I can't add methods to the Number class, so it will have to go somewhere else.
public Number numberFactory(String str) throws NumberFormatException {
try {
long l = Long.parseLong(str);
if (l >= 0 && l < cachedLongs.length) {
int i = (int)l;
if (cachedLongs[i] != null) return cachedLongs;
else return cachedLongs[i] = new Long(str);
} else {
return new Long(l);
} catch (NumberFormatException e) {
double d = Double.parseDouble(str);
return d == 0.0 ? ZERO : d == 1.0 ? ONE : new Double(d);
private Long[] cachedLongs = new Long[100];
private Double ZERO = new Double(0.0);
private Double ONE = new Double(1.0);
We see that new is a useful convention, but that factories and recycling are also useful. Java chose to support only new because it is the simplest possibility, and the Java philosophy is to keep the
language itself as simple as possible. But that doesn't mean your class libraries need to stick to the lowest denominator. (And it shouldn't have meant that the built-in libraries stuck to it, but alas, they
did.)
I have a class with six instance variables, each of which could be initialized or not. Should I write 64 constructors?
Of course you don't need (26) constructors. Let's say you have a class C defined as follows:
public class C { int a,b,c,d,e,f; }
Here are some things you can do for constructors:
1.Guess at what combinations of variables will likely be wanted, and provide constructors for those combinations. Pro: That's how it's usually done. Con: Difficult to guess correctly; lots of
redundant code to write.
2.Define setters that can be cascaded because they return this. That is, define a setter for each instance variable, then use them after a call to the default constructor:
public C setA(int val) { a = val; return this; }
new C().setA(1).setC(3).setE(5);
Pro: This is a reasonably simple and efficient approach. A similar idea is discussed by Bjarne Stroustrop on page 156 of The Design and Evolution of C++. Con: You need to write all the little
setters, they aren't JavaBean-compliant (since they return this, not void), they don't work if there are interactions between two values.
3.Use the default constructor for an anonymous sub-class with a non-static initializer:
new C() {{ a = 1; c = 3; e = 5; }}
Pro: Very concise; no mess with setters. Con: The instance variables can't be private, you have the overhead of a sub-class, your object won't actually have C as its class (although it will still be an
instanceof C), it only works if you have accessible instance variables, and many people, including experienced Java programmers, won't understand it. Actually, its quite simple: You are defining a
new, unnamed (anonymous) subclass of C, with no new methods or variables, but with an initialization block that initializes a, c, and e. Along with defining this class, you are also making an
instance. When I showed this to Guy Steele, he said "heh, heh! That's pretty cute, all right, but I'm not sure I would advocate widespread use..."
4.You can switch to a language that directly supports this idiom.. For example, C++ has optional arguments. So you can do this:
class C {
public: C(int a=1, int b=2, int c=3, int d=4, int e=5);
new C(10);
Common Lisp has keyword arguments as well as optional arguments, so you can do this:
(defstruct C a b c d e f) ; Defines the class
(make-C :a 1 :c 3 :e 5) ; Construct an
instance
What about class initialization?
It is important to distinguish class initialization from instance creation. An instance is created when you call a constructor with new. A class C is initialized the first time it is actively used. At that time,
the initialization code for the class is run, in textual order. There are two kinds of class initialization code: static initializer blocks (static { ... }), and class variable initializers (static String var =
Active use is defined as the first time you do any one of the following:
1.Create an instance of C by calling a constructor;
2.Call a static method that is defined in C (not inherited);
3.Assign or access a static variable that is declared (not inherited) in C. It does not count if the static variable is initialized with a constant expression (one involving only primitive operators (like +
or ||), literals, and static final variables), because these are initialized at compile time.
Here is an example:
Program:
class A {
static String a1 = ABC.echo(" 1: a1");
static String a2 = ABC.echo(" 2: a2");
class B extends A {
static String b1 = ABC.echo(" 3: b1");
static String b2;
static {
ABC.echo(" 4: B()");
b1 = ABC.echo(" 5: b1 reset");
a2 = ABC.echo(" 6: a2 reset");
class C extends B {
static String c1;
static { c1 = ABC.echo(" 7: c1"); }
static String c2;
static String c3 = ABC.echo(" 8: c3");
static {
ABC.echo(" 9: C()");
c2 = ABC.echo("10: c2");
b2 = ABC.echo("11: b2");
public class ABC {
static String echo(String arg) {
System.out.println(arg);
return arg;
public static void main(String[] args) {
new C();
Output:
1: a1
2: a2
3: b1
4: B()
5: b1 reset
6: a2 reset
7: c1
8: c3
9: C()
10: c2
11: b2
I hope the above will help you.
Thanks
Bakrudeen