confusion in variable initialization concepts

[Ansar Shah]

Hello All!

 
public abstract class A {
int a = 8;
public A() {
show();
}
abstract void show();
}
 
public class Trick extends A{
int a = 90; 
void show(){
System.out.println(
"value of a is " + a); 
}
public static void main(String args[]){ 
new Trick(); 
}
}

The out put of the main() method is "value of a is 0". Please explain the flow. It is a bit confusing for me.

Thanks
Ansar Shah

[Gunjan Kumar]

In main method, you are creating a instance of Trick(), so Trick constructor will get called and consequntly Super class(A) constructor will get called. In Super class constructor, you are calling Show() method.
Here int a =8 and int a =90 are instance variable and instance variable runs after the compiler's call to super.
So when show() method get called , value of a was 0(default value).
So it is displaying 0.

[Jesse Custer]

Howdy Ansar,

thanks for this great example. It was a real eye opener for me. The call to show() in the super class A will always point to the implementation in the Subclass Trick. At wich point the variable a of class Trick still has default value 0.
I would never have expected that. This is even the case when class A is not abstract and has it's own implementation of show().
In other words, the next piece of code gives exactly the same result.

public class A {
int a = 8;
        public A() {
show();
}
void show() {
System.out.println("value of a is " + a);
}
}
public class Trick extends A{
int a = 90;
void show() {
System.out.println("value of a is " + a);
}
public static void main(String args[]) {
new Trick();
}
}

[Chandra Bhatt]

Thank you everybody for raising this eye opening question. After a long time
seeing this kind of question.

Already you ranchers have given your fantastic examples:
See little modified code as well:

class A1 {
int a = 8;
        public A1() {
show();
}
void show() {
System.out.println("value of a is " + a);
}
}
public class Trick extends A1{
//int a = 90;
void show() {
System.out.println("value of a is " + a);
}
public static void main(String args[]) {
new Trick();
}
}

It prints "value of a is " + 8

[John Stone]

This topic is well-covered in "Thinking in Java" by Bruce Eckel.
Polymorphic and constructors.

class A1 {
static {
System.out.println("A1 static");
}
int a;
{
System.out.println("A1 non-static");
a = 9;
}

    public A1() {
        System.out.println("A1 constructor");
show();
}
void show() {
System.out.println("value of a is " + a);
}
}
 
class A2 extends A1{
static {
System.out.println("A2 static");
}

{
System.out.println("A2 non-static");
}
 
public A2() {
System.out.println("A2 constructor");
}
 
void show() {
System.out.println("value of a is " + a);
}
}
 
class Trick{
public static void main(String args[]) {
new A2();
}
}

output is

A1 static
A2 static
A1 non-static
A1 constructor
value of a is 9
A2 non-static
A2 constructor
 

I try to summarize what I remember:

1. class loader must load the class (this can happen when you want to create new object or access some static mameber.
2. if this class has base class, base is load prior to descendant (of course)
3. class objects are created (from the top (base) to bottom descendant), all static members are initialized (from top to bottom)
4. when there is all information needed how new object will look like, the memory is allocated and set to binary zero
5. constructor of class is called (which calls base constructor first)
6. when base class is constructed all non-static members are initialized
7. body of constructor is executed

(If I screwed up something, please correct me)