A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© yan 中级黑马   /  2013-8-4 19:01  /  1492 人查看  /  2 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

例:
abstract class Animal
{
       
        String name;
        String color;

        public void sleep()
        {
                System.out.println(name+"打呼噜.....");
        }
        public abstract void eat();
       
}
class Dog extends Animal
{
        public void eat()
        {
                System.out.println(name+"骨头.....");
        }
        public void lookHome()
        {
                System.out.println(name+"看家.....");
        }
       
}

class Cat extends Animal
{
        public void eat()
        {
                System.out.println(name+"鱼头.....");
        }
        public void catchMouse()
        {
                System.out.println(name+"抓老鼠.....");
        }
}


class AbstractDemo1
{
        public static void main(String[] args)
        {
                 Cat c = new Cat();

                 c.name="kitty";
                 c.color="花猫";

                 c.eat();
                 c.catchMouse();
                 c.sleep();


                 Dog d = new Dog();
                 d.name="旺财";
                 d.color="黑色";
                 d.eat();
                 d.lookHome();
                 c.sleep();
        }
}

抽象类里的方法子类里面具体化了,
就等于是子类的方法覆盖了抽象类里的方法,那么这个方法应该就相当于子类的个性
抽象类里面为什么抽象类里还要定义这个抽象的方法,
这样不想当于重复了吗?浪费空间,抽象不就是可有可无了吗?一直不能转过这个弯,希望能得到详细的回答

2 个回复

倒序浏览
抽象类里边定义抽象方法目的就是为了让子类去实现,因为子类可能对于同一个方法的实现内容会不一样,比如说学生类里边有个学习的方法,但小学生,初中生,高中生,大学生虽然都是学生类的子类,但他们学习的内容显然不相同,这样父类里边有学习这个方法,却无法具体实现,只能由其子类根据自己的需要来实现。至于你所说的抽象方法定义的多余,浪费空间,这个根本不是设计抽象类的重点,抽象类的出现是为了简化编程,缩短代码,其实就是为了多态,还能方便与程序的扩展。尤其是使用父类引用指向子类对象这种用法(这就是多态),非常有利与缩短代码,编写程序。下边的这个例子就是一个证明。
  1. class Student        //学生类的父类
  2. {
  3.         String name;                //姓名
  4.         int age;                        //年龄

  5.         //学习方法
  6.         public void study()
  7.         {

  8.         }

  9.         //度假方法
  10.         public void goVacation()
  11.         {

  12.         }

  13.         //自我介绍方法
  14.         public void introduce()
  15.         {
  16.                 System.out.println("我叫"+name+",我今年"+age+"岁!");
  17.         }
  18. }

  19. class BaseStudent extends Student
  20. {
  21.         BaseStudent(String name,int age)
  22.         {
  23.                 this.name = name;
  24.                 this.age = age;
  25.         }

  26.         //重写父类的study()方法
  27.         public void study()
  28.         {
  29.                 System.out.println("base study");
  30.         }

  31.         //重写父类的度假方法
  32.         public void goVacation()
  33.         {
  34.                 System.out.println("BaseStudent go vacation");
  35.         }
  36. }

  37. class AdvStudent extends Student
  38. {
  39.         AdvStudent(String name ,int age)
  40.         {
  41.                 this.name = name;
  42.                 this.age = age;
  43.         }

  44.         //重写父类的study()方法
  45.         public void study()
  46.         {
  47.                 System.out.println("advance study");
  48.         }

  49.         //重写父类的度假方法
  50.         public void goVacation()
  51.         {
  52.                 System.out.println("AdvStudent go vacation");
  53.         }
  54. }
  55. class  ExtendsDemo
  56. {
  57.         public static void main(String[] args)
  58.         {
  59.                 Student s1 = new BaseStudent("李四",20);
  60.                 Student s2 = new AdvStudent("张三",21);

  61.                 stuDoSomething(s1);
  62.                 stuDoSomething(s2);
  63.         }

  64.         //定义方法让学生做事
  65.         public static void stuDoSomething(Student s)
  66.         {
  67.                 s.introduce();
  68.                 s.study();
  69.                 s.goVacation();
  70.         }
  71. }
复制代码
而如果要是没有这种多态性,main函数里边调用子类就要这样写
  1. public static void main(String[] args)
  2.         {
  3.                 BaseStudent s1 = new BaseStudent("李四",20);
  4.                 AdvStudent s2 = new AdvStudent("张三",21);

  5.                 s1.introduce();
  6.                 s1.study();
  7.                 s1.goVacation();

  8.                 s2.introduce();
  9.                 s2.study();
  10.                 s2.goVacation();
复制代码
这样的话由多态情况下的每个对象只需要一句调用变成了没有多态情况下的3句调用,这样程序会显得非常繁琐,如果创建的子类对象更多,代码将会变得非常臃肿,而多态情况下这种情况会得到大大的好转!

希望能帮助楼主理解抽象类的作用以及应用!
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马