在C#中使用关键字 abstract 来定义抽象类和抽象方法。

不能初始化的类被叫做抽象类，它们只提供部分实现，但是另一个类可以继承它并且能创建它们的实例。

"一个包含一个或多个纯虚函数的类叫抽象类，抽象类不能被实例化；进一步地说，一个抽象类只能通过接口和作为其它类的基类使用."  -- C++ Programming Language by Stroustrup Chapter13.2

抽象类能够被用于类，方法，属性，索引器和事件，在使用abstract声明的类表示该类倾向要作为其它类的基类；成员被标示成abstract，或被包含进一个抽象类，必须被其派生类实现。

// 抽象类
abstract class ShapesClass
{
    // 抽象方法,没有具体的实现
    abstract public int Area();
}

// 派生类继承了基类(抽象类)
class Square : ShapesClass
{
    int x, y;
    // 实现基类的抽象方法
    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(); // 抽象类创建实例是不可能的
        MyClass mc = new MyClass();  // 输出 "Non-Abstract Method"
        mc.NonAbMethod();
    }
}

 

一个抽象类可以包含抽象方法和非抽象方法，当一个类继承于抽象类，那么这个派生类必须实现所有的基类抽象方法。

 一个抽象方法是一个没有方法体的方法。  

{
    // 抽象类中的非抽象方法
    public void NonAbMethod()
    {
        Console.WriteLine("Non-Abstract Method");
    }
    // 一个没有方法体的抽象方法
    public abstract void AbMethod(); 
}
class MyClass : MyAbs //非抽象基类继承抽象类时，基类必须实现抽象类中的抽象方法
{
    // 实现基类抽象方法 AbMethod
    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();
} 7 //基类为抽象类可以部分实现父类的抽象方法而不必实现所有抽象方法
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.不能在静态属性中使用abstract

　　*一个抽象属性能够通过派生类使用override实现

 

抽象类有以下特征：

1.抽象类不能被实例化

2.抽象类可以包含抽象方法和访问器

3.不能把抽象类用密封(sealed)来修饰，那就意味着类不能被继承，这违反抽象类被继承的原则。

4.派生于抽象类的非抽象类必须包括所有来自抽象类中的抽象方法的实现

5.在方法和属性中使用abstract 关键字意味着包含它们的实现