Question

所以我对OOP不是很好，而且有点难过。如果我已经有来自FruitHandler库的FruitHandler类，它们看起来像这样：

public partial class AppleCleaner : FruitHandler {

    public AppleCleaner(int fruitSize) {
        CleanApple(fruitSize);
    }

    void CleanApple(int size) {
        //code to clean an apple;
    }
}

public partial class PearCleaner : FruitHandler {

    public PearCleaner(int fruitSize) {
        CleanPear(fruitSize);
    }

    void CleanPear(int size) {
        //code to clean a pear;
    }
}

public partial class BananaCleaner : FruitHandler {

    public BananaCleaner(int fruitSize) {
        CleanBanana(fruitSize);
    }

    void CleanBanana(int size) {
        //code to clean a banana;
    }
}

我想创建一个也有基类FruitHandler的类，但是能够使用看起来像这样的CleanApple，CleanPear或CleanBanana：

public partial class FruitEater : FruitHandler {

    public FruitEater(Fruit fruit) {
        if (fruit.Name == "Apple") {
            CleanApple(fruit.size);
        } else if (fruit.Name == "Pear") {
            CleanPear(fruit.size);
        } else if (fruit.Name == "Banana") {
            CleanBanana(fruit.size);
        }

        EatFruit(fruit);
    }

    void EatFruit(Fruit fruit) {
        // eat it;
    }
}

我可以自由地重构这些，但需要注意的是，所有这些的基类必须是一个FruitHandler（因为在现实生活中这些都是Form，基类必须是Form）

Answer 1

你可以这样做：

interface IFruitCleaner {
    void Clean(int size)
}

public partial class AppleCleaner : FruitHandler, IFruitCleaner {

    public AppleCleaner(int fruitSize) {
        Clean(fruitSize);
    }

    void Clean(int size) {
        //code to clean an apple;
    }
}


public partial class FruitEater : FruitHandler {

    public FruitEater(Fruit fruit, IFruitCleaner cleaner) {
        cleaner.Clean(fruit.size);
        EatFruit(fruit);
    }

    void EatFruit(Fruit fruit) {
        // eat it;
    }
}

好像你想把水果传递给AppleCleaner而不是大小，但我已经把它留下了。

Answer 2

您应该使用接口。除非每个类都要在它们的基类中执行代码（这里不是这种情况），否则你应该使用一个接口来定义类中的公共方法：

public interface IFruit {
    void Clean(int Size);
}

public partial class AppleCleaner : IFruit, FruitHandler {

    public AppleCleaner(int fruitSize) {
        Clean(fruitSize);
    }

    void Clean(int size) {
        //code to clean an apple;
    }
}

public partial class PearCleaner : IFruit, FruitHandler {

    public PearCleaner(int fruitSize) {
        Clean(fruitSize);
    }

    void Clean(int size) {
        //code to clean a pear;
    }
}

public partial class BananaCleaner : IFruit, FruitHandler {

    public BananaCleaner(int fruitSize) {
        Clean(fruitSize);
    }

    void Clean(int size) {
        //code to clean a banana;
    }
}

这也简化了你的FruitEater课程：

public partial class FruitEater : FruitHandler {

    public FruitEater(IFruit fruit, int size) {
        fruit.Clean(size);
        EatFruit(fruit);
    }

    void EatFruit(IFruit fruit) {
        // eat it;
    }
}

Answer 3

通常你会在基类中使用clean，但正如你所说的那样，它是一个真实世界的例子，你可以使用一个接口。

public interface IFruitCleaner  {
   void Clean(int size);
}

public partial class AppleCleaner : FruitHandler, IFruitCleaner
{

    public AppleCleaner(int fruitSize)
    {
        Clean(fruitSize);
    }

    void Clean(int size)
    {
        //code to clean an apple;
    }
}

public partial class PearCleaner : FruitHandler, IFruitCleaner
{

    public PearCleaner(int fruitSize)
    {
        Clean(fruitSize);
    }

    void Clean(int size)
    {
        //code to clean a pear;
    }
}


public partial class BananaCleaner : FruitHandler, IFruitCleaner
{

    public BananaCleaner(int fruitSize)
    {
        Clean(fruitSize);
    }

    void Clean(int size)
    {
        //code to clean a banana;
    }
}

当所有具有相同基类（包括新类）时，如何继承多个部分类？

3 个答案: