我读了这个问题，并认为如果有人可以这样写，这个问题就很容易解决(并不是说没有它就不能解决):
@Override
public String toString() {
return super.super.toString();
}
我不确定它在很多情况下是否有用，但我想知道为什么它没有，以及其他语言中是否存在类似的东西。
你们怎么看?
编辑: 澄清一下:是的，我知道，这在Java中是不可能的，我并不真的怀念它。这不是我期望的工作，并惊讶地得到一个编译器错误。我只是有了个想法，喜欢讨论一下。
当前回答
这很容易做到。例如:
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类
其他回答
使用反射，似乎至少可以获得超类的超类的类，尽管不一定是它的实例;如果这可能是有用的，请考虑Javadoc http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Class.html#getSuperclass()
我会把超级。如果可能的话，超级方法主体放在另一个方法中
class SuperSuperClass {
public String toString() {
return DescribeMe();
}
protected String DescribeMe() {
return "I am super super";
}
}
class SuperClass extends SuperSuperClass {
public String toString() {
return "I am super";
}
}
class ChildClass extends SuperClass {
public String toString() {
return DescribeMe();
}
}
或者如果你不能改变超超类，你可以试试这个:
class SuperSuperClass {
public String toString() {
return "I am super super";
}
}
class SuperClass extends SuperSuperClass {
public String toString() {
return DescribeMe(super.toString());
}
protected String DescribeMe(string fromSuper) {
return "I am super";
}
}
class ChildClass extends SuperClass {
protected String DescribeMe(string fromSuper) {
return fromSuper;
}
}
在这两种情况下，
new ChildClass().toString();
结果变成“我超级超级”
我猜，因为它不常用。我能看到使用它的唯一原因是，如果您的直接父文件覆盖了某些功能，而您试图将其恢复到原始文件。
在我看来，这似乎是违反OO原则的，因为类的直接父类应该比祖父类更接近你的类。
我曾经遇到过这样的情况，即体系结构是在一个公共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方法轻松避免这种情况。但在任何时候，期待设计良好的架构都是不现实的，因此需要摆脱坚实的设计原则，引入像这样的技巧。 这只是我的意见……
@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行为将被忽略。 我不确定这是一个理想的或好的做法，以达到超级。非常好，但它仍然有效。
