一、解释1

在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 关键字意味着包含它们的实现。

二、解释2

//抽象方法：只包含方法定义，但没有具体实现的方法，需要其子类或者子类的子类来具体实现。
//静态方法不能标记为 override、virtual 或 abstract,即静态方法都必须是具体的
/抽象类：含有一个或多个抽象方法的类称为抽象类，在声明时，类名前须添加"abstract"关键字
//抽象类中可以包含非抽象方法
//抽象类不能够被实例化，这是因为它包含了没有具体实现的方法，即可实例化的类一定不是抽象类，不包含未具体实现的抽象方法。
//子类继承抽象父类后，可以使用override关键字覆盖父类中的抽象方法，并做具体的实现。也可以不实现抽象方法，留给后代实现，这时子类仍旧是一个抽象类，必须声明为abstract
//继承的抽象方法不可以被隐藏
//隐藏：在子类中创建与父类中的方法具有相同签名（相同的方法名，相同的参数列表--参数类型和次序）的方法(可以带有"virtual"或"override"关键字)即可实现，但建议使用"new"关键字,以明确地隐藏。
//只能使用"override"关键字来覆盖(override)父类中标记为"virtual"、"abstract"或"override"的方法,而子类中标记为override的方法，也必须是父类中标记为"virtual"、"abstract"或"override"的方法。
//覆盖(override):必须使用override关键字，可以被覆盖的方法包括标记为abstract,virtual,和override的方法；
//隐藏:使用new关键字，也可不使用关键字，可以被隐藏的方法包括一般方法，和标记为virtual"或"override"的方法；
//重载(overload)：不需要任何特殊的关键字
//静态方法可以被隐藏或重载

三、解释3

1、声明一个抽象方法使用abstract关键字。2、一个类中可以包含一个或多个抽象方法。3、抽象类中可以存在非抽象的方法。4、抽象类不能被直接被实例化。5、实现抽象类用“:”（冒号），实现抽象方法用override关键字。6、抽象类可以被抽象类所继承，结果仍是抽象类。7、抽象方法被实现后，不能更改修饰符。

using System;

namespace Abstract_for
{

/// <summary>
/// 抽象类 Abc
/// </summary>
abstract class Abc
{
public abstract void Afunc();//声明了抽象方法,但不实现

public void Bfunc()
{
Console.WriteLine("非抽象方法!");
}
}

/// <summary>
/// 抽象类Abc的派生类Derv
/// </summary>
class Derv:Abc
{//此类必须实现基类的抽象方法,否则必须声明为abstract的
public override void Afunc()
{//使用override关键字可以在派生类中实现抽象方法!通过override声明重写的方法成为重写基类方法
Console.WriteLine("实现抽象方法");
}
}
public class Test{
public static void Main(string[] args)
{
Derv d = new Derv();
d.Afunc();
d.Bfunc();
}
}

}

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

抽象类 用abstract 形容的 抽象类不能被实例化，只能被继承 举例说明 //抽象类 abstract class 画图类 { public void 画图 {} } //继承类 class 画三角类 ：画图类 { public void 画图 { //实现画三角的方法 } //继承类 class 画圆类 ：画图类 { public void 画图 { //实现画圆的方法 } } ok ! 画图类 paint1 = new 画三角类() ; paint1.画图();//画三角 画图类 paint2 = new 画圆类() ; paint2.画图();//画圆

转自：http://www.cnblogs.com/cuishao1985/archive/2009/12/30/1636190.html