Inhertiting static member variable !

[Prathamesh Gaddam]

How does the static memeber variable behaves towards inheritance? For e.g

class X {
static int a;
}

class Y extends X{ }

Class Z extends Y{

public static void main(String[] S){
X x = new X();
S.o.p(X.a);
x.a++;
Y y = new Y();
S.o.p(y.a);
Y.a++;
S.o.p(Z.a);
}
}

Please clarify any other behaviours of static variable towards inheritance, with respect to memory allocation, stack, heap and object reference.

[Jeanne Boyarsky]

Prathamesh,
There is only one A variable no matter how many instances or subclasses you have. While all of those references do refer to the same A variable, the code is harder to read. It is better to always refer to the static variable through the class hosting it - in this case X. Otherwise, someone reading the code has to figure out that there are three different ways of referring to the same variable in the method.

[Rob Spoor]

Originally posted by Prathamesh Gaddam:
How does the static memeber variable behaves towards inheritance?

Until a subclass hides it, a static field or method is available through the class itself, its subclasses and instances of all those classes. However, it is also available through null references! All that matters for those is the class the reference is declared as:

public class X
{
    public static int A = 5;
 
    public static void main(String[] args) throws Exception
    {
        X x = null;
        System.out.println(x.A);
        X[] array = new X[0];
        System.out.println(array[-1].A);
    }
}

Although x is null, it is declared as being of class X, so x.A actually executes X.A.

That code also shows something that has been allowed in previous versions of Java: although the array index is invalid, Java 1.3 (I believe) allowed it and would print 5 - since only the declared type (X) was used.
This is no longer possible though.


Now, if a subclass of X called Y would also declare a static field called A, then the declared type is what matters:

public class X
{
    public static int A = 5;
 
    public static void main(String[] args) throws Exception
    {
        X x = null;
        System.out.println(x.A); // prints 5
        x = new Y();
        System.out.println(x.A); // prints 5 because declared as X although it is a Y
        Y y = (Y)x;
        System.out.println(y.A); // prints 7 because declared as Y
    }
}
 
class Y extends X
{
    public static int A = 7;
}

[Prathamesh Gaddam]

Amazing! It's what I call it as real fundu! Dhanyavaad (Thank you in Hindi).

Please confirm as what I have understood.

In the hierarchy of class and its sub-class a single copy of static variable is maintained on heap which can be referred by null or class-type reference.

[Peter Chase]

While it is legal Java to invoke a static method using an object reference (which may be null), it is very bad practice to do so. You should always invoke it using the class literal.

// LEGAL BUT VERY BAD PRACTICE
MyObject myNullRef = null;
myNullRef.doStaticMethod();   
 
// LEGAL BUT BAD PRACTICE
MyObject myObjectRef = new MyObject();
myObjectRef.doStaticMethod(); 
 
// LEGAL BUT DOESN'T DO WHAT IT LOOKS LIKE IT DOES
MyObject mySubclassRef = new MySubclass();
mySubclassRef.doStaticMethod();
 
// THE RIGHT WAY
MyObject.doStaticMethod();