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

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

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

1. class Student        //学生类的父类
   
2. {
   
3.         String name;                //姓名
   
4.         int age;                        //年龄
   
5. 
   
6.         //学习方法
   
7.         public void study()
   
8.         {
   
9. 
   
10.         }
    
11. 
    
12.         //度假方法
    
13.         public void goVacation()
    
14.         {
    
15. 
    
16.         }
    
17. 
    
18.         //自我介绍方法
    
19.         public void introduce()
    
20.         {
    
21.                 System.out.println("我叫"+name+",我今年"+age+"岁!");
    
22.         }
    
23. }
    
24. 
    
25. class BaseStudent extends Student
    
26. {
    
27.         BaseStudent(String name,int age)
    
28.         {
    
29.                 this.name = name;
    
30.                 this.age = age;
    
31.         }
    
32. 
    
33.         //重写父类的study()方法
    
34.         public void study()
    
35.         {
    
36.                 System.out.println("base study");
    
37.         }
    
38. 
    
39.         //重写父类的度假方法
    
40.         public void goVacation()
    
41.         {
    
42.                 System.out.println("BaseStudent go vacation");
    
43.         }
    
44. }
    
45. 
    
46. class AdvStudent extends Student
    
47. {
    
48.         AdvStudent(String name ,int age)
    
49.         {
    
50.                 this.name = name;
    
51.                 this.age = age;
    
52.         }
    
53. 
    
54.         //重写父类的study()方法
    
55.         public void study()
    
56.         {
    
57.                 System.out.println("advance study");
    
58.         }
    
59. 
    
60.         //重写父类的度假方法
    
61.         public void goVacation()
    
62.         {
    
63.                 System.out.println("AdvStudent go vacation");
    
64.         }
    
65. }
    
66. class  ExtendsDemo
    
67. {
    
68.         public static void main(String[] args)
    
69.         {
    
70.                 Student s1 = new BaseStudent("李四",20);
    
71.                 Student s2 = new AdvStudent("张三",21);
    
72. 
    
73.                 stuDoSomething(s1);
    
74.                 stuDoSomething(s2);
    
75.         }
    
76. 
    
77.         //定义方法让学生做事
    
78.         public static void stuDoSomething(Student s)
    
79.         {
    
80.                 s.introduce();
    
81.                 s.study();
    
82.                 s.goVacation();
    
83.         }
    
84. }
    

复制代码

而如果要是没有这种多态性，main函数里边调用子类就要这样写

1. public static void main(String[] args)
   
2.         {
   
3.                 BaseStudent s1 = new BaseStudent("李四",20);
   
4.                 AdvStudent s2 = new AdvStudent("张三",21);
   
5. 
   
6.                 s1.introduce();
   
7.                 s1.study();
   
8.                 s1.goVacation();
   
9. 
   
10.                 s2.introduce();
    
11.                 s2.study();
    
12.                 s2.goVacation();

复制代码

这样的话由多态情况下的每个对象只需要一句调用变成了没有多态情况下的3句调用，这样程序会显得非常繁琐，如果创建的子类对象更多，代码将会变得非常臃肿，而多态情况下这种情况会得到大大的好转！

希望能帮助楼主理解抽象类的作用以及应用！