C#抽象類及其方法的學習

在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 關鍵字意味着包含它們的實現。

未完待續......