abstract表明一个类是不完整的，只能作为其他类的一个基类。

抽象类与非抽象类的不同之处有：

1.抽象类无法直接用例子说明，且在抽象类中不能使用操作符new。

2.抽象类允许(但不需要)含有抽象成员。

3.抽象类不能被密封(密封类不能被继承)。

当一个非抽象类是从一个抽象类派生而来时，该非抽象类一定包括所有被继承抽象成员的实际执行。这样的执行是通过使抽象成员无效而得到的。

----《C#编程思想》

在类定义前面放置abstract关键字，可以将类声明为抽象类。

EXAMPLE

public abstract class A{...};

使用abstract关键字可以创建必须在派生类中实现的不完整的类和类成员。

抽象类不能实例化。抽象类的用途是提供多个派生类可共享的基类的公共定义。

例如：类库可以定义一个作为其多个函数的参数的抽象类，并要求使用该库通过创建派生类来提供自己的类实现。

抽象类也可以定义抽象方法。将abstract关键字添加到方法的返回类型的前面。

EXAMPLE

public abstract class A

{

public abstract void AA(int num);

}

抽象方法没有实现，所以方法定义后面是分好，而不是方法块。

抽象类的派生类必须实现所有抽象方法。当抽象类从基类继承虚方法时，抽象类可以使用抽象方法重写该虚方法。

EXAMPLE

public class D

{

public virtual void DoWork(int i){}

}

public abstract class E:D

{

public abstract override void DoWork(int i);

}

public class F:E

{

public override void DoWork(int i)

{

    //new implementation

}

}

如果将virtual方法声明为abstract，则该方法对于从抽象类继承的所有类而言仍然是虚方法。

抽象继承方法的类无法访问该方法的原始实现。在此情况下，抽象类可以强制派生类为虚方法提供新的方法实现。

----《MSDN 抽象类、密封类及类成员》

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

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

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

派生类实现。

EXAMPLE

public abstract class A

{

    public abstract void FunctionA();

    public void FunctionB()

    {

        Console.WriteLine("FunctionB");

    }

}

public class B : A

{

    public override void FunctionA()

    {

        Console.WriteLine("override FunctionA");

    }   

}

public class C

{

    static void Main(string[] args)

    {

        B b1 = new B();

        b1.FunctionA();

        b1.FunctionB();

        Console.WriteLine("Press any key to exit...");

        Console.ReadKey();

    }

}

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

但是通过声明派生类也为抽象类，可以避免所有或特定的虚拟方法的实现。这就是抽象类的部分实现。

EXAMPLE

public abstract class A

{

    public abstract void FunctionA();

    public abstract void FunctionB();

}

public abstract class B : A

{

    public override void FunctionA()

    {

        Console.WriteLine("FunctionA");

    }

}

public class C : B

{

    public override void FunctionB()

    {

        Console.WriteLine("FunctionB");

    }

}

public class D

{

    static void Main(string[] args)

    {

        C c1 = new C();

        c1.FunctionA();

        c1.FunctionB();

        Console.WriteLine("Press any key to exit...");

        Console.ReadKey();

    }

}

C#中，一个抽象类可以继承非抽象类。并且，继承了基类的方法，添加新的抽象和非抽象方法是可行的。

EXAMPLE

public class A

{

    public void FunctionA()

    {

        Console.WriteLine("FunctionA");

    }

}

public abstract class B : A

{

    public abstract void FunctionB();

}

public class C : B

{

    public override void FunctionB()

    {

        Console.WriteLine("FunctionB");

    }

}

public class D

{

    static void Main(string[] args)

    {

        C c1 = new C();

        c1.FunctionA();

        c1.FunctionB();

        Console.WriteLine("Press any key to exit...");

        Console.ReadKey();

    }

}

一个抽象类也能从一个接口来实现，这种情况，必须为所有的方法提供方法体，这些方法是来自接口。

EXAMPLE

public interface I1

{

    void FunctionA();

}

public abstract class A : I1

{

    public void FunctionA()

    {

        Console.WriteLine("FunctionA");

    }

}

public class B : A

{

    public void FunctionB()

    {

        Console.WriteLine("FunctionB");

    }

}

public class C : B

{

    static void Main(string[] args)

    {

        B b1 = new B();

        b1.FunctionA();

        b1.FunctionB();

        Console.WriteLine("Press any key to exit...");

        Console.ReadKey();

    }

}

不能把关键字abstract和sealed一起使用，因为一个密封类不能够被抽象。

对于抽象类：

一个抽象类必须为所有的接口成员提供实现。

一个用于实现接口的抽象类可能把接口方法安排到抽象方法上。

EXAMPLE

interface I

{

void FunctionA();

}

abstract class : I

{

public abstract void FunctionA();

}