Java继承：继承超类成员和变量时的区别

Question

I was going through Java inheritance and I tried the following code

class A {
    public int x = 1;

    public void print1() {
        System.out.println("Print from A");
    }
}

class B extends A {
    public int x = 2;

    public void print1() {
        System.out.println("Print from B");
    }
}

class C extends B {
    public int x = 3;

    public void print1() {
        System.out.println("Print from C");
    }

    public static void main(String aa[]) {
        C c = new C();
        ((A) c).print1();
        System.out.println(c.x);    
        System.out.println(((A) c).x);          
    }
}

The output was

Print from C
3
1

Now, my question is that I am able to access class A member x from class C instance c but why am I not able to access the class A method print1() . I know, if I want I can call new A().print1(); . But, I want to access it from an instance of class C directly. So by overriding methods, are the top parent class methods lost in the bottom child class? However, the parent class members are retained (although hidden). Why so? And is there a way to call a method from class A in class C without creating an instance of A ?

Answer 1

EDIT

What's happening here?

When you say ((A)c).print1(); , JVM knows that actual the instance, on which it needs to call is print1() is of type C hence class C 's print1() version is executed.

But when you type ((A)c).x , you are referring to state, not behavior and that too using reference of type A . Which version of x will be picked up, is decided at compile time as compiler knows what is the type reference (In this case A ). That is why you see A 's state.

This statement from Java doc might also be interesting for you:

Within a class, a field that has the same name as a field in the superclass hides the superclass's field, even if their types are different. Within the subclass, the field in the superclass cannot be referenced by its simple name. Instead, the field must be accessed through super, which is covered in the next section. Generally speaking, we don't recommend hiding fields as it makes code difficult to read.

---

Why is it this way?

Answer to your questions:

Question 1:

my question is that I am able to access class A member x from class C instance c

About variable x , since it is declared as public , no business validation can be applied on that. Moreover, the developer who's declaring it as public , is aware that concept of encapsulation can't be applied now (which is obviously not recommended). So there is no harm in allowing access to parent's state using child instance. Therefore, by using ((A)c).x , you can access x from class A .

Question 2:

However, the parent class members are retained (although hidden). Why so?

It's because Java does not allow you to use super.super.super.. arbitrarily to access any parent's behavior in the inheritance hierarchy. And the reasoning behind it is to preserve encapsulation. You can only access behavior of the immediate parent class using super keyword but not beyond that.

To explain it more, let's say you have implementation of class B like:

class B extends A {
    public int x = 2;

    public void print1() {
        if(x >= 2) {
            System.out.println("Print from B");
        }
    }
}

Now if super.super was allowed, you can easily bypass validation in print1() method of class B and can invoke A 's print1() method from the instance of class C .

Question 3:

However, the parent class members are retained (although hidden). Why so?

As, mentioned earlier, to retain encapsulation.

Question 4:

And is there a way to call a method from class A in class C without creating an instance of A?

So there is no way to access print1() from A using C 's instance.

Answer 2

When you override a function which already implemented in base(parent) class, when you call that function within the child class, automatically the class in the child will call so in your case when you call print1() of a C object:

C c = new C();
c.print1();

you will call the override function. However if in any part of your program you feel that you need to call the top parent class for any case (which cannot be fulfilled by super ) then you should reconsider your design strategy; maybe you shouldn't override the print1() or even you shouldn't put print1() in the base class in the first place

Answer 3

In object oriented programming, only methods have the ability to be overriden. You cannot override a data member. This explains why you get the outputs.

print1() method of A is overriden in C , and c is an object of C . So, it will call the print1() method of C . On the other hand, the variable x is not overriden.

To call the superclass method, you can do:

super.print1();

Answer 4

Here , Same named Instance Variable is used in all the Classes to confuse the compiler, but you should know that Only Member functions can be overridden not member variables.

So, All the three x will be stored separately in memory. but public void print1() will be overridden by its child class. So,

1. ((A)c).print1(); this piece of Code will Call the overridden method defined in class C. doesn't matter in which class you cast the Object of Class C .

But in Second Case ((A)c).x will print the value from Class A .

2. ((A)c).x :- this will reference to the variable x belongs to Class A not to Class C . because variables never overridden in Inheritence.

Answer 5

((A)c).print1(); Actually it is similar to the c.print1(); . It doesn't matter that you typecast it with Class A, it will still call print1() function of the Class C.