如果子实现接口vs覆盖，则调用方法

Question

我有一个类似于next的等级结构：

 AbstractRequestWs
   |- CreatorRequestWs
   |- CheckRequestWs
   |- GetRequestWs
   |- DeleteRequestWs

在这个实现中，我用通用代码处理ws调用。因此，我创建了一个抽象类，它包含一些常见的逻辑和结构。

因此，我创建了一个类似于next的类：

public abstract class AbstractRequestWs {

    protected Entity itemMapped;
    protected final EntityToMap entityToMap;        

    public AbstractRequestWs(EntityToMap entityToMap) {
        this.entityToMap = entityToMap;
    }

    public Entity map() {
        doSometing();
        //Do this?? or instead override this method on childs
        if (this instanceof StatusUpdatable) {
            ((StatusUpdatable) this).calcualteStatus();
        }
        return mapToEntity();
    }

    protected abstract void doSometing();

    private Entity mapToEntity() {
       //common impl
    }

}

然后，一些孩子需要更新一个状态(这需要大量的计算)，而另一些则不需要，我的想法是用一个StatusUpdatable方法创建一个接口calcualteStatus，所以如果一个子接口实现了这个接口，那么将在抽象父类中调用calculateStatus。

例如，创建者实现了StatusUpdatable，因此将调用calculateStatus方法。

 public CreatorRequestWs implements StatusUpdatable {
   //....
     public void calculateStatus() {
        //
     }
 }

否则，GetRequestW不会实现StatusUpdatable，因此不会调用calculateStatus方法。

public GetRequestWs {
   //....
}

这是个好主意吗？检查一个子接口是否实现了某个接口并调用了该接口的一个方法，或者以其他方式覆盖了这个公共方法并直接执行它？

否则，我将不得不重写类中的map()方法，该方法需要计算状态：

public CreatorRequestWs  {

   //....

   @Override
   public Entity map() {
       doSometing();
       calcualteStatus();
       return mapToEntity();
   }

   public void calculateStatus() {
      //...
   }
}

我看到读取比重写映射更困难，因为calculateStatus调用的方法是由父类隐藏的，但否则我不会重复代码。

你认为如何？

Answer 1

我认为拥有calculateStatus方法的类应该在它们的doSomeThing()结束时调用它。

或者，如果您希望重用更多的代码，请创建一个AbstractRequestStatusUpdatableWs，如下所示：

abstract class AbstractRequestStatusUpdatableWs implements StatusUpdatable
{
     abstract void calculateStatus();
     abstract void doSomeRealWork();

     public final void doSomeThing()
     { 
           doSomeRealWork();
           calculateStatus();
     }
}