它违反了封装。你不应该能够绕过父类的行为。有时能够绕过自己类的行为(特别是在同一个方法中)，但不能绕过父类的行为是有意义的。例如，假设我们有一个基类“项目的集合”，一个子类表示“红色项目的集合”，该子类的一个子类表示“大红色项目的集合”。这是有道理的:

public class Items
{
    public void add(Item item) { ... }
}

public class RedItems extends Items
{
    @Override
    public void add(Item item)
    {
        if (!item.isRed())
        {
            throw new NotRedItemException();
        }
        super.add(item);
    }
}

public class BigRedItems extends RedItems
{
    @Override
    public void add(Item item)
    {
        if (!item.isBig())
        {
            throw new NotBigItemException();
        }
        super.add(item);
    }
}

这很好- RedItems总是可以确信它包含的项目都是红色的。现在假设我们能够调用super.super.add():

public class NaughtyItems extends RedItems
{
    @Override
    public void add(Item item)
    {
        // I don't care if it's red or not. Take that, RedItems!
        super.super.add(item);
    }
}

现在我们可以添加任何我们喜欢的东西，而RedItems中的不变量被打破了。

明白吗?

我没有足够的声誉来评论，所以我将把这个添加到其他答案中。

乔恩·斯基特用一个漂亮的例子回答得很好。Matt B有一个观点:不是所有的超类都有超类。如果你调用一个没有super的super，你的代码就会崩溃。

面向对象编程(Java就是面向对象编程)是关于对象的，而不是函数。如果你想要面向任务的编程，选择c++或其他语言。如果你的对象不适合它的父类，那么你需要将它添加到“祖父类”，创建一个新类，或者找到另一个它适合的父类。

就我个人而言，我发现这种限制是Java最大的优势之一。与我使用过的其他语言相比，代码有点僵硬，但我总是知道会发生什么。这有助于实现Java“简单而熟悉”的目标。在我的脑海里，打电话给上级。超级不简单也不熟悉。也许开发者也有同感?

这样做有一些很好的理由。你可能有一个子类，它的方法实现不正确，但是父方法实现正确。因为它属于第三方库，所以您可能无法/不愿意更改源代码。在本例中，您希望创建一个子类，但重写一个方法来调用super。超级的方法。

正如其他一些海报所示，通过反射是可以做到这一点的，但应该可以这样做

(本)SuperSuperClass .theMethod ();

我现在正在处理这个问题-快速修复是复制并粘贴超类方法到subsubclass方法:)

关键字super只是在超类中调用方法的一种方法。 在Java教程中:https://docs.oracle.com/javase/tutorial/java/IandI/super.html

如果您的方法覆盖了它的父类的方法之一，您可以通过使用关键字super调用被覆盖的方法。

不要相信这是一个超对象的引用!!不，它只是在超类中调用方法的关键字。

这里有一个例子:

class Animal {
    public void doSth() {
        System.out.println(this);   // It's a Cat! Not an animal!
        System.out.println("Animal do sth.");
    }
}

class Cat extends Animal {
    public void doSth() {
        System.out.println(this);
        System.out.println("Cat do sth.");
        super.doSth();
    }
}

当你调用cat.doSth()时，类Animal中的方法doSth()将打印这个，它是一只猫。

我认为如果你重写了一个方法，并想要它的所有超类版本(比如，说for equals)，那么你实际上总是想先调用直接的超类版本，如果它愿意，后者会依次调用它的超类版本。

我认为这没什么意义(如果有意义的话)。我想不出有什么情况)来调用某个方法的任意超类版本。我不知道这在Java中是否可行。它可以在c++中完成:

this->ReallyTheBase::foo();

我认为乔恩·斯基特有正确答案。我只是想补充一点，你可以通过强制转换从超类的超类中访问阴影变量:

interface I { int x = 0; }
class T1 implements I { int x = 1; }
class T2 extends T1 { int x = 2; }
class T3 extends T2 {
        int x = 3;
        void test() {
                System.out.println("x=\t\t"          + x);
                System.out.println("super.x=\t\t"    + super.x);
                System.out.println("((T2)this).x=\t" + ((T2)this).x);
                System.out.println("((T1)this).x=\t" + ((T1)this).x);
                System.out.println("((I)this).x=\t"  + ((I)this).x);
        }
}

class Test {
        public static void main(String[] args) {
                new T3().test();
        }
}

它产生输出:

x=              3
super.x=        2
((T2)this).x=   2
((T1)this).x=   1
((I)this).x=    0

(例子来自JLS)

但是，这对方法调用不起作用，因为方法调用是基于对象的运行时类型确定的。