Java继承-调用超类方法

Question

假设我有以下两个类

public class alpha {

    public alpha(){
        //some logic
    }

    public void alphaMethod1(){
        //some logic
    }
}

public class beta extends alpha {

    public beta(){
        //some logic
    }

    public void alphaMethod1(){
        //some logic
    }
}

public class Test extends beta
{
     public static void main(String[] args)
      {
        beta obj = new beta();
        obj.alphaMethod1();// Here I want to call the method from class alpha.
       }
}

如果我启动一个 beta 类型的新对象，我如何执行在 alpha 而不是 beta 类中找到的 alphamethod1 逻辑？我可以使用super().alphaMethod1()

Eclipse IDE 中的 Autotype 让我可以从 alpha 类或 beta 类中选择 alphamethod1。

Answer 1

你可以这样做：

super.alphaMethod1();

注意，super 是对父类的引用，而super() 是它的构造函数。

Answer 2

只需使用super.alphaMethod1();

见super keyword in java

Answer 3

你不能使用 beta 的对象调用 alpha 的 alphaMethod1() 但是你有两个解决方案：

解决方案 1： 从 beta 的 alphaMethod1() 调用 alpha 的 alphaMethod1()

class Beta extends Alpha
{
  public void alphaMethod1()
  {
    super.alphaMethod1();
  }
}

或来自任何其他 Beta 方法，例如：

class Beta extends Alpha
{
  public void foo()
  {
     super.alphaMethod1();
  }
}

class Test extends Beta 
{
   public static void main(String[] args)
   {
      Beta beta = new Beta();
      beta.foo();
   }
}

方案2：创建alpha的对象并调用alpha的alphaMethod1()

class Test extends Beta
{
   public static void main(String[] args)
   {
      Alpha alpha = new Alpha();
      alpha.alphaMethod1();
   }
}

Answer 4

可以使用 super 从母类调用方法，但这意味着你可能有设计问题。 也许B.alphaMethod1() 不应该覆盖A 的方法并被称为B.betaMethod1()。

如果视情况而定，你可以放一些代码逻辑，如：

public void alphaMethod1(){
    if (something) {
        super.alphaMethod1();
        return;
    }
    // Rest of the code for other situations
}

这样它只会在需要时调用 A 的方法，并且对类用户保持不可见。

Answer 5

每当您创建子类对象时，该对象就具有父类的所有功能。 这里 Super() 是加入父母的设施。

如果你在那个时候写了 super() ，就会调用父母的默认构造函数。 如果你写超级，也一样。

this关键字引用当前对象，与访问父母的超级关键字工具相同。

Answer 6

解决方案在此答案的末尾，但在阅读之前您还应该阅读它之前的内容。

---

您正在尝试做的事情会通过允许跳过覆盖方法中添加的可能验证机制来破坏安全性。

现在让想象一下我们可以通过类似的语法从超类调用方法的版本

referenceVariable.super.methodName(arguments)

如果我们有类似的类

class ItemBox{ //can sore all kind of Items
    public void put(Item item){
        //(1) code responsible for organizing items in box 
    }

    //.. rest of code, like container for Items, etc.
}

class RedItemsBox extends ItemBox {//to store only RED items

    @Override
    public void put(Item item){ //store only RED items
        if (item.getColor()==Color.RED){
            //(2) code responsible for organizing items in box
        }
    }
}

如您所见，RedItemsBox 应该只存储 RED 项目。

无论我们使用以下哪个

ItemBox     box = new RedItemsBox();
RedItemsBox box = new RedItemsBox();

打电话

box.put(new BlueItem());

将从RedItemsBox 调用put 方法（因为多态性）。所以它将正确阻止BlueItem对象被放置在RedItemBox中。

但是如果我们可以使用像 box.super.put(new BlueItem())这样的语法会发生什么？

在这里（假设它是合法的）我们将执行来自ItemBox 类的put 方法的版本。
但是该版本没有负责验证项目颜色的步骤。这意味着我们可以将 any Item 放入 RedItemBox。

这种语法的存在意味着在子类中添加的验证步骤可以随时被忽略，使它们毫无意义。

---

在某些情况下，执行“原始”方法的代码是有意义的。

而那个地方是内部覆盖方法。

请注意，ItemBox 和 RedItemBox 的 put 方法中的 cmets //(1) .. 和 //(2).. 非常相似。实际上它们代表相同的动作...

因此，在覆盖方法中重用“原始”方法的代码是有意义的。 那个可以通过super.methodName(arguments)调用（比如从RedItemBox的put内部）：

@Override
public void put(Item item){ //store only RED items
    if (item.getColor()==Color.RED){
        super.put(item); // <<<--- invoking code of `put` method 
                         //        from ItemBox (supertype)
    }
}

Answer 7

beta obj = 新 beta(); 由于您已经创建了 beta 对象，因此您不能直接引用 alpha 对象的 alphamethod1。 可以修改为

class Beta extends Alpha
{
  public void alphaMethod1()
  {
    super.alphaMethod1();
  }
}