Overriding member variables in Java ( Variable Hiding)

Question

I am studying overriding member functions in JAVA and thought about experimenting with overriding member variables.

So, I defined classes

public clas         


        

Answer 1

When you make a variable of the same name in a subclass, that's called hiding. The resulting subclass will now actually have both properties. You can access the one from the superclass with super.var or ((SuperClass)this).var. The variables don't even have to be of the same type; they are just two variables sharing a name, much like two overloaded methods.

Answer 2

There is no polymorphism for fields in Java.

Variables decision happens at a compile time so always Base Class variables (not child’s inherited variables) will be accessed.

So whenever upcasting happens always remember

1) Base Class variables will be accessed.

2) Sub Class methods(overridden methods if overriding happened else inherited methods as it is from parent) will be called.

Answer 3

OverRiding Concept in Java Functions will override depends on object type and variables will accessed on reference type.

1. Override Function: In this case suppose a parent and child class both have same name of function with own definition. But which function will execute it depends on object type not on reference type on run time.

For e.g.:

Parent parent=new Child();
parent.behaviour();

Here parent is a reference of Parent class but holds an object of Child Class so that's why Child class function will be called in that case.

Child child=new Child();
child.behaviour();

Here child holds an object of Child Class, so the Child class function will be called.

Parent parent=new Parent();
parent.behaviour();

Here parent holds the object of Parent Class, so the Parent class function will be called.

2. Override Variable: Java supports overloaded variables. But actually these are two different variables with same name, one in the parent class and one in the child class. And both variables can be either of the same datatype or different.

When you trying to access the variable, it depends on the reference type object, not the object type.

For e.g.:

Parent parent=new Child();
System.out.println(parent.state);

The reference type is Parent so the Parent class variable is accessed, not the Child class variable.

Child child=new Child();
System.out.println(child.state);

Here the reference type is Child, so the Child class variable is accessed not the Parent class variable.

Parent parent=new Parent();
System.out.println(parent.state);

Here the reference type is Parent, so Parent class variable is accessed.

Answer 4

Java has a feather of encapsulation means it tightly binds the property and the behavior of an object. so only via a class reference we can call it's behavior to change it's property.

and in inheritance only method overrides so that it can affects only it's property.

Answer 5

This is called variable hiding. When you assign aRef = b; , aRef has two intVal, 1 is named just intVal another is hidden under A.intVal (see debugger screenshot), Because your variable is of type class A , even when you print just intVal java intelligently picks up A.intVal.

Answer 1: One way of accessing child class's intVal is System.out.println((B)aRef.intVal);

Answer 2: Another way of doing it is Java Reflection because when you use reflection java cant intelligently pickup hidden A.intVal based on Class type, it has to pick up the variable name given as string -

import java.lang.reflect.Field;

class A{
    public int intVal = 1;
    public void identifyClass()
    {
        System.out.println("I am class A");
    }
}

class B extends A
{
    public int intVal = 2;
    public void identifyClass()
    {
        System.out.println("I am class B");
    }
}

public class Main
{
    public static void main(String [] args) throws Exception
    {
        A a = new A();
        B b = new B();
        A aRef;
        aRef = a;
        System.out.println(aRef.intVal);
        aRef.identifyClass();
        aRef = b;
        Field xField = aRef.getClass().getField("intVal");
        System.out.println(xField.get(aRef));
        aRef.identifyClass();
    }
}

Output -

1
I am class A
2
I am class B

Answer 6

I hope this can help:

public class B extends A {
//  public int intVal = 2;

    public B() {
        super();
        super.intVal = 2;
    }

    public void identifyClass() {
        System.out.println("I am class B");
    }
}

So overriding variable of base class is not possible, but base class variable value can be set (changed) from constructor of inherited class.