为什么super.super.method();在Java中是不允许的?

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

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

this->ReallyTheBase::foo();

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

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中的不变量被破坏了。

明白吗?

我猜，因为它不常用。我能看到使用它的唯一原因是，如果您的直接父文件覆盖了某些功能，而您试图将其恢复到原始文件。

在我看来，这似乎是违反OO原则的，因为类的直接父类应该比祖父类更接近你的类。

除了其他人提出的非常好的观点之外，我认为还有另一个原因:如果超类没有超类怎么办?

因为每个类都自然地扩展(至少)Object，所以super.whatever()总是引用超类中的一个方法。但是如果你的类只扩展了Object——那么super.super指的是什么呢?该如何处理该行为-编译器错误，空指针，等等?

我认为不允许这样做的主要原因是它违反了封装，但这可能也是一个小原因。

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

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

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

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

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

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)

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

使用反射，似乎至少可以获得超类的超类的类，尽管不一定是它的实例;如果这可能有用，请考虑http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Class.html getSuperclass ()中的Javadoc

简而言之

1. 创建祖先类型的临时实例
2. 将字段值从原始对象复制到临时对象
3. 在临时对象上调用目标方法
4. 将修改后的值复制回原始对象

用法:

public class A {
public void doThat() { ... }
}


public class B extends A {
public void doThat() { /* don't call super.doThat() */ }
}


public class C extends B {
public void doThat() {
Magic.exec(A.class, this, "doThat");
}
}




public class Magic {
public static <Type, ChieldType extends Type> void exec(Class<Type> oneSuperType, ChieldType instance,
String methodOfParentToExec) {
try {
Type type = oneSuperType.newInstance();
shareVars(oneSuperType, instance, type);
oneSuperType.getMethod(methodOfParentToExec).invoke(type);
shareVars(oneSuperType, type, instance);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static <Type, SourceType extends Type, TargetType extends Type> void shareVars(Class<Type> clazz,
SourceType source, TargetType target) throws IllegalArgumentException, IllegalAccessException {
Class<?> loop = clazz;
do {
for (Field f : loop.getDeclaredFields()) {
if (!f.isAccessible()) {
f.setAccessible(true);
}
f.set(target, f.get(source));
}
loop = loop.getSuperclass();
} while (loop != Object.class);
}
}

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

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

(本)SuperSuperClass .theMethod ();

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

在我看来，这是在Java中实现super.super.sayYourName()行为的干净方法。

public class GrandMa {
public void sayYourName(){
System.out.println("Grandma Fedora");
}
}


public class Mama extends GrandMa {
public void sayYourName(boolean lie){
if(lie){
super.sayYourName();
}else {
System.out.println("Mama Stephanida");
}
}
}


public class Daughter extends Mama {
public void sayYourName(boolean lie){
if(lie){
super.sayYourName(lie);
}else {
System.out.println("Little girl Masha");
}
}
}


public class TestDaughter {
public static void main(String[] args){
Daughter d = new Daughter();


System.out.print("Request to lie: d.sayYourName(true) returns ");
d.sayYourName(true);
System.out.print("Request not to lie: d.sayYourName(false) returns ");
d.sayYourName(false);
}
}

输出:

如果您认为您将需要超类，您可以在该类的变量中引用它。例如:

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

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


}
}

当你不能改变基类的代码时，调用super.super.method()是有意义的。这通常发生在扩展现有库时。

首先问问自己，为什么要扩展这个类?如果答案是“因为我不能改变它”，那么你可以在你的应用程序中创建确切的包和类，并重写调皮方法或创建委托:

package com.company.application;


public class OneYouWantExtend extends OneThatContainsDesiredMethod {


// one way is to rewrite method() to call super.method() only or
// to doStuff() and then call super.method()


public void method() {
if (isDoStuff()) {
// do stuff
}
super.method();
}


protected abstract boolean isDoStuff();




// second way is to define methodDelegate() that will call hidden super.method()


public void methodDelegate() {
super.method();
}
...
}


public class OneThatContainsDesiredMethod {


public void method() {...}
...
}

例如，你可以在你的应用程序中创建org.springframework.test.context.junit4.SpringJUnit4ClassRunner类，这样这个类应该在jar中真正的类之前加载。然后重写方法或构造函数。

注意:这是绝对的黑客，强烈不建议使用，但它是工作!使用这种方法是危险的，因为类装入器可能存在问题。此外，这可能会导致问题，每次您将更新库包含覆盖类。

我们通过在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(...);
}
}

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

Class B printClass行为在这种情况下将被忽略。 我不确定这是一个理想的或好的做法，以达到超级。超棒，但它仍然在工作

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

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

结果变成“我超级超级”

你不能从超类中挑选。