Question

为简单起见，我们假设我有一个＆＃34; Base＆＃34;抽象类：

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

    public abstract void BaseMethod();
}

我想让第2和第3课继承这个＆＃34; BaseClass＆＃34;：

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

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

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

我知道我可以实施其他方法＆＃39;清空。但是，我试图避免这种情况，因为我找到了以下声明：

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

这句话是错的吗？非常感谢有关此主题的任何意见。谢谢！

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

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

这句话是对的。这意味着班级＆＃39; Class1＆＃39;和＆＃34; Class2＆＃34;如果没有实现所有的抽象方法，它也必须是抽象的。

Answer 4

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

OR

你可以通过包装来“欺骗”，或者像在示例中那样以某种方式扩展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种不同的实现，你可以混合搭配它们。

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

4 个答案: