Why does inheritance behave differently in Java and C++ with superclasses calling (or not) subclasses' methods?

Question

I have written - what seemed to be - exactly the same example of inheritance both in Java and C++. I am really amazed to see the different outputs of these programs. Let me share both code snippets and the corresponding outputs.

---

C++ Code:

class A
{
public:
    A() {}
    void sleep() {
        cout << "A.Sleep" << endl;
        eat();
    }
    void eat() {cout << "A.Eat" << endl;}
};

class B: public A
{
public:
    B() {}
    void sleep() {
        A::sleep();
        cout << "B.Sleep " <<endl;
        this->eat();
    }
    void eat() {
        cout << "B.Eat" << endl;
        run();
    }
    void run() {
        A::sleep();
        cout << "B.run" << endl;
    }
};

int main()
{
    B *b = new B();
    b->sleep();
}

---

Output:

A.Sleep
A.Eat
B.Sleep
B.Eat
A.Sleep
A.Eat
B.run

executed successfully...

---

Java Code:

class A
{
    A() {}
    void sleep() {
        System.out.println("A.Sleep");
        this.eat();
    }
    void eat() { System.out.println("A.Eat");}
};

class B extends A
{
    B() {}
    @Override
    void sleep() {
        super.sleep();
        System.out.println("B.Sleep");
        this.eat();
    }
    @Override
    void eat() {
        System.out.println("B.Eat");
        run();
    }
    void run() {
        super.sleep();
        System.out.println("B.Run");
    }
}

public class Test {
    public static void main(String[] args) {
        B b = new B();
        b.sleep();
    }
}

---

Output:

A.Sleep
B.Eat
A.Sleep
B.Eat
A.Sleep
......
......
......
(Exception in thread "main" java.lang.StackOverflowError)

---

I don't know why these two examples of inheritance behave differently. Shouldn't it work similarly?

What is the explanation for this scenario?

Answer 1

In your C++ example you are hiding the base methods, but you don't override them. So they are actually different methods which just happen to have the same name. If you are calling

A* a = new B();
a->sleep();

it will actually print "A.Sleep". If you want to override a method, you need to declare it virtual in the Base class (automatically making it virtual in all sub classes too). You can read more about function hiding vs overriding in C++ in this post.

In your Java example you actually override the methods, so they are the same method. One taking the place of the old. You can think of it this way: all Java functions are secretly marked as virtual, meaning they can be overridden. If you want a method to not be overridable in Java, you must declare it final.

Answer 2

Note: be careful, every language as its own way of thinking. There is a lot of ways to interpret/implement OO. Even if C++ and Java looks similar, they are far from similar.

In both languages, the compiler verifies at compile-time if you can call a method, by examining the class (and the one inherited from the current one, etc) for a method of the right signature and visibility. What makes things different is the way the call is really emitted.

C++:

In the case of non-virtual methods the method called is fully determined at compile-time. This is why even if the object is of class B, when it is executing A::sleep the call to eat is resolved as a call to A::eat (eat is not virtual then compiler calls A::eat because you are in level A). In B::sleep() the call to this->eat() is resolved as a call to B.eat() because at that place this is of type B. You can't go down to the inheritance hierarchy (call to eat in class A will never call an eat method in a class below).

Be aware that things are different in the case of virtual methods (it is more similar to the Java case while being different).

Java:

In Java, the method called is determined at run-time, and is the one that is the most related to the object instance. So when in A.sleep the call to eat will be a call related to the type of the current object, that means of the type B (because the current object is of type B) then B.eat will be called.

You then have a stack overflow because, as you are playing with an object of type B a call to B.sleep() will call A.sleep(), which will call B.eat(), which in turn will call B.run() which will call A.sleep(), etc in a never ending loop.