原文：http://www.cnblogs.com/flyinthesky/archive/2008/06/18/1224774.html

在C#中使用關鍵字 abstract 來定義抽象類和抽象方法。

不能初始化的類被叫做抽象類，它們只提供部分實現，但是另一個類可以繼承它並且能建立它們
的例項。

"一個包含一個或多個純虛擬函式的類叫抽象類，抽象類不能被例項化，進一步
一個抽象類只能通過介面和作為其它類的基類使用."- C++ Programming Language by Stroustrup Chapter13.2

抽象類能夠被用於類，方法，屬性，索引器和事件，使用abstract 在一個類宣告中表示該類傾向要作為其它類的基類
成員被標示成abstract，或被包含進一個抽象類，必須被其派生類實現。

abstract   class  ShapesClass
     {
        abstract public int Area();
    }
     class  Square : ShapesClass
     {
        int x, y;
        // Not providing an Area method results
        // in a compile-time error.
        

public override int Area()
        {
            return x * y;
        }
    }

例如，一個包含非抽象方法的抽象類：

     abstract   class  MyAbs
     {
        public void NonAbMethod()
        {
            Console.WriteLine("Non-Abstract Method");
        }
    }
     class  MyClass : MyAbs
     {
    }
     class  MyClient
     {
        public static void Main()
        {
            //MyAbs mb = new MyAbs();//not possible to create an instance
            MyClass mc = new MyClass();
            mc.NonAbMethod(); // Displays 'Non-Abstract Method'
        }
    }

一個抽象類可以包含抽象和非抽象方法，當一個類繼承於抽象類，那麼這個派生類必須實現所有的
的基類抽象方法。

一個抽象方法是一個沒有方法體的方法。
  abstract   class  MyAbs
     {
        public void NonAbMethod()
        {
            Console.WriteLine("Non-Abstract Method");
        }
        public abstract void AbMethod(); // An abstract method
    }
     class  MyClass : MyAbs // must implement base class abstract methods
     {
        public override void AbMethod()
        {
            Console.WriteLine("Abstarct method");
        }
    }
     class  MyClient
     {
        public static void Main()
        {
            MyClass mc = new MyClass();
            mc.NonAbMethod();
            mc.AbMethod();
        }
    }

但是通過宣告派生類也為抽象，我們可以避免所有或特定的虛方法的實現，
這就是抽象類的部分實現。

abstract   class  MyAbs
     {
        public abstract void AbMethod1();
        public abstract void AbMethod2();
    }
     // not necessary to implement all abstract methods
     // partial implementation is possible
     abstract   class  MyClass1 : MyAbs
     {
        public override void AbMethod1()
        {
            Console.WriteLine("Abstarct method #1");
        }
    }
     class  MyClass : MyClass1
     {
        public override void AbMethod2()
        {
            Console.WriteLine("Abstarct method #2");
        }
    }
     class  MyClient
     {
        public static void Main()
        {
            MyClass mc = new MyClass();
            mc.AbMethod1();
            mc.AbMethod2();
        }
    }
在C#中，一個抽象類能夠繼承另一個非抽象類，另外，繼承了基類的方法，新增新的
抽象和非抽象方法是可行的。

  class  MyClass1  //  Non-Abstract class
     {
        public void Method1()
        {
            Console.WriteLine("Method of a non-abstract class");
        }
    }
     abstract   class  MyAbs : MyClass1  //  Inherits from an non-abstract class
     {
        public abstract void AbMethod1();
    }
     class  MyClass : MyAbs // must implement base class abstract methods
     {
        public override void AbMethod1()
        {
            Console.WriteLine("Abstarct method #1 of MyClass");
        }
    }
     class  MyClient
     {
        public static void Main()
        {
            MyClass mc = new MyClass();
            mc.Method1();
            mc.AbMethod1();
        }
    }
一個抽象類也能從一個介面來實現，這種情況，我們必須為所有的方法提供方法體，這些方法是來自介面

     interface  IInterface
     {
        void Method1();
    }
     abstract   class  MyAbs : IInterface
     {
        public void Method1()
        {
            Console.WriteLine("Method implemented from the IInterface");
        }
    }
     class  MyClass : MyAbs // must implement base class abstract method
     {
    }
     class  MyClient
     {
        public static void Main()
        {
        MyClass mc = new MyClass();
        mc.Method1();
        }
    }  

 我們不能把關鍵字abstract 和 sealed 一起用在C#中，因為一個密封類不能夠被抽象。

  abstract   class  MyAbs
     {
        public abstract void AbMethod1();
        public abstract void AbMethod2();
    }
     class  MyClass1 : MyAbs
     {
        public override void AbMethod1()
        {
            Console.WriteLine("Abstarct method #1 of MyClass1");
        }
        public override void AbMethod2()
        {
            Console.WriteLine("Abstarct method #2 of MyClass1");
        }
    }
     class  MyClient
     {
        public static void Main()
        {
            MyAbs ma1 = new MyClass1();// Polymorphism
            ma1.AbMethod1();
            ma1.AbMethod2();
        }
    }

抽象方法有以下特徵：

1.一個抽象方法可以看作是一個虛擬函式。

2.抽象方法的宣告只能在抽象類中。

3.因為抽象方法宣告只提供一個無實現的方式，沒有方法體

4.方法體的實現被覆寫方法提供，覆寫方法是一個非抽象類的成員。

5.抽象屬性的行為和抽象方法相像，除了不同的宣告形式。

6.在一個靜態屬性中使用abstract 是一個錯誤。

        *一個抽象屬效能夠通過派生類使用 override 實現.

對於抽象類：

一個抽象類必須為所有的介面成員提供實現
一個用於實現介面的抽象類可能把介面方法安排到抽象方法上。例如

interface  I 
{
    void M();
}
abstract   class  C: I 
{
    public abstract void M();
}

抽象類具有以下特徵：

1.抽象類不能被例項化。

2.抽象類可以包含抽象方法和訪問器

3.不能把抽象類用密封(sealed)來修飾，那就意味著類不能被繼承，這違反抽象類被繼承的原則。

4.一個派生於一個抽象類的非抽象類必須包括所有的繼承來的抽象方法和訪問器的實現

5.在方法和屬性中使用abstract 關鍵字意味著包含它們的實現。