Inheritance and overloading in Java

Question

I'm studying for an exam and I need some help to understand what is going on in the following snipped of code.

class A {
    public void method1(A X) {
        System.out.println("A");
    }
}
class B extends A {
    public void method2() {
        System.out.println("B");
    }
}
class C extends B {
    public void method1(A x) {
        System.out.println("C");
    }
}
class D extends C {
    public void method1(D x) {
        System.out.println("D");
    }
}
public class test {
    public static void main(String[] args) {
        C c = new D();
        B b = c;
        c.method1(c);  // prints C
        b.method1(b);  // prints C
    }
}

Ok this is what I think: c.method1(c) invokes method1 in C and not method1 in D because c is decleard as a C therefore method1 in D is not visible. But b.method1(b) is more difficult. B does not have method1 and I assumed that method1 in the superclass will be used, but it is not. Why is it using the method in C? I put a new D in b but nothing of the specialization of D is visable, because b is from the type B.

Answer 1

In summary, here's the visibility of each method at each inheritance level:

class D:

public void method1(D x) { System.out.println("D"); }
public void method1(A x) { System.out.println("C"); }
public void method2()    { System.out.println("B"); }

class C:

public void method1(A x) { System.out.println("C"); }
public void method2()    { System.out.println("B"); }

class B:

public void method1(A x) { System.out.println("A"); }
public void method2()    { System.out.println("B"); }

class A:

public void method1(A x) { System.out.println("A"); }

It's also important to point out that both variables 'c' and 'b' in your example, are the same object, and is a instance of D.

So... If you call c.method1(c);, it prints "C" because D is an instance of A (it's actually a D, but it's also an A by inheritence), so you can call method1(A), which for D, prints "C". (that's a mouth full). Why doesn't it print "D" you'll ask? Because the variable is declared as a C, which the compiler can only link to method1(A).

If you call b.method1(b);, it prints "C" because your variable b is actually an instance of a D, since you created it as new D(). Actually c and b point to the same object of type D.

When a method is called, the JVM looks at the actual type of the object D in this case, and not what it's declared as B.

A good way to remember is when you have something like

B b = new D()

The left part of the equation is mostly used by the compiler. Remember, method1(A) and method1(D) are two different methods (because not the same exact signature, different argument types).

The right part of the equation is used by the JVM at runtime. It defines the actual type, at runtime, of that variable b.

Answer 2

The type of the variable referencing the instance is irrelevant to the method invoked.

The type of the object defines which method is invoked; subclasses overriding methods to vary the behaviour of the instance, while still maintaining their assignability to a variable of type of a super class. That is the essence of OO - see Liskov substitution principle.

However, when it comes to overloading methods, the type of varialbe holding the parameter controls which method is invoked - the type of the instance to which it refers is irrelevant.

Answer 3

Lets take your example code and comment which method is called, why it is called and why not everything here is inheriting.

class A {
    public void method1(A X) {
        System.out.println("A");      <--|
    }                                    |
}                                        |
class B extends A {                      |
    public void method2() {              | This is the only overriding happening
        System.out.println("B");         | because they share the signature method1(A)
    }                                    | The other signatures are method1() from class B
}                                        | and method1(D) from class D
class C extends B {                      |
    public void method1(A x) {           |
        System.out.println("C");         |
    }                             -------
}
class D extends C {
    public void method1(D x) {
        System.out.println("D");
    }
}
public class test {
    public static void main(String[] args) {
        C c = new D();
        B b = c;
        c.method1(c);  // prints C
        b.method1(b);  // prints C
    }
}   

Since you are calling the method1 from the Object defined as C you are getting the result C. The only method´s that are known to this class, despite the methods of the Object class, are method1(A) and method1(). Due to your Class beeing defined as C it will correctly call the method from the class C, since the method1 function from class D doesn´t overrite the one from class C.

Edit to answer your comment:

you are invoking the method with the signature method1(A) at this point. Since your Object actually reprent´s the class D it will notice that the method method1(A) is overwritten by the previously inherited class C and therefore will print C. In basic words, the defintion of the class defines which methods you are allowed to call (in the scope of visibility of the object) but the actually type of the object that it is referencing defines how the method is called (if it´s overriten at some point).

Answer 4

If I got it right, your question is, why you got printed "C", not "A" for b.method1(b), as you expected. The answer is simple, you are dealing here with a combination of dynamic dispatch (dynamic binding) and static dispatch (static binding). The first is done, based on runtime types, the second one on on compile-time types.

Note, BTW, that in D you have two methods, with different signatures (remember, to override, you need exact match of signatures, so in this case it is rather overloading == compile-time polymorphism):

public void method1(D x)
public void method1(A x)

So, what happens here, when you execute b.method1(b).

You need first to determine the method signature to call and then find the matching method. The first is based on compile-time types. The argument you pass, is of type B (implicit upcast), so it selects method1(A x) (method1(D x) has a signature that does not fit) and will search for method1(A x) upwards the inheritance tree to find the match. The first match is in C. For more information look here: JLS, esp. the explanation:

When a method is invoked (§15.12), the number of actual arguments (and any explicit type arguments) and the compile-time types of the arguments are used, at compile time, to determine the signature of the method that will be invoked (§15.12.2)

Answer 5

Your method overriding was broken.

Well the method in Class C is equivalent to method in Class D are different. You are not ovverdien in correctly. The signature is different.

You can test it by writing @Override on top of your method.

    @Override
    public void method1(D x) {
        System.out.println("D");
    }

The above code won't compile and give you an error since you changed the signature of that method in subclass.

Answer 6

If we see the code only method method1 in class C is being overridden from B which is eventually inherited from class A. As overriding is runtime polymorphism, though you have created a instance of class D but since these two methods are different its invoking class C method1

If you want to invoke that of D you will need to change the parameter of method to A

Answer 7

the principal is easy when you call a method of an object. the system is gonna start the research of the method from the class of instantiation of the object, then he is gonna go up to it's direct mother until he found it. for example : if you instantiate with D class, and let's say that the method1 only exist in the A class. so the system is gonna fellow this steps of research :

D(not found) > C(not found) > B(not found) > A(found) 

so he will use the A class method