Non-static initializer vs Constructor

[A Kumar]

Hi all,

Both non-static initializer block and a constructor are xcuted during instance creation...u can set values in these blocks..


Then when should we make use of non-static initializer block..

And whats the difference between non-static block and constructor..?

Thx
A Kumar

[Ilja Preuss]

The non-static initializer is the only way to do initialization in an anonymous inner class, as those can't have constructors.

[A Kumar]

Thanks Ilja....

[Philip Heller]

Good one, Ilja!

Also, you might have a class with a dozen constructors, each of which begins with the same lines. If you factor those lines out into a non-static initializer, you guarantee that all constructors will call them in the right order. Even constructors that haven't been written yet.

-- Phil

[kenji mapes]

Wow. Learn something new everyday here. I am amazed at your guy's wealth of knowledge.

[Mahesh x Bogadi]

Sorry I could not understand.

Please add a coding example!!

[Ilja Preuss]

Originally posted by Philip Heller:

Also, you might have a class with a dozen constructors, each of which begins with the same lines. If you factor those lines out into a non-static initializer, you guarantee that all constructors will call them in the right order. Even constructors that haven't been written yet.

I typically prefer constructor chaining for that, but I suppose there are examples where this doesn't work well.

I'd like to see an example, too!

[Philip Heller]

Here's an example of what I mean:

  
 
class A {
    DataOutputStream    dos;
    Socket              sock;
    
    {
        // Initialize dos & sock.
    }
 
    A(int x, int y)
    {
        // Stuff with x & y
    }
 
    A(Thread t, String s)
    {
        // Stuff with t & s
    }
}

The DataOutputStream and the Socket need multi-line initializer code because presumably their initialization involves calls that throw exceptions. The 3 constructors have no overlapping args, which is what makes this case a candidate for this approach.

Without a non-static initializer, we would have something like:

class A {
    DataOutputStream    dos;
    Socket              sock;
    
    A(int x, int y, Thread t, String s)
    {
        // Initialize dos & sock.
        if (x != -1 && y != -1)
        {
            // Stuff with x & y
        }
        else if (t != null  &&  s != null)
        {
            // Stuff with t & s
        }
    }
 
    A(int x, int y)
    {
        this(x, y, null, null);
    }
 
    A(Thread t, String s)
    {
        this(-1, -1, t, s);
    }
}

And it just gets stickier if there are more ctors.

-- Phil

[Ilja Preuss]

Originally posted by Philip Heller:
Here's an example of what I mean:

[...]

Without a non-static initializer, we would have something like:

class A {
    DataOutputStream    dos;
    Socket              sock;
    
    A(int x, int y, Thread t, String s)
    {
        // Initialize dos & sock.
        if (x != -1 && y != -1)
        {
            // Stuff with x & y
        }
        else if (t != null  &&  s != null)
        {
            // Stuff with t & s
        }
    }
 
    A(int x, int y)
    {
        this(x, y, null, null);
    }
 
    A(Thread t, String s)
    {
        this(-1, -1, t, s);
    }
}

That would be bad. But it can be made better:

class A {
    DataOutputStream    dos;
    Socket              sock;
    
    private A()
    {
        // Initialize dos & sock.
    }
 
    A(int x, int y)
    {
        this();
        // Stuff with x & y
    }
 
    A(Thread t, String s)
    {
        this();
        // Stuff with t & s
    }

Granted, the initializer has the advantage that you can't forget to call it. But it's probably more a matter of style, isn't it?

[Layne Lund]

Originally posted by Ilja Preuss:

class A {
    DataOutputStream    dos;
    Socket              sock;
    
    A(int x, int y, Thread t, String s)
    {
        // Initialize dos & sock.
        if (x != -1 && y != -1)
        {
            // Stuff with x & y
        }
        else if (t != null  &&  s != null)
        {
            // Stuff with t & s
        }
    }
 
    A(int x, int y)
    {
        this(x, y, null, null);
    }
 
    A(Thread t, String s)
    {
        this(-1, -1, t, s);
    }
}

<hr></blockquote>

That would be bad. But it can be made better:

class A {
    DataOutputStream    dos;
    Socket              sock;
    
    private A()
    {
        // Initialize dos & sock.
    }
 
    A(int x, int y)
    {
        this();
        // Stuff with x & y
    }
 
    A(Thread t, String s)
    {
        this();
        // Stuff with t & s
    }

Granted, the initializer has the advantage that you can't forget to call it. But it's probably more a matter of style, isn't it?[/QB]

I like Ilja's alternative better since it avoids the possibility of calling the ctor with t set to null but s as a valid reference.

Layne

[Philip Heller]

Yep, it comes down to style ... for both approaches there are good and bad situations. For my personal style, the non-static initializer says, "Never ever construct without doing the stuff in the initializer."

[Ilja Preuss]

Originally posted by Layne Lund:

I like Ilja's alternative better since it avoids the possibility of calling the ctor with t set to null but s as a valid reference.

Just for clarification: I don't think anyone said the first constructor chaining example was a good idea. The alternative we were assessing was the use of instance initializers.

[Dao Kia]

Hello everyone,

Looking at this post, I have a question coming up in my head.

If I have a class like this:

class Test {

FileWriter fw;
{
try {
fw = new FileWriter("das.txt");
}
catch (IOException ioe){

}
}

// And some other code
}

It compiles fine. But how can I NOT catch the IOException and let the caller to handle it? What would be the code looks like?

Thank You,

Dao