C#的抽象类

       参考：http://www.cnblogs.com/HQFZ/p/4714686.html 、http://www.cnblogs.com/flyinthesky/archive/2008/06/18/1224774.html  和 http://www.cnblogs.com/blsong/archive/2010/08/12/1798064.html  三篇大作。

       面向对象的三大特性是：封装、继承和多态。这三个特性不必多说，说说abstracct和virtual这些概念。在C#中声明方法时，需要为其指定修饰符，以指定其访问级别或使用限制。C# 中常用的修饰符有private、public、protected、internal共4个访问修饰符和partial、new、static（静态函数）、virtual（虚拟函数）、override（重载函数）、sealed（密封函数，不能被继承）、abstract（抽象类或抽象函数，指示某个类只能是其他类的基类）、extern等8个声明修饰符。

一、abstract

      关键字 abstract 来定义抽象类和抽象方法。不能初始化的类被叫做抽象类，它们只提供部分实现，但是另一个类可以继承它并且能创建它们的实例。

（1）一个抽象类可以只包含非抽象方法；抽象类本身不能实例化，但是它毕竟是一个特殊的基类，本质的目的还是重用，所以还是可以正常实现“非抽象方法”，并指定public等访问修饰符。

    abstract class MyAbs     
    {
        public void NonAbMethod()
        {
            Console.WriteLine("Non-Abstract Method");
        }
    }

    class MyClass : MyAbs
    {
        //没有需要override的抽象方法
    }

    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'
        }
    }

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

    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();
        }
    }

（3）抽象类的部分实现：当抽象类的成员比较多的时候，我们可以避免所有或特定的虚方法的实现，方法是通过声明派生类也为抽象类。 

    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()   //继承抽象类MyClass1的时候，同时也继承了MyClass1的父类，此时就必须实现全部的抽象方法了。
        {
            Console.WriteLine("Abstarct method #2");
        }
    }

    class MyClient
    {
        public static void Main()
        {
            MyClass mc = new MyClass();
            mc.AbMethod1();
            mc.AbMethod2();
        }
    }

 （4）在C#中，一个抽象类能够继承另一个“非抽象类”，另外，继承了基类的方法，添加新的抽象和非抽象方法是可行的。其实这一点比较好理解，毕竟抽象类允许存在“非抽象方法”，即正常的方法，那么当然可以从其他途径继承过来。

（5）一个抽象类也能从一个接口来实现，这种情况，我们必须为所有的方法提供方法体，这些方法是来自接口。【其实第1、4、5的特性说明抽象类本质属性就是为重用而生的】。

    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();
        }
    }

（6）一个抽象类必须为所有的接口成员提供实现，一个用于实现接口的抽象类可能把接口方法安排到抽象方法上。

    interface I 
    {
      void M();
    }

    <span style="color:#33ff33;">abstract</span> class C: I 
    {
       public <span style="color:#33ff33;">abstract</span> void M();
    }

抽象方法有以下特征：

1.一个抽象方法可以看作是一个虚函数。

2.抽象方法的声明只能在抽象类中。

3.因为抽象方法声明只提供一个无实现的方式，没有方法体

4.方法体的实现被覆写方法提供，覆写方法是一个非抽象类的成员。

5.抽象属性的行为和抽象方法相像，除了不同的声明形式。

6.在一个静态属性中使用abstract 是一个错误。

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

抽象类具有以下特征：

1.抽象类不能被实例化。

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

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

4.一个派生于一个抽象类的非抽象类必须包括所有的继承来的抽象方法和访问器的实现。

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

二、virtual

虚函数是在C#中实现多态的一种方法，你要在子类中对override 关键字修饰要实现的虚方法，父类要使用Vritual关键字。

    class Shape 
    {
        public virtual void Draw()
        { 
            Console.WriteLine("Shape.Draw"); 
        } 
    }

    class Rectangle : Shape 
    {
        public override void Draw() 
        {
            Console.WriteLine("Rectangle.Draw"); 
        }
    }

二、Abstract和Virtual 的区别

      在C#的学习中，容易混淆virtual方法和abstract方法的使用，现在来讨论一下二者的区别。二者都牵涉到在派生类中与override的配合使用。  

abstract:声明抽象类、抽象方法
1.抽象方法所在类必须为抽象类
2.抽象类不能直接实例化，必须由其派生类实现。
3.抽象方法不包含方法主体，必须由派生类以override方式实现此方法,这点跟interface中的方法类似

virtual:标记方法为虚方法
1.可在派生类中以override覆盖此方法
2.不覆盖也可由对象调用
3.无此标记的方法(就是正常方法)，重写时需用new隐藏原方法
【abstract 与virtual : 方法重写时都使用 override 关键字】

      参考：http://www.cnblogs.com/blsong/archive/2010/08/12/1798064.html

   public abstract class Book
   {
     public Book()
     {
     }
     public abstract void getPrice(); //抽象方法，不含主体
     public virtual void getName() //虚方法，可覆盖
     {
       Console.WriteLine("this is a test:virtual getName()");
     }
     public virtual void getContent() //虚方法，可覆盖
     {
       Console.WriteLine("this is a test:virtual getContent()");
     }
     public void getDate() //一般方法，若在派生类中重写，须使用new关键字
     {
       Console.WriteLine("this is a test: void getDate()");
     }
   }
   

   public class JavaBook:Book
   {
      public override void getPrice() //实现抽象方法，必须实现
      {
        Console.WriteLine("this is a test:JavaBook override abstract getPrice()");
      }
      public override void getName() //覆盖原方法，不是必须的
      {
        Console.WriteLine("this is a test:JavaBook override virtual getName()");
      }
   }
   测试如下：
   public class test
   {
      public test()
      {
        JavaBook jbook=new JavaBook();
        jbook.getPrice(); //将调用JavaBook中getPrice()
        jbook.getName(); //将调用JavaBook中getName()
        jbook.getContent(); //将调用Book中getContent()
        jbook.getDate(); //将调用Book中getDate()
   }
   public static void Main()
   {
     test t=new test();
   }