Can Java Subclasses Truly Override Instance Variables, or is Something Else at Play?

Variable Overriding in Java: A Deeper Exploration

Overriding member functions in Java is a well-known concept. However, experimenting with overriding member variables raises questions. Consider the following code:

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

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

public class MainClass {
    public static void main(String [] args) {
        A a = new A();
        B b = new B();
        A aRef;
        aRef = a;
        System.out.println(aRef.intVal);
        aRef.identifyClass();
        aRef = b;
        System.out.println(aRef.intVal);
        aRef.identifyClass();
    }
}

The puzzling behavior lies in the output:

1
I am class A
1
I am class B

Why is intVal still 1 when aRef points to b?

Unveiling Variable Hiding

Contrary to function overriding, variable overriding is not possible. Instead, Java employs a concept known as "variable hiding." When a variable with the same name is declared in a subclass, it masks the variable in the superclass within the scope of the subclass.

In the example, class B declares intVal = 2. While this overlaps with the variable in class A, it doesn't override it. Both variables coexist in the object of type B.

Accessing the Superclass Variable

To access the variable from the superclass, there are two options:

• super.var: This explicitly references the variable from the superclass.
• ((SuperClass)this).var: This downcasts this to the superclass type and then accesses the variable.

For instance, aRef.super.intVal would retrieve 2, the intVal of class B.

Variable Hiding in Practice

Variable hiding can be useful in certain scenarios. For example, you could define a base class with common properties that all subclasses inherit and selectively override certain properties as needed. However, it's important to use this technique judiciously to avoid confusion and potential errors.

The above is the detailed content of Can Java Subclasses Truly Override Instance Variables, or is Something Else at Play?. For more information, please follow other related articles on the PHP Chinese website!