在子类的方法中本地调用超类方法时，使用“ super”关键字还是使用超类实例？

Question

Let say I have:

class Superclass {
  //fields...

  methodA() {...}

  methodB() {...}

...
}

class Subclass extends Superclass {
   //fields...

   methodA() {
      // Here I need to call methods A and B from superclass:
      // For this, I can use supper
      super.methodA();
      super.methodB();

      // Or I have to instantiate the superclass and use the instance
      Superclass superclass = new Superclass();
      superclass.methodA();
      superclass.methodB();
}

It works both ways, but I want to know which is better to use. Any of these ways is a bad programming technique? I hope you give me answer and arguments.

Answer 1

  super.methodA();

  Superclass superclass = new Superclass();
  superclass.methodA();

These two calls of methodA work on different instances, so they are completely different. super.methodA() executes methodA on the current instance. superclass.methodA() executes methodA on a new instance of Superclass which is not related to the current instance.

You would almost always use the first option. As for the second option, It doesn't make sense to create a new instance, call a method on that instance and then never do anything with that instance again.

Answer 2

It works both ways, but I want to know which is better to use.

Well that entirely depends on what you're trying to achieve. If you want to create a new, entirely independent instance, do so. But it's more common that you want to use the superclass implementation of a method you're overriding on the same instance that the overridden method is currently executing on in which case you would use super.methodA() .

In my experience, super is most commonly used when overriding a method to do some subclass-specific work, call the superclass implementation, then do some more superclass-specific work. For example:

@Override public void add(Foo foo) {
    doSomeSubclassSpecificValidation(foo);
    super.add(foo);
    doSomeSubclassSpecificBookKeeping();
}

In other words, even though you're overriding the method, you still want the "normal" behaviour - you just want some extra code to run as well. Or sometimes you want to run the superclass code conditionally, eg only if the input meets a certain criterion.

Answer 3

It's totally different.

super.methodA() will call methodA() in the left circle, while creating a new superclass and calling that methodA() will first create the right circle, and then call methods from it.

Answer 4

With above answers, you must have understood that basically you are calling same method of same class but on two different objects so it all depends as what you are trying to achieve ( On which object you plan to call those methods ). As you know, call to same methods of same class but on different instances are not the same. "super" object is parent of "this" object and that super object was created implicitly when you instantiated Subclass so as per your example code, both are NOT SAME but for simple cases,output might be same. Go one more level up and see if it looks different to you from client code ( try writing calling code of Subclass ).