是否可以省略父类中的抽象方法，直接在子类中新增该方法呢

Question

   在研究到抽象类的时候突然有个想法，为什么必须要用抽象类呢，不会直接用普通的继承关系不就行了吗？为什么要定义一个抽象类，在抽象类中定义抽象方法，然后在子类中实现具体方法。
   但是在普通的父类子类的继承中，不是子类可以扩展父类的方法吗？那样的话我不是可以不要用抽象类了？
   是不是抽象类中的抽象方法是多此一举呢？直接在子类中扩展不是一样嘛。如下例子：import java.text.*;
import java.util.*;public class PersonTest
{  
   public static void main(String[] args)
   {  
      Person[] people = new Person[2];      // fill the people array with Student and Employee objects
      people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
      people[1] = new Student("Maria Morris", "computer science");      // print out names and descriptions of all Person objects
      for (Person p : people)
         System.out.println(p.getName() + ", " + p.getDescription());
   }
}abstract class Person
{  
   public Person(String n)
   {  
      name = n;
   }   public abstract String getDescription();   public String getName()
   {  
      return name;
   }   private String name;
}class Employee extends Person
{  
   public Employee(String n, double s,
      int year, int month, int day)
   {  
      super(n);
      salary = s;
      GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);
      hireDay = calendar.getTime();
   }   public double getSalary()
   {  
      return salary;
   }   public Date getHireDay()
   {  
      return hireDay;
   }   public String getDescription()
   {  
      return String.format("an employee with a salary of $%.2f", salary);
   }   public void raiseSalary(double byPercent)
   {  
      double raise = salary * byPercent / 100;
      salary += raise;
   }   private double salary;
   private Date hireDay;
}
class Student extends Person
{  
   /**
      @param n the student's name
      @param m the student's major
   */
   public Student(String n, String m)
   {  
      // pass n to superclass constructor
      super(n);
      major = m;
   }   public String getDescription()
   {  
      return "a student majoring in " + major;
   }   private String major;
}
-------------------------------
改成这样不是一样正常运行吗？
/**
   @version 1.01 2004-02-21
   @author Cay Horstmann
*/import java.text.*;
import java.util.*;public class PersonTest1
{  
   public static void main(String[] args)
   {  
      Person[] people = new Person[2];      // fill the people array with Student and Employee objects
           people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
       
    
       people[1] = new Student("Maria Morris", "computer science");
              // print out names and descriptions of all Person objects
      for (Person p : people)
         System.out.println(p.getName() + ", " + p.getDescription());  
      
   } 
} class Person
{  
   public Person(String n)
   {  
      name = n;
   }
 
   public String getDescription()
   {  
      return "hello person ";
   }
  
   public String getName()
   {  
      return name;
   }   private String name;
}class Employee extends Person
{  
   public Employee(String n, double s,
      int year, int month, int day)
   {  
      super(n);
      salary = s;
      GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);
      hireDay = calendar.getTime();
   }   public double getSalary()
   {  
      return salary;
   }   public Date getHireDay()
   {  
      return hireDay;
   }   public String getDescription()
   {  
      return String.format("an employee with a salary of $%.2f", salary);
   }   public void raiseSalary(double byPercent)
   {  
      double raise = salary * byPercent / 100;
      salary += raise;
   }   private double salary;
   private Date hireDay;
}
class Student extends Person
{  
   /**
      @param n the student's name
      @param m the student's major
   */
   public Student(String n, String m)
   {  
      // pass n to superclass constructor
      super(n);
      major = m;
   }   public String getDescription()
   {  
      return "a student majoring in " + major;
   }   private String major;
}

Answer 1

这样可以更好的解藕.
如果你修改了接口或抽象类中的方法,
在其他使用的地方就可以不修改了.

Answer 2

晕.应该加强你的"面向接口编程"的习惯.
其优点:
1.很好的限制性.抽象类标识其子类的共有特性和必须实现的方法.2.很好的多态性.可以变化为任何他的子类.3.很好的扩展性.子类可以有其自己本身的属性,方法.

Answer 3

但是普通的父类，子类继承关系也具备这些优点啊

Answer 4

想法是好的，但是存在必有他的意义。。
当代码量到一定程度的时候，就自然会明白了。

Answer 5

父类中的抽象方法的意义,近似于接口,它定义的一组规范、标准.给你举个例子：像电脑的主板，一块主板有很多个接口，它是如何实现，任何品牌的键盘、鼠标……等等,一些外设的硬件插上就可以用呢？就是采用了接口和抽象方法，主板厂商只需要把他定义好的接口和抽象方法公布出来，那些厂商就通过重写这些方法实现自已并且有特色的厂品了。