抽象类（abstract）

abstract修饰符可以和类、方法、属性、索引器及事件一起使用。在类声明中使用abstract修饰符以指示某个类只能是其它类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。

è     抽象类不能实例化

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

è     不能用sealed修饰符修改抽象类，这意味着抽象类不能被继承

è     从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实现

看一段代码：

using System ;

abstract class A

{

    protected int _x;

    public abstract void F();

    public abstract int X

    {

       get;set;

    }

}

class B:A

{

    public override void F()

    {

    }

    public override int X

    {

       get

       {

           return _x;

       }

       set

       {

           _x=value ;

       }

    }

}

class Test

{

    static void Main()

    {

       B b=new B ();

       b.X = 10;

       Console .WriteLine (b.X );

    }

}

->抽象方法是隐式的虚方法

->只允许在抽象类中使用抽象方法声明

->因为抽象方法声明不提供实际的实现，所以没有方法体；方法声明只是以一个分号结束，并且在签名后没有大括号（｛｝），实现由一个重写方法提供，此重写方法是非抽象类的成员。

->在抽象方法声明中使用static或virtual修饰符是错误的。

->除了在声明和调用语法上不同外，抽象属性的行为与抽象方法一样。

->在静态属性上使用abstract修饰符是错误的。

->在派生类中， 通过包括使用override修饰符的属性声明，可以重写抽象的继承属性。

抽象类的构造函数：

任何情况下，抽象类都不应进行实例化，因此，正确定义其构造函数就非常重要。确保抽象类功能的正确性和扩展性也很重要。下列准则有助于确保抽象类能够正确地设计并在实现后可以按预期方式工作。

->不要在抽象类型中定义公共的或受保护的内部构造函数，具有public或protected internal可见性的构造函数用于能进行实例化的类型。任何情况下抽象类型都不能实例化。

->应在抽象类中定义一个受保护（protected）构造函数或内部（private）构造函数。

->如果在抽象类中定义一个受保护构造函数，则在创建派生类的实例时，基类可执行初始化任务。

再看一段代码：

using System ;

abstract class Employee

{

    protected string _name;

    protected Employee () {}

    protected Employee (string name)

    {

       _name = name ;

    }

    public abstract void StartWork();

}

class Manager:Employee

{

    public Manager (string name):base (name){}

    public override void StartWork()

    {

       //base .StartWork ();

       Console .WriteLine (_name +"??′?è???");

    }

}

class Seller:Employee

{

    public Seller (string name):base (name){}

    public override void StartWork()

    {

       //base .StartWork ();

       Console .WriteLine (_name +"?úê?2ú?·");

    }

}

class Test

{

    static void Main()

    {

       Employee [] emp = new Employee[2] ;

       emp [0]=new Manager ("??èy");

       emp [1]=new Seller ("à???");

       foreach (Employee e in emp )

       {

           e.StartWork ();

       }

    }

}

当所有的子类都要实现一些共同的功能的时候，这时顷向于使用虚方法，我们可以把这些共同的功能定义在基类中，子类通过base调用。如果所有子类的方法各不相干，则使用抽象方法。

抽象方法和虚拟方法的区别：

->抽象方法和虚拟方法的区别在于： 虚拟方法有一个实现部分，并为派生类提供了覆盖该方法的选项，相反，抽象方法没有提供实现部分，强制派生类覆盖方法（否则派生类不能成为具体类）。

->abstract方法只能在抽象类中声明，虚方法则不是。

->abstract方法必须在派生类中重写，而virtual则不必

->abstract方法不能声明方法实体， 虚方法则可以、

->包含abstract方法的类不能被实例化，而包含virtual的类则可以。