我读了这个问题，并认为如果有人可以这样写，这个问题就很容易解决(并不是说没有它就不能解决):
@Override
public String toString() {
return super.super.toString();
}
我不确定它在很多情况下是否有用，但我想知道为什么它没有，以及其他语言中是否存在类似的东西。
你们怎么看?
编辑: 澄清一下:是的，我知道，这在Java中是不可能的，我并不真的怀念它。这不是我期望的工作，并惊讶地得到一个编译器错误。我只是有了个想法，喜欢讨论一下。
当前回答
public class SubSubClass extends SubClass {
@Override
public void print() {
super.superPrint();
}
public static void main(String[] args) {
new SubSubClass().print();
}
}
class SuperClass {
public void print() {
System.out.println("Printed in the GrandDad");
}
}
class SubClass extends SuperClass {
public void superPrint() {
super.print();
}
}
输出:打印在祖父
其他回答
这很容易做到。例如:
B的C子类和a的B子类，这三个都有方法methodName()。
public abstract class A {
public void methodName() {
System.out.println("Class A");
}
}
public class B extends A {
public void methodName() {
super.methodName();
System.out.println("Class B");
}
// Will call the super methodName
public void hackSuper() {
super.methodName();
}
}
public class C extends B {
public static void main(String[] args) {
A a = new C();
a.methodName();
}
@Override
public void methodName() {
/*super.methodName();*/
hackSuper();
System.out.println("Class C");
}
}
运行类C输出如下: A类 C类
而不是输出: A类 B类 C类
我没有足够的声誉来评论，所以我将把这个添加到其他答案中。
乔恩·斯基特用一个漂亮的例子回答得很好。Matt B有一个观点:不是所有的超类都有超类。如果你调用一个没有super的super，你的代码就会崩溃。
面向对象编程(Java就是面向对象编程)是关于对象的，而不是函数。如果你想要面向任务的编程，选择c++或其他语言。如果你的对象不适合它的父类，那么你需要将它添加到“祖父类”，创建一个新类，或者找到另一个它适合的父类。
就我个人而言，我发现这种限制是Java最大的优势之一。与我使用过的其他语言相比，代码有点僵硬，但我总是知道会发生什么。这有助于实现Java“简单而熟悉”的目标。在我的脑海里，打电话给上级。超级不简单也不熟悉。也许开发者也有同感?
我曾经遇到过这样的情况，即体系结构是在一个公共CustomBaseClass中构建公共功能，该CustomBaseClass代表几个派生类实现。 但是，我们需要规避特定派生类的特定方法的通用逻辑。在这种情况下，我们必须使用super.super.methodX实现。
我们通过在CustomBaseClass中引入一个布尔成员来实现这一点，该成员可用于有选择地推迟自定义实现，并在需要时让位于默认框架实现。
...
FrameworkBaseClass (....) extends...
{
methodA(...){...}
methodB(...){...}
...
methodX(...)
...
methodN(...){...}
}
/* CustomBaseClass overrides default framework functionality for benefit of several derived classes.*/
CustomBaseClass(...) extends FrameworkBaseClass
{
private boolean skipMethodX=false;
/* implement accessors isSkipMethodX() and setSkipMethodX(boolean)*/
methodA(...){...}
methodB(...){...}
...
methodN(...){...}
methodX(...){
if (isSkipMethodX()) {
setSKipMethodX(false);
super.methodX(...);
return;
}
... //common method logic
}
}
DerivedClass1(...) extends CustomBaseClass
DerivedClass2(...) extends CustomBaseClass
...
DerivedClassN(...) extends CustomBaseClass...
DerivedClassX(...) extends CustomBaseClass...
{
methodX(...){
super.setSKipMethodX(true);
super.methodX(...);
}
}
然而，在框架和应用程序中遵循良好的架构原则，我们可以通过使用hasA方法而不是isA方法轻松避免这种情况。但在任何时候，期待设计良好的架构都是不现实的，因此需要摆脱坚实的设计原则，引入像这样的技巧。 这只是我的意见……
当你不能改变基类的代码时，调用super.super.method()是有意义的。这通常发生在扩展现有库时。
首先问问自己，为什么要扩展这个类?如果答案是“因为我不能改变它”，那么你可以在你的应用程序中创建确切的包和类，并重写调皮方法或创建委托:
package com.company.application;
public class OneYouWantExtend extends OneThatContainsDesiredMethod {
// one way is to rewrite method() to call super.method() only or
// to doStuff() and then call super.method()
public void method() {
if (isDoStuff()) {
// do stuff
}
super.method();
}
protected abstract boolean isDoStuff();
// second way is to define methodDelegate() that will call hidden super.method()
public void methodDelegate() {
super.method();
}
...
}
public class OneThatContainsDesiredMethod {
public void method() {...}
...
}
例如，您可以创建org.springframework.test.context.junit4。类SpringJUnit4ClassRunner，所以这个类应该在jar中真正的类之前加载。然后重写方法或构造函数。
注意:这是绝对的黑客，强烈不建议使用，但它是工作!使用这种方法是危险的，因为类装入器可能存在问题。此外，这可能会导致问题，每次您将更新库包含覆盖类。
除了其他人提出的非常好的观点之外，我认为还有另一个原因:如果超类没有超类怎么办?
因为每个类都自然地扩展(至少)Object，所以super.whatever()总是引用超类中的一个方法。但是如果你的类只扩展Object呢?超级指的是什么?该如何处理该行为-编译器错误，空指针，等等?
我认为不允许这样做的主要原因是它违反了封装，但这可能也是一个小原因。
