Using super.method() when you're not overriding the method?

Question

Is it common practice to always use super for calling methods out of the superclass, even when I'm NOT overriding the method?

Assume

public class Parent{
    public void method() {

    }
}

So

public class Child extends Parent {
    public void someMethod() {
        super.method();
    }
}

or

public class Child extends Parent {
    public void someMethod() {
        method();
    }
}   

Thanks for your input.

Answer 1

Calling super tells the JVM to explicitly look to the parent class' version of a method. Continuing with your example, if you just call

method()

The JVM will first search in the calling class for the method (in this case Child) before looking at the parent class. On the other hand, if you call

super.method()

then the JVM will explicitly look at the parent class for an implementation, even if Child has an method called method().

Putting these two ideas together, you should probably always use super when you intend to call the parent class' method. If your class does not override the method, then you could call without super. But even this becomes problematical if someone were to refactor your class later on and override the method.

Answer 2

The leading question is easy to answer:

Is it common practice to always use super for calling methods out of the superclass, even when I'm NOT overriding the method?

No, its not common practice. On the contrary, its dangerously confusing to do so. You call methods normally, because the main point of inheritance is to allow the classes to override methods to change/extend their behavior. You normally don't care about at which level a method is actually implemented.

The obvious exception is when you do override the method yourself and you want/need the parents functionality.

Now to the dangerously confusing part of explicitly calling super:

public class CallSuper {

    static class Parent {
        public void foo() {
            System.out.println("Parent.foo");
        }

        /** 
         * Calls foo to do the main work
         */
        public void bar() {
            System.out.print
            foo();
        }
    }

    static class Child extends Parent {
        public void foo() {
            System.out.println("Child.foo");
        }

        public void bar() {
            super.foo();
        }
    }

    static class GrandChild extends Child {
        public void foo() {
            System.out.println("GrandChild.foo");
        }
    }

    public static void main(String[] args) {
        Parent p = new Parent();
        Parent c = new Child();
        Parent g = new GrandChild();

        System.out.print("Parent.foo() = ");
        p.foo();
        System.out.print("Child.foo() = ");
        c.foo();
        System.out.print("GrandChild.foo() = ");
        g.foo();

        System.out.print("Parent.bar() = ");
        p.bar();
        System.out.print("Child.bar() = ");
        c.bar();
        System.out.print("GrandChild.bar() = ");
        g.bar();
    }
}

If you run this example it will output (added line numbers for clarity):

1 Parent.foo() = Parent.foo
2 Child.foo() = Child.foo
3 GrandChild.foo() = GrandChild.foo
4 Parent.bar() = Parent.foo
5 Child.bar() = Parent.foo
6 GrandChild.bar() = Parent.foo

The first four lines are not surprising, we get what foo implements at each level, respectively Parents's bar calling its foo. It starts to get odd at line 5. Child bypasses its own override of foo by calling super.bar(), so while its foo() is specialized, bar() is not. In Line 6, you see that GrandChild inherits this oddity from Child, so the somewhat innocent looking super.foo() in Child's bar has now broken GrandChild's expectations that its override of foo() is effective for all bar() as well.

Now if you imagine foo() and bar() actually doing something useful and that they have a meaningful relationship with each other, e.g. you are led to believe (either by Parent's documentation or just common sense) that overriding foo() will change the behavior of bar(), too. Child's "super" is breaking that.

As a rule of thumb, if you see a "super.x()" call anywhere outside of an actual override of "x()", its probably an accident lurking to happen.

Answer 3

Is it common practice to always use super for calling methods out of the superclass? Or is it redundant code?

It's not redundant. It have a special purpose of invoking parent class method (though you ovveriden). When you don't want, don't invoke. If you current class is not child of that class, super won't work for you.

Also if you call an overridden supermethod, does it use the supermethod or the lowest method?(in the inheritance tree)

The overridden method. Since you overridden it in your class.