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

时间:2016-04-06 18:03:35

标签: c# inheritance abstract-class

为简单起见,我们假设我有一个" Base"抽象类:

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

    public abstract void BaseMethod();
}

我想让第2和第3课继承这个" BaseClass":

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

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

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

我知道我可以实施其他方法'清空。但是,我试图避免这种情况,因为我找到了以下声明:

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

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

4 个答案:

答案 0 :(得分:8)

  

抽象类可以在不实现抽象方法的情况下继承(虽然这样的派生类本身是抽象的

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

答案 1 :(得分:3)

声明没有错,但要遵循您的代码需要更改为

的声明
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>,你怎么知道哪个是你想要调用的正确版本?您应该重新考虑您的设计只有一个两个函数都可以使用的虚拟方法。

答案 2 :(得分:1)

&#34;抽象类可以在不实现抽象方法的情况下继承(尽管这样的派生类本身就是抽象的)&#34;。

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

答案 3 :(得分:1)

正如其他人所说,你做不到。你必须将你的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种不同的实现,你可以混合搭配它们。