0

我有一个扩展 SuperClass 并实现 IClass 的类（为简单起见称为 SubClass）。我知道您可以使用 super.method() 调用 SuperClass 的方法，但是是否可以从 IClass 实现的 SubClass 中调用方法？

例子：

public class SuperClass {

    public void method(){

        implementedMethod();

    }

}

子类：

public class SubClass extends SuperClass implements IClass{

    public void implementedMethod() {

        System.out.println("Hello World");

    }

}

I类：

public interface IClass {

    public void implementedMethod();

}

我想从 SuperClass 调用 SubClass'impliedMethod() （它从 IClass 获得）

我该怎么做呢？

4

3 回答 3

2

您可以使超类抽象：

public abstract class SuperClass implements IClass {
    public void method(){
        implementedMethod();
    }
}
于 2013-07-25T19:47:19.630 回答
1

调用该方法的唯一方法是创建一个 SubClass 类型的对象（在 SuperClass 中）并调用 subClassInstance.implementedMethod()。

我还想强调，这是非常不雅的。正如对您的问题的评论中所述，如果您的超类需要调用子类方法，您应该重新考虑您的类设计。

于 2013-07-25T19:36:23.350 回答
1

鉴于上述类型，anExpressionOfTypeSubClassOrIClass.implementedMethod()必须使用。请注意，表达式的类型- 它提供的视图- 必须具有打算使用的方法。在这种情况下，SuperClass 类型的表达式不能在这里使用，因为它没有声明的implementedMethod成员。

一种方法（可以说是首选方法）是使用抽象方法。尽管多态性并不严格要求抽象方法，但它们描述了诸如此类的场景，其中子类应提供实现。（抽象方法可以用空方法替换，期望但不要求在子类中被覆盖，但为什么不用abstract于其设计目的？）

abstract class SuperClass implements IClass {
    // Don't implement this, but declare it abstract
    // so that we can conform to IClass as well
    public abstract void implementedMethod();

    public void method () {
       // Now this object (which conforms to IClass) has implementedMethod
       // which will be implemented by a concrete subclass.
       implementedMethod();
    }
}

这具有“负面”方面，即 SuperClass 不能直接实例化（毕竟它是抽象的）并且 SuperClass 必须实现（或者，如图所示，通过抽象委托）预期的签名。在这种情况下，我也选择让 SuperClass 实现 IClass，即使它不是严格要求的，因为它保证 SuperClass 和所有子类都可以被视为IClass。

或者，请记住，表达式类型只是对象的视图，不一定与对象的实际具体类型相同。虽然我建议不要使用以下代码，因为它失去了一些类型安全性，但我认为它显示了重要的一点。

class SuperClass {
    public void method () {
        // We try to cast and NARROW the type to a
        // specific "view". This can fail which is one
        // reason why it's not usually appropriate.
        ((IClass)this).implementedMethod();
    }
}

class SubClass extends SuperClass implements IClass {
  // ..
}

class BrokenSubClass extends SuperClass () {
}

// OK! Although it is the SAME OBJECT, the SuperClass
// method can "view" the current instance (this) as an IClass
// because SubClass implements IClass. This view must be
// explicitly request through a cast because SuperClass itself
// does not implement IClass or have a suitable method to override.
(new SubClass()).method();

// BAD! ClassCastException, BrokenSubClass cannot be "viewed" as IClass!
// But we didn't know until runtime due to lost type-safety.
(new BrokenSubClass()).method();
于 2013-07-25T20:11:39.613 回答