Java 使用；超级"；关键字或在从子类中的方法中本地调用超类方法时使用超类实例？

假设我有：

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();
}

它是双向的，但我想知道哪一个更好用。这些方法中有哪一种是糟糕的编程技术？我希望你能给我答案和论据

  super.methodA();

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

methodA的这两个调用适用于不同的实例，因此它们完全不同

super.methodA（）

对当前实例执行

methodA

superclass.methodA（）

对与当前实例不相关的

superclass

的新实例执行

methodA

您几乎总是使用第一个选项。至于第二个选项，创建一个新实例，在该实例上调用一个方法，然后再也不对该实例执行任何操作是没有意义的

methodA的这两个调用适用于不同的实例，因此它们完全不同

super.methodA（）

对当前实例执行

methodA

superclass.methodA（）

对与当前实例不相关的

superclass

的新实例执行

methodA

您几乎总是使用第一个选项。至于第二个选项，创建一个新实例，在该实例上调用一个方法，然后再也不对该实例执行任何操作是没有意义的

methodA的这两个调用适用于不同的实例，因此它们完全不同

super.methodA（）

对当前实例执行

methodA

superclass.methodA（）

对与当前实例不相关的

superclass

的新实例执行

methodA

您几乎总是使用第一个选项。至于第二个选项，创建一个新实例，在该实例上调用一个方法，然后再也不对该实例执行任何操作是没有意义的

methodA的这两个调用适用于不同的实例，因此它们完全不同

super.methodA（）

对当前实例执行

methodA

superclass.methodA（）

对与当前实例不相关的

superclass

的新实例执行

methodA

您几乎总是使用第一个选项。至于第二个选项，创建一个新实例，在该实例上调用一个方法，然后再也不对该实例执行任何操作是没有意义的

它是双向的，但我想知道哪一个更好用

这完全取决于你想要达到的目标。如果您想创建一个新的、完全独立的实例，请这样做。但更常见的是，您希望在被重写的方法当前正在执行的同一实例上使用正在重写的方法的超类实现，在这种情况下，您将使用

super.methodA（）

根据我的经验，

super

最常用于重写方法以执行某些特定于子类的工作，调用超类实现，然后执行一些特定于超类的工作。例如：

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

换句话说，即使您重写了该方法，您仍然需要“正常”行为——您只需要运行一些额外的代码。或者，有时您希望有条件地运行超类代码，例如，仅当输入满足某个标准时

它是双向的，但我想知道哪一个更好用

这完全取决于你想要达到的目标。如果您想创建一个新的、完全独立的实例，请这样做。但更常见的是，您希望在被重写的方法当前正在执行的同一实例上使用正在重写的方法的超类实现，在这种情况下，您将使用

super.methodA（）

根据我的经验，

super

最常用于重写方法以执行某些特定于子类的工作，调用超类实现，然后执行一些特定于超类的工作。例如：

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

换句话说，即使您重写了该方法，您仍然需要“正常”行为——您只需要运行一些额外的代码。或者，有时您希望有条件地运行超类代码，例如，仅当输入满足某个标准时

它是双向的，但我想知道哪一个更好用

这完全取决于你想要达到的目标。如果您想创建一个新的、完全独立的实例，请这样做。但更常见的是，您希望在被重写的方法当前正在执行的同一实例上使用正在重写的方法的超类实现，在这种情况下，您将使用

super.methodA（）

根据我的经验，

super

最常用于重写方法以执行某些特定于子类的工作，调用超类实现，然后执行一些特定于超类的工作。例如：

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

换句话说，即使您重写了该方法，您仍然需要“正常”行为——您只需要运行一些额外的代码。或者，有时您希望有条件地运行超类代码，例如，仅当输入满足某个标准时

它是双向的，但我想知道哪一个更好用

这完全取决于你想要达到的目标。如果您想创建一个新的、完全独立的实例，请这样做。但更常见的是，您希望在被重写的方法当前正在执行的同一实例上使用正在重写的方法的超类实现，在这种情况下，您将使用

super.methodA（）

根据我的经验，

super

最常用于重写方法以执行某些特定于子类的工作，调用超类实现，然后执行一些特定于超类的工作。例如：

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

换句话说，即使您正在重写该方法