Oop 面向对象继承问题

考虑以下两种方法：

A类{
void Method1（）{
如果（！某物）返回；
DoX（）；
DoY（）；
DoZ（）；
}
B类{
void方法2（）{
如果（！某物）返回；
DoX（）；
DoY（）；
DoP（）；
}
}

显然，可以编写一个超类来避免干燥原理：

class超级{
虚空法（）{
如果（！something）返回；//问题。。。
DoX（）；
DoY（）；
}
}
甲级：超级{
重写无效方法（）{
继承方法（）；
DoZ（）；
}
}
B类：超级{
重写无效方法（）{
继承方法（）；
DoP（）；
}
}

问题是！something检查在第一个示例中它将在哪里运行，而在第二个示例中，它将在超类的方法中运行，但在派生类中执行DoZ（）或DoP（）

我的问题是：解决这类问题的最佳方法是什么？我手头上的一个方法是使超类的方法成为一个返回bool的函数

virtualbool方法（）{if（！something）返回false；}
重写布尔方法（）{if（！inherited Method（））return；}

---

这是最好的解决方法吗？

为什么不为DoP或Doz声明另一个虚拟方法呢？如果您想用它们各自的名称公开它们，可以将它们包装起来

类似于超类：

virtual void wrapping(){};

然后每个孩子：

void wrapping() { DoP(); }
void wrapping() { DoZ(); }

---

不知道我是否清楚。

另一个选项：在派生方法中保留检查。派生类可能需要稍微不同的条件

class Super{
  virtual void Method(){
    DoX();
    DoY();
  }
}
class A:Super{
  override void Method(){
    if(!something) return;
    inherited Method();
    DoZ();
  }
}
class B:Super{
  override void Method(){
    if(!something) return;
    inherited Method();
    DoP();
  }
}

那么：

class Super {
    void Method() {
        if (!something) return;

        DoX();
        DoY();

        DoThingy();
    }

    abstract void DoThingy();
}

class A : Super {
    override DoThingy() {
        DoZ();
    }
}

class B : Super {
    override DoThingy() {
        DoP();
    }
}