我读了这个问题，并认为如果有人可以这样写，这个问题就很容易解决(并不是说没有它就不能解决):
@Override
public String toString() {
return super.super.toString();
}
我不确定它在很多情况下是否有用，但我想知道为什么它没有，以及其他语言中是否存在类似的东西。
你们怎么看?
编辑: 澄清一下:是的，我知道，这在Java中是不可能的，我并不真的怀念它。这不是我期望的工作，并惊讶地得到一个编译器错误。我只是有了个想法，喜欢讨论一下。
当前回答
在c#中，你可以像这样调用任何祖先的方法:
public class A
internal virtual void foo()
...
public class B : A
public new void foo()
...
public class C : B
public new void foo() {
(this as A).foo();
}
你也可以在Delphi中这样做:
type
A=class
procedure foo;
...
B=class(A)
procedure foo; override;
...
C=class(B)
procedure foo; override;
...
A(objC).foo();
但是在Java中，你只能通过一些设备来实现这样的聚焦。一种可能的方法是:
class A {
int y=10;
void foo(Class X) throws Exception {
if(X!=A.class)
throw new Exception("Incorrect parameter of "+this.getClass().getName()+".foo("+X.getName()+")");
y++;
System.out.printf("A.foo(%s): y=%d\n",X.getName(),y);
}
void foo() throws Exception {
System.out.printf("A.foo()\n");
this.foo(this.getClass());
}
}
class B extends A {
int y=20;
@Override
void foo(Class X) throws Exception {
if(X==B.class) {
y++;
System.out.printf("B.foo(%s): y=%d\n",X.getName(),y);
} else {
System.out.printf("B.foo(%s) calls B.super.foo(%s)\n",X.getName(),X.getName());
super.foo(X);
}
}
}
class C extends B {
int y=30;
@Override
void foo(Class X) throws Exception {
if(X==C.class) {
y++;
System.out.printf("C.foo(%s): y=%d\n",X.getName(),y);
} else {
System.out.printf("C.foo(%s) calls C.super.foo(%s)\n",X.getName(),X.getName());
super.foo(X);
}
}
void DoIt() {
try {
System.out.printf("DoIt: foo():\n");
foo();
Show();
System.out.printf("DoIt: foo(B):\n");
foo(B.class);
Show();
System.out.printf("DoIt: foo(A):\n");
foo(A.class);
Show();
} catch(Exception e) {
//...
}
}
void Show() {
System.out.printf("Show: A.y=%d, B.y=%d, C.y=%d\n\n", ((A)this).y, ((B)this).y, ((C)this).y);
}
}
objC.DoIt()结果输出:
DoIt: foo():
A.foo()
C.foo(C): y=31
Show: A.y=10, B.y=20, C.y=31
DoIt: foo(B):
C.foo(B) calls C.super.foo(B)
B.foo(B): y=21
Show: A.y=10, B.y=21, C.y=31
DoIt: foo(A):
C.foo(A) calls C.super.foo(A)
B.foo(A) calls B.super.foo(A)
A.foo(A): y=11
Show: A.y=11, B.y=21, C.y=31
其他回答
看看这个Github项目，尤其是objectHandle变量。这个项目展示了如何实际而准确地在孙子上调用祖父母方法。
以防链接被破坏，下面是代码:
import lombok.val;
import org.junit.Assert;
import org.junit.Test;
import java.lang.invoke.*;
/*
Your scientists were so preoccupied with whether or not they could, they didn’t stop to think if they should.
Please don't actually do this... :P
*/
public class ImplLookupTest {
private MethodHandles.Lookup getImplLookup() throws NoSuchFieldException, IllegalAccessException {
val field = MethodHandles.Lookup.class.getDeclaredField("IMPL_LOOKUP");
field.setAccessible(true);
return (MethodHandles.Lookup) field.get(null);
}
@Test
public void test() throws Throwable {
val lookup = getImplLookup();
val baseHandle = lookup.findSpecial(Base.class, "toString",
MethodType.methodType(String.class),
Sub.class);
val objectHandle = lookup.findSpecial(Object.class, "toString",
MethodType.methodType(String.class),
// Must use Base.class here for this reference to call Object's toString
Base.class);
val sub = new Sub();
Assert.assertEquals("Sub", sub.toString());
Assert.assertEquals("Base", baseHandle.invoke(sub));
Assert.assertEquals(toString(sub), objectHandle.invoke(sub));
}
private static String toString(Object o) {
return o.getClass().getName() + "@" + Integer.toHexString(o.hashCode());
}
public class Sub extends Base {
@Override
public String toString() {
return "Sub";
}
}
public class Base {
@Override
public String toString() {
return "Base";
}
}
}
编码快乐! !
public class A {
@Override
public String toString() {
return "A";
}
}
public class B extends A {
@Override
public String toString() {
return "B";
}
}
public class C extends B {
@Override
public String toString() {
return "C";
}
}
public class D extends C {
@Override
public String toString() {
String result = "";
try {
result = this.getClass().getSuperclass().getSuperclass().getSuperclass().newInstance().toString();
} catch (InstantiationException ex) {
Logger.getLogger(D.class.getName()).log(Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
Logger.getLogger(D.class.getName()).log(Level.SEVERE, null, ex);
}
return result;
}
}
public class Main {
public static void main(String... args) {
D d = new D();
System.out.println(d);
}
}
运行: 一个 BUILD SUCCESSFUL(总时间:0秒)
我没有足够的声誉来评论，所以我将把这个添加到其他答案中。
乔恩·斯基特用一个漂亮的例子回答得很好。Matt B有一个观点:不是所有的超类都有超类。如果你调用一个没有super的super，你的代码就会崩溃。
面向对象编程(Java就是面向对象编程)是关于对象的，而不是函数。如果你想要面向任务的编程，选择c++或其他语言。如果你的对象不适合它的父类，那么你需要将它添加到“祖父类”，创建一个新类，或者找到另一个它适合的父类。
就我个人而言，我发现这种限制是Java最大的优势之一。与我使用过的其他语言相比，代码有点僵硬，但我总是知道会发生什么。这有助于实现Java“简单而熟悉”的目标。在我的脑海里，打电话给上级。超级不简单也不熟悉。也许开发者也有同感?
我认为这是一个打破继承协议的问题。 通过扩展一个类，你服从/同意它的行为、特征 而当调用super.super.method()时，你想要打破你自己的服从协议。
你不能从超类中挑选。
然而，可能会出现需要调用super.super.method()的情况——在您的代码或继承的代码中，这通常是一个糟糕的设计标志! 如果不能重构超类和超超类(一些遗留代码)，则选择复合而不是继承。 封装破坏是指通过破坏封装的代码@Override一些方法。 标记了设计为不被覆盖的方法 决赛。
我猜，因为它不常用。我能看到使用它的唯一原因是，如果您的直接父文件覆盖了某些功能，而您试图将其恢复到原始文件。
在我看来，这似乎是违反OO原则的，因为类的直接父类应该比祖父类更接近你的类。
