Java继承-调用超类方法

让我们假设我有以下两个类

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（）

简单地使用

super.alphaMethod1（）

请参见，您可以执行以下操作：

super.alphaMethod1();

请注意，
super
是对父类的引用，但super（）是它的构造函数。
可以使用super从母类调用方法，但这意味着您可能有设计问题。
也许
B.alphaMethod1（）
不应该重写A的方法并被称为
B.betaMethod1（）

如果这取决于具体情况，您可以放置一些代码逻辑，如：

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

这样，它只在需要时调用A的方法，并且对类用户不可见。
无论何时创建子类对象，该对象都具有父类的所有特性。
这里Super（）是为家长准备的设备

如果您当时编写super（），则会调用父级的默认构造函数。
同样，如果你写超级。
此关键字引用的当前对象与访问父对象的超级关键字facilty相同。
您不能使用beta的对象调用alpha的alphaMethod1（），但您有两种解决方案：

解决方案1:从beta的
alphaMethod1（）调用alpha的
alphaMethod1（）

或任何其他测试方法，如：

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（）

答案在这个答案的末尾，但在阅读它之前，你还应该阅读它前面的内容


您试图做的是，允许跳过覆盖方法中添加的可能验证机制，从而破坏安全性。
现在让我们想象一下，我们可以通过如下语法从超类调用方法的版本

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
应仅存储红色项目

无论我们使用以下哪种

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

召唤

box.put(new BlueItem());

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

但是如果我们可以使用类似于
box.super.put（new BlueItem（））
的语法，会发生什么呢

在这里（假设它是合法的），我们将从
ItemBox
类执行
put
方法的版本。

但该版本没有负责验证商品颜色的步骤。这意味着我们可以将任何
项
放入
重拨项框

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


在这种情况下，执行“原始”方法的代码是有意义的。
而该位置是覆盖方法内部的

请注意，ItemBox和RedItemBox的
put
方法中的注释
/（1）
和
/（2）
非常相似。实际上，它们代表着相同的行为

所以，在重写方法中重用来自“原始”方法的代码是有意义的。
这可以通过
super.methodName（arguments）
调用实现（比如从RedItemBox的
put
内部）：

@覆盖
公共作废放置（项目）{//仅存储红色项目
if（item.getColor（）==Color.RED）{
super.put（item）；//beta obj=new beta（）；
由于您已经创建了beta对象，所以不能直接引用alpha对象的alphamethod1。
它可以修改为

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

尝试不带参数的super。
super.alphaMethod1（）
事实上。你为什么不试试看会发生什么；）？另外，这个问题可能已经被问了几百次了……我知道这个问题现在已经很老了，但是如果你知道有重复的问题，那么就把这个问题标记为重复的。这是谷歌上的最高结果，回答得很好！有人在结尾或结尾处调用超级方法ome一开始为什么？在构造函数中，需要调用super（）作为第一条语句（如果显式调用它）.在常规方法中，您可以根据应用程序逻辑需要在任何地方调用它。例如，在开始时，如果您想在调用后添加额外的步骤，或者在结束时，如果您添加额外的检查。@MichałŠrajer使用
super
您不能将方法从类
alpha
调用到扩展类
beta>的
Test
类中
作为一名Java初学者，我只是想知道为什么
super（）
没有神奇的魔力来知道它在哪个方法中使用（意思是：如果
foo（）
调用
super（）
，显然
super（）
意味着
super.foo（）
。构造函数在Java IMHO中太特殊了）请参阅Eiffel中的
preducer
，在那里它做得很好。其他信息：
super.alphaMethod1（）；
不能从
main
方法调用。此答案没有说明它，但此调用需要从子类的非静态上下文中的某个地方进行：
beta
。
box.put(new BlueItem());

@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)
    }
}

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