OOP設計：具有相同基礎類的具有不同操作的具體類

Question

我想知道是否可以用C＃編寫以下代碼：

AbstractClass a = new ConcreteClass1();
a.Operations.Method1();

AbstractClass b = new ConcreteClass2();
b.Operations.Method2();

其中Method1（）是ConcreteClass1實例的獨占，而Method2（）是ConcreteClass2（）實例的獨占。 結果，a.Operations.Method2（）和b.Operations.Method1（）無效。

Answer 1

這是不可能的設計- a和b具有相同的類型，編譯器會這樣對待他們。 使其起作用的唯一方法是使用運行時異常。

使用抽象類或接口的概念與您嘗試執行的操作存在沖突。 聽起來ConcreteClass1和ConcreteClass2的用途不同，還是應該使用相同的抽象基類？

我不知道您到底想做什么-因此，我將提供一些選擇：

使用接口來顯示特定的類實現特定的操作：

interface IOperation1
{
    void Operation1();
}

interface IOperation2
{
    void Operation2();
}

然后根據您要實現的目標引用接口。

如果Method1和Method2應該在同一時間被調用，考慮設計，其中AbstractClass聲明要調用的方法，以及具體的類基礎上完成不同的操作：

abstract class AbstractClass
{
   ...
   abstract void DoSomeOperation();
}

class ConcreteClass1 
{
   override void DoSomeOperation() 
   {
      this.Operations.Method1();
   }
}

class ConcreteClass2 
{
   override void DoSomeOperation() 
   {
      this.Operations.Method2();
   }
}

Answer 2

ConcreteClass1和ConcreteClass2可以使用一些不同的方法，但是共享一些都從AbstractClass繼承的功能。 （如果將它們強制轉換為它們的基本類型，則只能調用它們從基本類型繼承的通用方法。）

這聽起來像之間的具體類是否使用差分Method1或Method2是一個內部細節應的類的內部進行處理。 該類應該知道它需要調用什么方法。 實際上，該類別的使用者是否甚至需要知道它取決於Operations ？ 可能不是。 使用者應該只在類上調用一個方法，然后該類是否使用Operations.Method1 ， Operations.Method2甚至完全依賴於Operations是內部實現細節。

也許您想要的是這樣的：

public abstract class AbstractClass
{
    public abstract void DoSomething();
}

public class Operations
{
    public void Method1()
    {
        //Does something
    }

    public void Method2()
    {
        //Apparently does something comopletely different
    }
}

public class ConcreteClass1 : AbstractClass
{
    private Operations _operations;

    public override void DoSomething()
    {
        _operations.Method1();
    }
}

public class ConcreteClass2 : AbstractClass
{
    private Operations _operations;

    public override void DoSomething()
    {
        _operations.Method2();
    }
}

僅當要求 每個派生類都將使用它時 ， Operations才應該在基類中。 （這不會發生太多。如果所有派生類都具有相同的行為，為什么它不在基類中？）如果是這種情況，則可以將其隱藏在基類中，如下所示：

public abstract class AbstractClass
{
    private Operations _operations;

    protected Operations Operations { get { return _operations; } }
    public abstract void DoSomething();
}

這樣，它就暴露給派生類，而對其他所有事物都隱藏了。