为什么是super.super.method（）; Java中不允许？

我读了这个问题，并认为如果可以写的话，很容易解决（不是没有它就不能解决）：

@Override
public String toString() {
    return super.super.toString();
}

我不确定在很多情况下它是否有用，但是我想知道为什么它没有用，以及其他语言中是否存在类似的东西。

你们有什么感想？

编辑：澄清一下：是的，我知道，这在Java中是不可能的，我也不是很想念它。这不是我期望的工作，并且惊讶于出现编译器错误。我只有这个主意，喜欢讨论。

#1楼

似乎至少可以使用反射来获取超类的超类的类，尽管不一定是它的实例。如果这可能有用，请考虑Javadoc，网址为http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Class.html#getSuperclass（）

#2楼

当架构是在代表几个派生类实现的通用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方法，我们可以轻松避免此类情况。但是在任何时候，期望设计良好的体系结构都不太可行，因此需要摆脱扎实的设计原则并引入类似的技巧。只是我的2美分...

#3楼

@Jon Skeet很好的解释。 IMO如果有人要调用super.super方法，则必须要忽略直接父级的行为，但要访问大父级的行为。这可以通过实例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行为。我不确定这是否是实现super.super的理想或良好做法，但仍然有效。

#4楼

如果可能的话，我会把super.super方法的主体放在另一个方法中

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();
    }
}

或者，如果您不能更改super-super类，则可以尝试以下操作：

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();

结果为“我是超级超级”

#5楼

我认为这是一个破坏继承协议的问题。
通过扩展课程，您可以遵守/同意其行为，功能
在调用super.super.method() ，您想打破自己的服从协议。

你不能从超级班上挑樱桃 。

但是，在某些情况下，您可能需要在代码中或在您继承的代码中调用super.super.method() -通常是一个错误的设计标志！
如果超级 超级超级类不能被重构（一些旧的代码），然后选择超过继承组成。

封装破坏是当您通过破坏封装的代码@Override一些方法时。设计为不可覆盖的方法标记为final 。

来源：oschina

链接：https://my.oschina.net/u/3797416/blog/3179548

标签

string