比如：A B C D E五个类 每个类都要实现一模一样的a b c d e方法
如果这五个方法加起来需要5k行代码。

那么如果你一个个去写 就需要5k*5=25k……

这个时候你就干脆写一个抽象类F 其中包含a b c d e五个方法
然后再A B C D E中继承抽象类F 所需要的就是5k+很少的继承语句 就省事和好维护得多

可以增加代码的重用性，可维护性

*抽象类与抽象方法
抽象类不能实例化，只有具体类才可以实例化
抽象类是一种特殊的类，它可以拥有数据成员，可以是其他类的子类，但它的某些行为故意给其子类来定义，这是因为抽象类不能够实例化。抽象类和抽象方法都使用abstract关键字来声明。

抽象类就是一些具有相同特征的类的一种类。就是类就是一些具有相同特征对象一样。游戏中貌似用得很多，个人观点。

用来提供基本的方法给派生类继承的!

1、声明一个抽象方法使用abstract关键字。
2、一个类中可以包含一个或多个抽象方法。
3、抽象类中可以存在非抽象的方法。
4、抽象类不能被直接被实例化。
5、实现抽象类用“:”（冒号），实现抽象方法用override关键字。
6、抽象类可以被抽象类所继承，结果仍是抽象类。
7、抽象方法被实现后，不能更改修饰符。
例子如下:
    public abstract class Person
    {
        public abstract void SayHello();
        public void about()
        {
            Console.WriteLine("Abstract Demo");
        }
    }

    public class Student : Person
    {
        public override void SayHello()
        {
            Console.WriteLine("SayHello");
        }
    }
    class MainClass
    {
        public static void Main()
        {
            new Student().SayHello();
        }
    }

希望对你有帮助

抽象类只能作为其他类的基类，而且在定义方法或属性的时候，我们只能写它的声明部分或者签名部分，而它的具体的实现内容需要，它的子类也就是继承它的类去实现，使用抽象类的好处是比较节省内存空间，其次就是可以确保该类被集成后，该方法或属性会被重写（对于初学者来说容易忘记），从我个人理解的技术角度出发的话，我认为使用抽象类的好处就是，有时候我们写一个类，比如是交通工具类，我们有个移动的方法，我们没有办法去写里面实现的内容，因为交通工具各种各样不知道具体的移动方法，所以我们必须用一个具体交通工具的类去继承原来的类，然后在该方法里可以实现具体的步骤，这也是面向对象编程和现实世界里很自然的表达...

楼上已经有人讲了抽象类的具体规则了，我就给你一个实际的例子把。
就拿中国移动来说，有：全球通，动感地带和神州行三种手机卡，它们的业务类型、计费方式、适用范围都不相同。
你可以写一个抽象类，来完成一个基础的模型，然后分别用三个类继承此类，使用抽象方法等技术来实现它们各自的细节，收费方式等等。
这样不仅锻炼了技术，还对于你自身的面向对象思维有很大的帮助。
希望你能够亲身去实践一下，不过有一定难度。加油吧！

怎么就没人提到抽象类用于多态呢！？？下面通过使用继承的多态（子类中有不同类型的人，年轻人和老年人等）来说明抽象类使用在多态中的好处：

1. 
   
2. //PersonStyle类是抽象地，它不表示特定的哪个类型的人，不打算实例化，而是作为不同类型人的祖先类，包含应用到的不同类型的人的信息，存储不同类型的变量在PersonStye类中声明，然后由子孙继承；
   
3. abstract class PersonStyle
   
4.     {
   
5. 
   
6.       
   
7.         /// <summary>
   
8.         /// 使用可见修饰符定义类成员，派生类将会继承它
   
9.         /// </summary>
   
10.        protected  string name;
    
11.        protected string category;
    
12. 
    
13. 
    
14. 
    
15.        public PersonStyle(string Name, string Category)
    
16.         {
    
17. 
    
18.             name = Name;
    
19.             category = Category;
    
20.             
    
21.             
    
22.         }
    
23.        /// <summary>
    
24.        /// 返回一个字符串包括人员的信息
    
25.        /// </summary>
    
26.        /// <returns></returns>
    
27.        public override string ToString()
    
28.        {
    
29.            string result = "Name:" + name + "\n";
    
30.            result  +="Category:"+category+"\n";
    
31.            return result;
    
32.        }
    
33. 
    
34.       /// <summary>
    
35.       /// 定义一个抽象方法可以为不同人(年轻人，老年人等)调用
    
36.       /// </summary>
    
37.       /// <returns></returns>
    
38.        public abstract string Re();
    
39. }

复制代码

1. class PersonMember
   
2.     {
   
3. 
   
4.         private PersonStyle[] personlist;
   
5.         public PersonMember()
   
6.         {
   
7.             
   
8.             //方法触发时引用指向的对象类型用来决定要触发哪个版本的方法
   
9.             personlist = new PersonStyle[2];
   
10.             personlist[0] = new OldPerson("steven", "老人");
    
11.             personlist[1] = new NewPerson("wifi", "少年", "运动");
    
12.         }
    
13.         public void SayHello()
    
14.         {
    
15.             string login;
    
16.             for (int count = 0; count < personlist.GetLength(0); count++)
    
17.             {
    
18.                 Console.WriteLine(personlist[count]);
    
19.                 Console.WriteLine();
    
20.                 login=personlist[count].Re();
    
21.                 Console.WriteLine(login);
    
22.             }
    
23.     }
    
24. }

复制代码

1. class OldPerson:PersonStyle
   
2.     {
   
3.       public OldPerson(string Name, string Category)
   
4.             :base(Name,Category  )
   
5.         {
   
6.             
   
7.         }
   
8. 
   
9.         
   
10.         public override string Re()
    
11.         {
    
12.             return ("重写抽象方法！\n");
    
13. 
    
14.       }
    
15. }

复制代码

1. class NewPerson:PersonStyle
   
2.     {
   
3.         private string hobby;
   
4. 
   
5.         /// <summary>
   
6.         /// base引用触发父类的构造函数        /// </summary>
   
7.         /// <param name="Name"></param>
   
8.         /// <param name="Category"></param>
   
9. 
   
10.         public NewPerson(string Name, string Category,string Hobby)
    
11.             :base(Name,Category  )
    
12.         {
    
13.             hobby =Hobby  ;
    
14.         }
    
15.         public override string ToString()
    
16.         {
    
17.             string result = base.ToString();
    
18.             result += "Hobby:" + hobby;
    
19.             return result;
    
20.         }
    
21.         /// <summary>
    
22.         /// 通过继承间接引用私有方法！         /// </summary>
    
23.         /// <returns></returns>
    
24.         private string Sleeping()
    
25.         {
    
26.             return ("\n私有方法间接引用！");
    
27.         }
    
28.         public override  string Re()
    
29.         {
    
30.             return (Sleeping());
    
31.         }
    
32.         
    
33.     }

复制代码

1. static void Main(string[] args)
   
2.         {
   
3.             PersonMember myperson = new PersonMember();
   
4.             myperson.SayHello();
   
5.             
   
6.            
   
7. 
   
8.             Console.ReadKey();
   
9.         }

复制代码

抽象类一般用于提供一个方法借口，然后在子类里去实现这个借口。。
举个例子：游戏中的角色有玩家，还有敌人，这两种角色都有一个方法Move，但是玩家和敌人的Move规则却不一样，这时候就可以定义一个抽象类People，然后定义Move方法。
接着分别从People派生出两个类：Player和Enemy，然后从这两个类中实现Move方法。