在超类中使用子类的方法

Question

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

例：

public class SuperClass {

    public void method(){

        implementedMethod();

    }

}

子类：

public class SubClass extends SuperClass implements IClass{

    public void implementedMethod() {

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

    }

}

iCLASS非：

public interface IClass {

    public void implementedMethod();

}

我想从SuperClass调用SubClass的ImplementedMethod（）（从IClass那里获得）

我将如何去做？

Answer 1

您可以使超类抽象：

public abstract class SuperClass implements IClass {
    public void method(){
        implementedMethod();
    }
}

Answer 2

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

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

Answer 3

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

一种方法（可以说是首选方法）是使用抽象方法 。 即使多态性不是严格要求抽象方法，但它们描述了诸如此类的情况，其中子类应提供实现。 （可以将抽象方法替换为期望但不要求在sublcasses中覆盖的空方法，但为什么不将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();