什么是抽象类、抽象方法呢？
跟我们平时说的类和方法由什么不一样呢？能举个例子说明一下最好···

抽象类和抽象方法的应用

    1> 如何实现抽象方法

       >当从一个抽象基类派生一个子类时，子类将继承基类的所有特征，包括它未实现的抽象方法。抽象方法必须在其子类中

        实现，除非它的子类也是抽象类。与子类重写父类的虚方法一样，在子类中实现一个抽象方法的方式也是使用override

        关键字来重写抽象方法。

       > 访问修饰符 override 返回类型 方法()

    2>抽象方法的应用举例

       //父类

       public abstract class FuLei

       {

             public abstract string ShowInfo();

       }

       //子类1

       class ZiLei_1:FuLei

         {

             public override string ShowInfo()

             {

                        return "我是子类_1";

             }

          }

       //子类2

       class ZiLei_2:FuLei

         {

             public override string ShowInfo()

             {

                        return "我是子类_2";

             }

          }

       //form里面

        public void show(FuLei fl)

        {

            MessageBox.Show(fl.ShowInfo());  

        }



        private void button1_Click(object sender, EventArgs e)

        {

            show(new ZiLei_1());

        }



        private void button2_Click(object sender, EventArgs e)

        {

            show(new ZiLei_2());

        }

    3> 抽象方法的应用场合

       >首先我们不希望它被实例化，因此抽象类提供抽象方法，要求继承它的子类去实现，它通过这些抽象方法来约束子类的

        行为

       >抽象方法和虚方法的区别

       虚方法                                            抽象方法

       -------------------------------------------------------------------------

       用virtual修饰                                用abstract修饰

       要有方法体，哪怕是一个分号    不允许有方法体

       可以被子类override                     必须被子类override      

       除了密封类外都可以写                只能在抽象类中写

抽象类，实际上就是对类的进一步抽象。在面向对象的分析和设计中有很多次抽象，从现实世界中的对象抽象出软件系统中的对象（保留主要属性和行为，去掉次要属性和行为），从软件系统中的对象抽象出软件系统中的类（去掉属性值，把具体的对象变成了抽象的概念），现在我们要介绍的抽象类是对多个类的抽象结果，抽象类中描述了多个具体类的共同特征和行为，与我们之前说的父类是类似，不同之处在于抽象类不能有具体的对象，抽象类可以有不用实现的方法。

抽象方法的含义：某个对象具有这样的方法，但是方法如何实现不清楚。比如各种交通工具都可以把乘客从一个地方带到另外一个地方，所以交通工具应该具有一个方法——移动，但是具体如何移动，不清楚，所以如果要在交通工具这个类中定义这个方法，只能是抽象的。意味着，交通工具应该有一个方法（移动），但是具体如何实现，需要看具体的子类。

学习ing~

如果一个类不与具体的事物相联系，而只是表达一种抽象的概念，仅仅是作为其派生类的一个基类，这样的类就是抽象类，在抽象类中声明方法时，如果加上abstract时就是抽象方法

1.抽象类概述及声明
抽象类与非抽象类的主要区别：
·抽象类不能直接被实例化
·抽象类中可以包含抽象成员，但非抽象类中不可以
·抽象类不能被密封
举个小例子

public abstract class oneClass
{
　　public int i；
　　public void denylau（）
　　{
　　}
}
2.抽象方法概述及声明

声明抽象方法时需注意：·抽象方法必须声明在抽象类中　　·声明抽象方法时，不能使用virtual、static、private修饰符。
在抽象类中抽象方法不提供实现。
如：
public abstract class myTestClass（）
{
　　public abstract void method（）；
}

3.抽象类与抽象方法的使用
例子：

using System;
using System.Collections.Generic;
using System.Text;

namespace _
{
    public abstract class myClass
    {
        private string id = "";
        private string name = "";
        /// <summary>
        /// 编号属性及实现
        /// </summary>
        public string ID
        {
            get
            {
                return id;
            }
            set
            {
                id = value;
            }
        }
        /// <summary>
        /// 姓名属性及实现
        /// </summary>
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
        /// <summary>
        /// 抽象方法，用来输出信息
        /// </summary>
        public abstract void ShowInfo();
    }
    public class DriveClass:myClass                     //继承抽象类
    {
        /// <summary>
        /// 重写抽象类中输出信息的方法
        /// </summary>
        public override void ShowInfo()
        {
            Console.WriteLine(ID + " " + Name);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            DriveClass driveclass = new DriveClass();   //实例化派生类
            myClass myclass = driveclass;               //使用派生类对象实例化抽象类
            myclass.ID = "BH0001";                      //使用抽象类对象访问抽象类中的编号属性
            myclass.Name = "TM";                        //使用抽象类对象访问抽象类中的姓名属性
            myclass.ShowInfo();                         //使用抽象类对象调用抽象类中的的抽象方法
        }
    }
}

抽象类，即在类声明前面加上abstract限定符。由于抽象类没有定义完整的实现，所以抽象类不创建任何对象。
抽象方法：使用abstract限定符能够创建抽象方法，抽象方法不包含方法体，在基类中它不实现任何操作。
例子：using System;
         using System.Collections.Generic;
         using System.Linq;
         using System.Text;  
         namespace   Test
        {
            abstract   class  Animal   //抽象类
             {
                  public  abstract  void  Shout();   //声明一个抽象方法
             }
        }
      


        class  Dog:Animal   //继承基类
        {
            public override void  Shout()   //重写方法
            {
                Console.WriteLine("这是狗的叫法：汪汪");
            }
        }

        class Program
        {
            static void Main(string[]args)
             {
                  Dog dog=new Dog()  //实例化派生类

                  dog.Shout();//调用抽象类中的的抽象方法

                 Console.Readkey();
             }
        }
   

   

抽象类

        有时候, 基类并不与具体的事物相联系, 而只是表达一种抽象的概念, 用以 为他的派生类提供一个公共的界面, 为此 , C#中引入了抽象类 (abstract class) 的概念.
        抽象类使用 abstract 修饰符, 对抽象类的使用有以下几点规定:
•        抽象类只能作为其他类的基类, 他不能被实例化, 而且对抽象类不能使用 new 操作符, 抽象类如果含有抽象的变量或值, 则他们要么是 null 类型, 要么包含了对非抽象类的实例的引用.
•        抽象类允许包含抽象成员, 虽然这不是必须的.
•        抽象类不能同时又是密封的.

        如果一个非抽象类从抽象类中派生, 则必须通过重载来实现所有继承而来的抽象成员.

        abstract class A
        {
                public abstract void F();
        }
        abstract class B : A
        {
                public void G() { }
        }
        class C : B
        {
                public override void F ()
                {
                        //  F的具体实现代码
                }
        }       

        抽象类 A 提供了一个抽象方法 F(), 抽象类 B 从抽象类 A 中继承, 并且又提供了一个实例方法 G(), 因为 B 中并没有包含对 F()方法的实现, 所以 B 也必须是抽象类, 类 C 从类 B 中继承, 类中重载了抽象方法 F() , 并且提供了对 F() 的具体实现, 则类 C 允许是非抽象的.

抽象方法

                由于抽象类本身表达的是抽象的概念, 因此类中的许多方法并不一定要有具体的实        现, 而只是留出一个接口来作为派生类重载的界面.
                一个方法声明中如果加上 abstract 修饰符, 我们称该方法为抽象方法(abstract         method).
                如果一个方法被声明为抽象的, 那么该方法默认也是一个虚方法,  事实是, 抽象方        法是一个新的虚方法, 他不提供具体的方法实现代码, 我们知道, 非虚的派生类要求通过重        载为继承的虚方法提供自己的实现, 而抽象方法则不包含具体的实现内容, 所以方法声明        的执行体中只有一个分号  ";" .

       
                只能在抽象类中声明抽象方法, 对抽象方法, 不能在使用 static 或 virtual 修饰符,        而且方法不能有任何可执行代码, 只需要给出方法的原型就可以了.


using System;

abstract class Vehicle
{
        public int wheels;
        public int weight;
        public Vehicle(){}
        public Vehicle(int wheels,int weight)
        {
                this.wheels=wheels;
                this.weight=weight;
        }
        public abstract void Speak();
}
class Car : Vehicle
{
        public int passengers;
        public Car(int wheels,int weight,int passengers):base(wheels,weight)
        {
                this.wheels=wheels;
                this.weight=weight;
                this.passengers=passengers;
        }
        public override void Speak()
        {
                Console.WriteLine("the car Di-Di");
        }
}
class Truck : Vehicle
{
        public int load;
        public Truck(int wheels,int weight,int load):base(wheels,weight)
        {
                this.wheels=wheels;
                this.weight=weight;
                this.load=load;
        }
        public override void Speak()
        {
                Console.WriteLine("the truck Ba-Ba");
        }
}
class Program
{
        static void Main()
        {
                Car c=new Car(4,3,5);
                c.Speak();
                Truck t=new Truck(10,5,50);
                t.Speak();
        }
}


        抽象方法在派生类中不能使用 base 关键字来进行访问, 例如,下面的代码在编译时会出错

        abstract class A
        {
                public abstract void F();
        }
        class B : A
        {
                public override void F()
                {
                        base.F();    //错误,  base.F()  是抽象方法
                }
        }

        还可以利用抽象方法来重载基类的虚方法, 这是基类中虚方法的执行代码就被"拦截"了.
       
        class A
        {
                public virtual void F()
                {
                        Console.WriteLine("A.F()");
                }
        }
        abstract class B : A
        {
                public abstract override void F();
        }
        class C : B
        {
                public override void F()
                {
                        Console.WriteLine("C.F()");
                }
        }

                类 A 声明了一个虚方法 F(), 派生类 B 使用抽象方法重载了 F(),  这样 B 的派生类 C 就可以重载 F() 并提供自己的实现.

抽象类不能实例化，抽象方法不能在抽象类中实现。从字面意思去理解，抽象的就表示不是具体的、模糊的。在实际应用中，当多个类有共同点时，可以通过继承自一个抽象类来实现多态或者减少代码。

·抽象类不能直接被实例化

·抽象类中可以包含抽象成员，但非抽象类中不可以

·抽象类不能被密封

举个小例子

public abstract class oneClass

{

　　public int i；

　　public void denylau（）

　　{

　　}

}
声明抽象方法时，不能使用virtual、static、private修饰符。

在抽象类中抽象方法不提供实现。
如
public abstract class myTestClass（）

{
　　public abstract void method（）
}