一个抽象类的子类也是一个抽象类可是抽象类又不能创建对象，我晕了abstract class Employee{
private String name;
private String id;
private double pay;
Employee(String name,String id ,double pay){
  this.name = name;
  this.id = id;
  this.pay = pay;
  }
public abstract void work();
}
abstract class Manager  extends Employee{
private int bonus;
Manager(String name ,String id ,double pay,int bonus){
  super(name,id,pay);
  this.bonus = bonus;
  public void work(){
   System.out.println("manger work");
   }
  }
}
abstract class Pro extends Employee {
Pro(String name,String id, double pay){
super(name, id , pay);
}
public void work(){
System.out.println("pro work");
}
}
public class Day7{
public static void main(String[] args){
Pro p = new Pro("zhangsan","008",8000.00);
}
不会调了。。。

我想你的代码中Employee应该是抽取出来的最终类吧。所以在代码中只有它使用abstract修饰成抽象类。所以该类是不能创建对象的。
而Manager、Employee是它的子类，继承了Employee，所以它们都得实现抽象类Employee中的抽象方法work。它们就可以成为普通类，所以是不需要用abstract修饰(你用abstract修饰了的话，它们就还是抽象类，所以是不能够创建对象的),可以直接创建对象并调用其方法。

1. abstract class Employee{
   
2.         private String name;
   
3.         private String id;
   
4.         private double pay;
   
5.         Employee(String name,String id ,double pay){
   
6.                 this.name = name;
   
7.                 this.id = id;
   
8.                 this.pay = pay;
   
9.         }
   
10.         public abstract void work();
    
11. }
    
12. 
    
13. class Manager  extends Employee{   //Manager不需要用abstract修饰，它的内部已经没有抽象方法了。
    
14.         private int bonus;
    
15.         Manager(String name ,String id ,double pay,int bonus){
    
16.                 super(name,id,pay);
    
17.                 this.bonus = bonus;
    
18.         }
    
19.         public void work(){
    
20.                 System.out.println("manger work");
    
21.    }
    
22. }
    
23. 
    
24. class Pro extends Employee {  //Pro也不需要用abstract修饰了；
    
25.         public Pro(String name,String id, double pay){
    
26.                 super(name, id , pay);
    
27.         }
    
28.         public void work(){
    
29.                 System.out.println("pro work");
    
30.         }
    
31. }
    
32. 
    
33. public class Test14{
    
34.         public static void main(String[] args){
    
35.                 Pro p = new Pro("zhangsan","008",8000.00); //创建对象；
    
36.                 p.work();  //调用其方法。
    
37.                 Manager man = new Manager("li", "007", 5000, 1000);
    
38.                 man.work();
    
39.                
    
40.         }
    
41. }
    

复制代码

子类一般不用再抽象了，直接把父类的方法实现即可。

父类是抽象的即可，因为父类是子类抽取出来的共同的功能，但是功能主体不同，所以父类用抽象的，但是子类就不用再抽象了，因为子类是具体实现这些功能的，即将父类中的函数进行复写，所以，子类不用用抽象了。

抽象类是不能创建对象 所以要调用就找他的实现非抽象子类 用子类来声明对象 然后再调用相应方法

抽象类没法加建立对象，抽象类的子类，如果没实现所有的方法还是抽象类的话也没法建立对象，所以你可以弄个子类把所有方法实现了