黑马程序员技术交流社区

标题: 抽象类一般怎么用？ [打印本页]
作者: lijun6459991    时间: 2011-12-15 20:43
提示: 作者被禁止或删除 内容自动屏蔽
作者: 许超    时间: 2011-12-16 08:24
比如：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+很少的继承语句 就省事和好维护得多

可以增加代码的重用性，可维护性
作者: 吴泉水    时间: 2011-12-16 08:40
*抽象类与抽象方法
抽象类不能实例化，只有具体类才可以实例化
抽象类是一种特殊的类，它可以拥有数据成员，可以是其他类的子类，但它的某些行为故意给其子类来定义，这是因为抽象类不能够实例化。抽象类和抽象方法都使用abstract关键字来声明。
作者: 朱勋    时间: 2011-12-16 10:36
抽象类就是一些具有相同特征的类的一种类。就是类就是一些具有相同特征对象一样。游戏中貌似用得很多，个人观点。
作者: 刘波    时间: 2011-12-19 15:38
用来提供基本的方法给派生类继承的!

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

希望对你有帮助
作者: 丰亚彬    时间: 2011-12-21 10:47
抽象类只能作为其他类的基类，而且在定义方法或属性的时候，我们只能写它的声明部分或者签名部分，而它的具体的实现内容需要，它的子类也就是继承它的类去实现，使用抽象类的好处是比较节省内存空间，其次就是可以确保该类被集成后，该方法或属性会被重写（对于初学者来说容易忘记），从我个人理解的技术角度出发的话，我认为使用抽象类的好处就是，有时候我们写一个类，比如是交通工具类，我们有个移动的方法，我们没有办法去写里面实现的内容，因为交通工具各种各样不知道具体的移动方法，所以我们必须用一个具体交通工具的类去继承原来的类，然后在该方法里可以实现具体的步骤，这也是面向对象编程和现实世界里很自然的表达...
作者: 朱磊    时间: 2011-12-30 12:27
楼上已经有人讲了抽象类的具体规则了，我就给你一个实际的例子把。
就拿中国移动来说，有：全球通，动感地带和神州行三种手机卡，它们的业务类型、计费方式、适用范围都不相同。
你可以写一个抽象类，来完成一个基础的模型，然后分别用三个类继承此类，使用抽象方法等技术来实现它们各自的细节，收费方式等等。
这样不仅锻炼了技术，还对于你自身的面向对象思维有很大的帮助。
希望你能够亲身去实践一下，不过有一定难度。加油吧！
作者: 傅涌钦    时间: 2011-12-30 22:53
怎么就没人提到抽象类用于多态呢！？？下面通过使用继承的多态（子类中有不同类型的人，年轻人和老年人等）来说明抽象类使用在多态中的好处：

  2. //PersonStyle类是抽象地，它不表示特定的哪个类型的人，不打算实例化，而是作为不同类型人的祖先类，包含应用到的不同类型的人的信息，存储不同类型的变量在PersonStye类中声明，然后由子孙继承；
  3. abstract class PersonStyle
  4.     {

  6.       
  7.         /// <summary>
  8.         /// 使用可见修饰符定义类成员，派生类将会继承它
  9.         /// </summary>
  10.        protected  string name;
  11.        protected string category;



  15.        public PersonStyle(string Name, string Category)
  16.         {

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

  34.       /// <summary>
  35.       /// 定义一个抽象方法可以为不同人(年轻人，老年人等)调用
  36.       /// </summary>
  37.       /// <returns></returns>
  38.        public abstract string Re();
  39. }
复制代码
  1. class PersonMember
  2.     {

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

  9.         
  10.         public override string Re()
  11.         {
  12.             return ("重写抽象方法！\n");

  14.       }
  15. }
复制代码
  1. class NewPerson:PersonStyle
  2.     {
  3.         private string hobby;

  5.         /// <summary>
  6.         /// base引用触发父类的构造函数        /// </summary>
  7.         /// <param name="Name"></param>
  8.         /// <param name="Category"></param>

  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.            

  8.             Console.ReadKey();
  9.         }
复制代码
作者: 王兴    时间: 2011-12-31 15:14
抽象类一般用于提供一个方法借口，然后在子类里去实现这个借口。。
举个例子：游戏中的角色有玩家，还有敌人，这两种角色都有一个方法Move，但是玩家和敌人的Move规则却不一样，这时候就可以定义一个抽象类People，然后定义Move方法。
接着分别从People派生出两个类：Player和Enemy，然后从这两个类中实现Move方法。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2