C# 抽象类与抽象方法的作用与实例

在C#中，允许把类和方法声明为抽象类与抽象方法，具体的声明方法是在类名或方法名前加上abstract关键字。

那么我们什么时候应该用抽象类呢？
如果一个类设计的目点是用来被其它类继承的，它代表一类对象的所具有的公共属性或方法，那个这个类就应该设置为抽象类。

抽象类与其它的类有什么区别呢？
抽象类是不能够被实例化的。如果一个类中包含有抽象方法，那么这个类一定要声明为抽象类。同时，抽象方法一定需要在子类中重写，让抽象方法成为一个具体的实实在在的方法。

比如，我们要声明一个动物类animal，然后有其它的类Cat(猫)，Dog(狗)等具体的类来继承它，那么这个动物类就应该声明为抽象类。因为animal只是一个名词，不代表任何具体的对象，它只是代表所有动物所拥有的共同特征，所以animal类是根本不可能被实例化的。同时，如果所有动物都必须声明"叫"这样一个方法的话，那么，我们可以在animal类中声明一个抽象方法shout()，因为抽象方法是必须在子类中重写的，所以这就限制了所有继承自animal类都必须重写shout()方法。

实例：
声明Animal类

abstract class Animal //声明Animal为抽象类
{
……
protected abstract void Shout(); //声明Shout()方法为抽象方法，那么所有继承Animal类的子类都必须重写Shout()方法
}

声明Dog类，继承自Animal类

class Dog:Animal
{
protected override vod Shout()
{
response.write("汪");
}
}

 

抽象类能够被用于类，方法，属性，索引器和事件，使用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 关键字意味着包含它们的实现。