Question

我有一个基类，它有一些抽象方法，有21个类继承自这个基类。现在，对于其中一个抽象方法，我想用21个类中的6个实现它的通用实现，所以我考虑创建另一个基类来实现这一点。

我愿意接受建议，但我在当前基类和21个类之间创建另一个基类的主要目的是在21个类中的6个中重复相同的代码，如果我没有必要的话。

以下是用于说明情况的代码示例：

public abstract class FooBase
{
   public abstract string Bar();
   public abstract string SomeMethod();
   public virtual string OtherMethod()
   {
       return this.SomeMethod();
   }
}

public abstract class AnotherBase : FooBase
{
   public abstract string Bar();
   public abstract string SomeMethod();
   public override OtherMethod()
   {
      //this is the common method used by 6 of the classes
      return "special string for the 6 classes";
   }
}

public class Foo1 : FooBase
{
   public override string Bar()
   {
      //do something specific for the Foo1 class here
      return "Foo1 special string";
   }
   public override string SomeMethod()
   {
      //do something specific for the Foo1 class here
      return "Foo1 special string";
   }
}

public class Another2 : AnotherBase
{
   public override string Bar()
   {
      //do something specific for the Another2 class here
      return "Another special string";
   }
   public override string SomeMethod()
   {
      //do something specific for the Another2 class here
      return "Another2 special string";
   }
}

Answer 1

是的，您可以从另一个抽象类派生一个抽象类

public abstract class FooBase
{
    //Base class content
}

public abstract class AnotherBase : FooBase
{
    //it is "optional" to make the definition of the abstract methods of the Parent class in here
}

当我们说可选来定义子类内部父类的抽象方法时，必须是子类应该是抽象的。< / p>

public abstract class FooBase
{
    public abstract string Bar();
    public abstract string SomeMethod();
    public abstract string OtherMethod();
}

public abstract class AnotherBase : FooBase
{
    public override string OtherMethod()
    {
        //common method that you wanted to use for 6 of your classes
        return "special string for the 6 classes";
    }
}

//child class that inherits FooBase where none of the method is defined
public class Foo1 : FooBase
{
    public override string Bar()
    {
        //definition
    }
    public override string SomeMethod()
    {
        //definition
    }
    public override string OtherMethod()
    {
        //definition
    }
}

//child class that inherits AnotheBase that defines OtherMethod
public class Another2 : AnotherBase
{
    public override string Bar()
    {
        //definition
    }
    public override string SomeMethod()
    {
        //definition
    }
}

所以我猜测还会有另外5个类Another2继承自AnotherBase的类OtherMethod

Answer 2

是的，这是完全可能的并经常完成。没有规则说您可以在类层次结构的最底层只有一个基类;该类的子类也可以是抽象的，从而成为（一些更专业的）基类，用于从一般基类间接派生的一组类。

Answer 3

您应该指定这些类的确切内容，但是..给出您提供的信息：

这是Strategy pattern旨在解决的确切问题，如Head First Design Patterns一书中给出的示例所示。

你有一个抽象的Duck类，其他的鸭子（例如，RedheadDuck，MallardDuck）派生出来。 Duck类有一个Quack方法，只需在屏幕上显示字符串“quack”。

现在告诉您添加RubberDuck。这家伙不嘎嘎！所以你会怎么做？使Quack抽象，让子类决定如何实现它？不，这会导致重复的代码。

相反，您使用IQuackBehaviour方法定义Quack接口。从那里，您可以派生出两个类QuackBehaviour和SqueakBehaviour。

public class SqueakBehaviour: IQuackBehaviour
{
    public void Quack(){
        Console.WriteLine("squeak");
    }
}

public class QuackBehaviour: IQuackBehaviour
{
    public void Quack(){
        Console.WriteLine("quack");
    }
}

现在，您根据需要使用此行为撰写：

public class MallardDuck : Duck
{
    private IQuackBehaviour quackBehaviour = new QuackBehaviour();

    public override void Quack()
    {
        quackBehaviour.Quack();
    }
}

public class RubberDuck : Duck
{
    private IQuackBehaviour quackBehaviour = new SqueakBehaviour();

    public override void Quack()
    {
        quackBehaviour.Quack();
    }
}

如果您希望鸭子在运行时更改其行为，您甚至可以通过属性注入IQuackBehaviour的实例。

你能用另一个基类覆盖基类中的一个抽象方法吗？

3 个答案: