Over Riding Variables

[rimzim sinha]

Like methods in subclass override methods in superclass, what happens to the variables in subclass when redefined in superclass?

Is there any concept of overriding variables?

[Manikandan Jayaraman]

Like methods in subclass override methods in superclass, what happens to the variables in subclass when redefined in superclass?

Your statement had interchanged subclass and superclass terms. I think you meant to ask what will happen to the variables of the superclass when redefined in a subclass.

Anyways, They get overrided, in short. But the catch is, the behavior after overriding.

Member Variables are compile time binded with the refernce variables.
Where as Member methods are run time binded to the object that the refernce holds. It will always be better, if you try to work out a program to find out the behavior.

 
class A
{
int a=10;
}
 
class B extends A
{
int a = 20;
}
 
public class C
{
public static void main(String args[])
{
A a1 = new A();
B b1 = new B();
A a2 = new B();
 
System.out.println(a1.a + " " + b1.a + " " + a2.a);
}
}

It prints 10 20 10. So for variables, which reference holds the object, is what that decides which value is accessed, unlike overrided member functions.
[ October 29, 2004: Message edited by: Manikandan Jayaraman ]

[Corey McGlone]

Originally posted by rimzim sinha:
Is there any concept of overriding variables?

Absolutely not!

You can't "override" a variable. If you define a variable in a subclass with the same name as a variable in a superclass, you have "hidden" the superclass variable, not "overridden" it. Overriding is for instance methods only.

Check out the JLS §8.3.3.2 Example: Hiding of Instance Variables.

[Manikandan Jayaraman]

Corey! One doubt here ... Talking literally, overriding is nothing but hiding ... right???

When we override a base class method in the derived class, we are hiding the base class method from the derived class and its objects. The similar stuff is what that happens with variables too.

If you disagree and have sufficient points to differentiate between "Hiding" and "Overriding", can you please put them forth, here! Thanks!

[Jay Pawar]

Manikandan,
In Java overridden methods are by default ( virtual ) meaning Virtual Table is created in memory which holds the virtual pointer to the function which is called at runtime ( Late binding concept ).
Hence when there is code like this
Base objBase = new Subclass();
The compiler defers the binding at run time and it will look at the contents of objBase and not the type of objBase. Here the object contents are of Subclass, so the Subclass version of the method will be called.
As far as variables are concerned, as Corey pointed out there is nothing called overriding variables. Because there is no concept of late binding for variables as described above. The compiler always does the binding for variables at compile time. In short, for VARIABLES always look at the TYPE OF OBJECT and NOT the contents of the object.

NOTE: No VTable is created in memory for holding variables.

Hope this helps you.

[Corey McGlone]

Hiding is very different from overriding. When you "override" a method, you can utilize polymorphism. When you "hide" something, you do not. Here's an example using static methods and instance methods. Note that instance methods can be overridden while static method are hidden.

class Parent
{
    public static void staticMethod()
    {
        System.out.println("Parent static method");
    }
 
    public void instanceMethod()
    {
        System.out.println("Parent instance method");
    }
}
 
class Child extends Parent
{
    public static void staticMethod()
    {
        System.out.println("Child static method");
    }
 
    public void instanceMethod()
    {
        System.out.println("Child instance method");
    }
}
 
public class Test
{
    public static void main(String[] args)
    {
        Parent p = new Parent();
        Child c = new Child();
        Parent pc = new Child();
 
        Parent.staticMethod();  // Invokes Parent static
        Child.staticMethod();   // Invokes Child static
 
        System.out.println();
 
        p.staticMethod();       // Invokes Parent static
        c.staticMethod();       // Invokes Child static
        pc.staticMethod();      // Invokes Parent static
 
        System.out.println();
 
        p.instanceMethod();     // Invokes Parent instance
        c.instanceMethod();     // Invokes Child instance
        pc.instanceMethod();    // Polymorphic invocation - Invokes Child instance
    }
}
 
// Output
 
Parent static method
Child static method
 
Parent static method
Child static method
Parent static method
 
Parent instance method
Child instance method
Child instance method

Notice how these work. When we invoke a static method, the JVM determines the compile-time type of the variable the method is being invoked upon (regardless of what the run-time type is) and invokes that method. When you invoke an instance method, the JVM first determines what the run-time type of the object is, rather than the type of the reference variable, and invokes that method. This is a polymorphic call.

I would suggest these links for some "light reading":

Static Methods CAN NOT be Overridden
Invoking Static Methods from an Instance
JSL §8.4.6 Inheritance, Overriding, and Hiding

[Manikandan Jayaraman]

Oh... Thanks Corey and Jay! Made me fine with these basics.

[Atul Chandran]

Methods are binded at run time.Are final and private methods an exception to this rule?Are they binded at compile time??

[Jay Pawar]

Original post by Atul

Methods are binded at run time.

NOT ALL METHODS are binded at run time ONLY OVERRIDDEN METHODS.

Final and private methods are always binded compile time.

Hope this helps you

[Corey McGlone]

Originally posted by Atul Chandran:
Methods are binded at run time.Are final and private methods an exception to this rule?Are they binded at compile time??

Final method can't be overridden (or hidden) so there is no notion of late-binding with a final method. In essence, a subclass of a class that defines a final method can't have a method with the same name. Therefore, you'd never even some up with a case where you'd have to wonder about this.

Private methods are not inherited so, while you could have a subclass that defines a method with the same name as a method in the superclass, there is no overriding taking place. Private method are, essentially, bound to the compile-time type.

[rimzim sinha]

Thanks you everyone,