Java：如何访问两层以下的父类方法？

我有一个类，它扩展了一个需要覆盖的类，但我需要调用该类的父类。既然我不能调用super，因为它将执行直接父类，那么获取父类的父类的最佳方法是什么

我确信这是一个基本的问题，但我已经有一段时间没有做过java了

class A
{
 public void myMethod()
 { /* ... */ }
}

class B extends A
{
 public void myMethod()
 { /* Another code */ }
}

class C extends B
{
 I need to call Class A here
 { /* Another code */ }
}

---

不能，因为它已被B重写。C中没有A的实例

问题是，您想调用类a的方法，但从哪个实例调用？您已经实例化了C，这是一个类，它有两个自己的并从B继承的方法。如果B重写了a的方法，您就不能从C访问它，因为该方法本身属于C（不是B的方法，它已被继承，现在在C中）

可能的解决办法：

B不覆盖

myMethod（）

C接收A的实例并将其保存为类属性

---

A中的

myMethod（）

是静态的，您可以使用

A.myMethod（）

（我不推荐）

除了pakore回答的问题外，如果对您有效，您还可以链接

super.myMethod（）

调用。您将从B中的

myMethod（）

从A调用

myMethod（）

class A {
   public void myMethod() {
     ....
   }
}

class B extends A {
   public void myMethod() {
     ....
     super.myMethod();
     ....
   }
}

class C extends B {
  public void myMethod() {
    ....
    super.myMethod(); //calls B who calls A
    ....
  }
}

---

您最终将从调用myMethod，但会间接。。。如果这对您有效。

您不能直接调用A的方法。在我遇到的少数情况下，解决方案是在中添加一个方法以公开其实现。例如

class A
{
   public myMethod() {
        doAMyMethod();
   }

   void doAMyMethod() {
      // what A want's on doMyMethod, but now it's available
      // as a separately identifiable method
   }
}

class C extends B
{
   public void someStuff() {
      this.doAMyMethod();
   }
}

---

该方案将公共接口（doMyMethod）与实现（doMyMethod）分离。继承确实取决于实现细节，因此这严格来说并不是那么糟糕，但如果可能的话，我会尽量避免它，因为它在a和C中的实现之间创建了紧密耦合。

您所问的是错误的做法，您所说的是C不是B，但是A。你需要做的是让C从A继承。然后你可以调用super

如果不是，这是唯一的方法

public String A()
{
String s = "hello";
return s;
}

public String B()
{
String str = super.A();
return str;
}

public String C()
{
String s = super.B();
return s;
}

---

你没有：它违反了封装

可以说，“不，我不想要我自己的行为——我想要我父母的行为”，因为假设只有当它正确地维持你自己的状态时，你才会这样做

---

然而，你不能绕过你父母的行为——这将阻止它强制执行自己的一致性。如果父类希望允许您直接调用祖父母方法，它可以通过单独的方法公开该方法。。。但这取决于父类。

我在本例中所做的是：

在类C中创建类A的对象，并在那里访问类A。 此示例澄清了更多细节：

class A{
int a;
}
class B extends A{
int a;
}
class C extends B{
int a; 
A obj = new A();
public void setData(int p,int q, int r) {

 this.a = p; //  points to it's own class
 super.a = q;// points to one up level class i.e in this case class B
 obj.a = r; // obj points the class A
}
 public void getData() {
    System.out.println("A class a: "+ obj.a);
    System.out.println("B class a: "+ super.a);
    System.out.println("C class a: "+this.a);
 }
}

public class MultiLevelInheritanceSuper {

 public static void main(String args[]){
    C2 obj = new C2();
    obj.setData(10, 20, 30);
    obj.getData();

 }

}

此示例的输出为：

A class a: 30
B class a: 20
C class a: 10

---

谢谢，我明白了。我想我可能是走错了路。谢谢，我发现我走错了路，必须想出更好的解决办法。我可能不必访问grand parents方法来做我想做的事情。只有当您希望B.myMethod（）与A.myMethod（）做完全相同的事情时，这才有效，这导致了以下问题：为什么第一次要覆盖它@帕科雷：对不起。。。举个简单的例子。根据某些条件、标志等，在需要时调用super.myMethod。我稍微更改了示例以使其更清晰。是的，我想您指的是您现在更新的内容。请记住，您的解决方案与从C调用A.myMethod（）不同，因为B.myMethod（）正在做其他C不希望做的事情。C只是想让A.myMethod（）完成一些事情，而不是那样，还有更多。这就是为什么我说只有当A.myMethod（）==B.myMethod（）时，它才有效，当它有效时，重写就没有意义：）@pakore:我同意你的看法！这就是为什么我添加了“如果对你有效”部分：D。如果OP对这种行为没有问题，那么它就是一个解决方案，否则就不是了。不管怎样，他在这里违反了封装规则。幸运的是，他意识到自己走错了路。谢谢，我知道我做错了，但谢谢你的解释。这有助于我理解。几乎总是使用super是不好的形式。唯一可能的例外是重写方法调用它重写的内容。在这种情况下，最好引入一个抽象或不做任何事情的方法，并用“原始”方法final覆盖它。然而，这意味着你只有一次机会。不管怎么说，深厚的继承权是不好的……可能是重复的。也与