如何避免从抽象类实现方法？

Question

为了简单起见，假设我有一个“ Base”抽象类：

public abstract class BaseClass
{
    public abstract void BaseMethod(object obj);

    public abstract void BaseMethod();
}

我想使第二和第三类从此“ BaseClass”继承：

public class Class1 : BaseClass
{
    public override void BaseMethod(object obj)
    {
        //Some code
    }
}

public class Class2 : BaseClass
{
    public override void BaseMethod()
    {
        //Some code
    }
}

基本上， 我希望每个类都实现一个方法而不实现另一个方法 。 上面的示例不起作用，因为对于每个类，系统都会提示我实现另一个抽象方法。

我知道我可以实现其他方法“空”。 但是，由于发现以下语句，因此我试图避免这种情况：

无需实现抽象方法就可以继承抽象类（尽管这样的派生类本身就是抽象的）

这句话错了吗？ 非常感谢您对此主题的任何投入。 谢谢！

Answer 1

无需实现抽象方法就可以继承抽象类（ 尽管这样的派生类本身就是抽象的 ）

粗体部分是您不遵守的部分-是的，您可以有一个“中间”类，该类仅实现某些抽象方法，但该类也必须是抽象的 。 在某些时候，当您进入具体的类时，必须实现所有抽象方法。 无论是在类本身还是在继承链中的某个地方。

Answer 2

该语句没有错，但是要遵循该语句，您的代码需要更改为

public abstract class Class1 : BaseClass
{
    public override void BaseMethod(object obj)
    {
        //Some code
    }
}

public abstract class Class2 : BaseClass
{
    public override void BaseMethod()
    {
        //Some code
    }
}

因此，您仍然将无法创建类。 更好的解决方案是将函数虚拟化，而不是使用空的正文或引发错误的正文抽象。

public abstract class BaseClass
{
    public virtual void BaseMethod(object obj) { throw new NotImplmentedException(); }

    public abstract void BaseMethod() { throw new NotImplmentedException(); }
}

但是我仍然认为这是一个坏主意，如果您有List<BaseClass> ，您将如何知道要调用的正确版本？ 您应该重新考虑设计，使其只有一种虚拟方法可供两个功能使用。

Answer 3

“可以在不实现抽象方法的情况下继承抽象类（尽管这样的派生类本身就是抽象的）”。

这个说法是正确的。 这意味着如果类“ Class1”和“ Class2”未实现所有抽象方法，则它们也必须是抽象的。

Answer 4

正如别人所说，你做不到。 您必须将BaseClass划分为两个不同的类（如果BaseClass是您的类）。

要么

您可以通过包装或按示例扩展BaseClass来“作弊”

    public class BaseClassWrapper : BaseClass
    {
        private IBaseMethodA methodA;

        private IBaseMethodB methodB;

        public BaseClassWrapper(IBaseMethodA methodA, IBaseMethodB methodB)
        {
            this.methodA = methodA;
            this.methodB = methodB;
        }

        public override void BaseMethod()
        {
            methodB.BaseMethod();
        }

        public override void BaseMethod(object obj)
        {
            methodA.BaseMethod(obj);
        }

        public interface IBaseMethodA
        {
            void BaseMethod(object obj);
        }

        public interface IBaseMethodB
        {
            void BaseMethod();
        }
    }

现在，您有两个单独的接口要实现。 这显然会使设计和实现更加复杂，但可能会给您带来一些优势。 例如，如果您对IBaseMethodA有4种不同的实现，对于IBaseMethodB有3种，则可以混合使用它们。