how overriding works in the following code?

Question

consider the following code in java:

public class Superclass {    
    public void printMethod() {
        System.out.println("Printed in Superclass.");
    }
}

Here is a subclass, called Subclass, that overrides printMethod():

public class Subclass extends Superclass {    
    // overrides printMethod in Superclass
    public void printMethod() {
        super.printMethod();
        System.out.println("Printed in Subclass");
    }
    public static void main(String[] args) {
        Subclass s = new Subclass();
        s.printMethod();    
    }
}

The output obtained is the following:

Printed in Superclass
Printed in Subclass

If the subclass is overriding why is superclass println still displaying on screen? It is not suppose only to display the content of the method on the subclass?

Why is super not being invoked in the following code if the method is overriding?

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    // Inflate the menu; this adds items to the action bar if it is present.
    getMenuInflater().inflate(R.menu.main, menu);
    return true;
}

What do you think `super.printMethod();` does? – Sotirios Delimanolis Jan 08 '14 at 21:15 — Sotirios Delimanolis, Jan 08 '14 at 21:15

score 2 · Answer 1 · answered Jan 08 '14 at 21:15

2

1 Because of the first line in the method super.printMethod();

2 Because there is no call to a super method.

answered Jan 08 '14 at 21:15

Elliott Frisch

198,278
20
158
249

William Morrison · Answer 2 · 2014-01-08T21:22:45.277

if the subclass is overriding why is superclass println still displaying on screen?

Because you called super.printMethod(). That calls the parent class implementation of printMethod().
why is super not being invoked in the following code if the method is overriding?

Because the developer didn't need, or didn't want the code in the parent class to execute- he wanted to rewrite the method entirely. You might also see the override keyword used when the parent implementation isn't defined, such as with an interface or an abstract class.

Calling the parent class implementation of a method isn't required.

score 1 · Accepted Answer · edited May 23 '17 at 12:13

if the subclass is overriding why is superclass println still displaying on screen? it is not suppose only to display the content of the method on the subclass?

This line:

super.printMethod();

Will call the super class's printMethod(). This will essentially become:

new Superclass().printmethod();

You don't need to call super to do an override. Do this instead:

// overrides printMethod in Superclass
public void printMethod() {
    //super.printMethod();
    System.out.println("Printed in Subclass");
}

Another way to approach your question is to do the following:

public class Superclass {    
    public void printMethod() {
        System.out.println("Printed in " + this.getClass().getName() + ".");
    }
}

Then just do:

public class Subclass extends Superclass {    
    // overrides printMethod in Superclass
    public void printMethod() {
        super.printMethod();//just do override
    }
    public static void main(String[] args) {
        Subclass s = new Subclass();
        s.printMethod();    
    }
}

another question, why is super not being invoked in the following code if the method is overriding?

You don't need super to do @Override as mentioned above. From this question:

Use it every time you override a method for two benefits. Do it so that you can take advantage of the compiler checking to make sure you actually are overriding a method when you think you are. This way, if you make a common mistake of misspelling a method name or not correctly matching the parameters, you will be warned that you method does not actually override as you think it does. Secondly, it makes your code easier to understand because it is more obvious when methods are overwritten.

Additionally, in Java 1.6 you can use it to mark when a method implements an interface for the same benefits. I think it would be better to have a separate annotation (like @Implements), but it's better than nothing.

If you want to know more about when to use super with method overrides, then check this article question.

if I understand correct, if you remove the super then you are not invoking the super's printMethod(); right? so why is override useful in this case? I could just create 2 classes that do not extend anything and they both have a print statement. — user3170491, Jan 08 '14 at 21:25
Overriding methods is useful based on what your design is. I've updated the answer as to why you use `@Override`. — But I'm Not A Wrapper Class, Jan 08 '14 at 21:27
@user3170491 you don't understand OOP yet, do you? The answer is polymorphism. For simple programs, of course you could. But at the higher level, it is beneficial to organize code to fit interfaces, so that it can be multifunctional and modular. — SpacePrez, Jan 08 '14 at 21:38

score 0 · Answer 4 · answered Jan 08 '14 at 21:15

You don't have to call the superclass method with super.printMethod(); to override the method, but you did, so

Printed in Superclass

is printed. To not have it print, remove the call to super.printMethod();; it's not necessary.

For onCreateOptionsMenu, it's not using the overridden functionality, so there's no need to call super.onCreateOptionsMenu.

score 0 · Answer 5 · answered Jan 08 '14 at 21:15

0

When you invoke super(), you call the superclass method. The override would still work without "Printed in Superclass" printed if you simply deleted the super() invocation.

answered Jan 08 '14 at 21:15

La-comadreja

5,627
11
36
64

how overriding works in the following code?

5 Answers5