我读了这个问题，并认为如果有人可以这样写，这个问题就很容易解决(并不是说没有它就不能解决):
@Override
public String toString() {
return super.super.toString();
}
我不确定它在很多情况下是否有用，但我想知道为什么它没有，以及其他语言中是否存在类似的东西。
你们怎么看?
编辑: 澄清一下:是的，我知道，这在Java中是不可能的，我并不真的怀念它。这不是我期望的工作，并惊讶地得到一个编译器错误。我只是有了个想法，喜欢讨论一下。
当前回答
如果您认为您将需要超类，您可以在该类的变量中引用它。例如:
public class Foo
{
public int getNumber()
{
return 0;
}
}
public class SuperFoo extends Foo
{
public static Foo superClass = new Foo();
public int getNumber()
{
return 1;
}
}
public class UltraFoo extends Foo
{
public static void main(String[] args)
{
System.out.println(new UltraFoo.getNumber());
System.out.println(new SuperFoo().getNumber());
System.out.println(new SuperFoo().superClass.getNumber());
}
public int getNumber()
{
return 2;
}
}
应该打印出来:
2
1
0
其他回答
关键字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()将打印这个，它是一只猫。
我认为乔恩·斯基特有正确答案。我只是想补充一点，你可以通过强制转换从超类的超类中访问阴影变量:
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)
但是，这对方法调用不起作用，因为方法调用是基于对象的运行时类型确定的。
@Jon Skeet解释得好。 在我看来，如果有人想打电话给管理员。超方法则必须是想要忽略直接父元素的行为，但想要访问大父元素的行为。 这可以通过实例Of来实现。如下代码
public class A {
protected void printClass() {
System.out.println("In A Class");
}
}
public class B extends A {
@Override
protected void printClass() {
if (!(this instanceof C)) {
System.out.println("In B Class");
}
super.printClass();
}
}
public class C extends B {
@Override
protected void printClass() {
System.out.println("In C Class");
super.printClass();
}
}
这是驾驶员课，
public class Driver {
public static void main(String[] args) {
C c = new C();
c.printClass();
}
}
它的输出将是
In C Class
In A Class
在这种情况下，类B printClass行为将被忽略。 我不确定这是一个理想的或好的做法，以达到超级。非常好，但它仍然有效。
除了其他人提出的非常好的观点之外，我认为还有另一个原因:如果超类没有超类怎么办?
因为每个类都自然地扩展(至少)Object，所以super.whatever()总是引用超类中的一个方法。但是如果你的类只扩展Object呢?超级指的是什么?该如何处理该行为-编译器错误，空指针，等等?
我认为不允许这样做的主要原因是它违反了封装，但这可能也是一个小原因。
使用反射，似乎至少可以获得超类的超类的类，尽管不一定是它的实例;如果这可能是有用的，请考虑Javadoc http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Class.html#getSuperclass()
