/*假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。
员工类：name id pay
经理类：继承了员工，并有自己特有的bonus。
*/

1. [code]class Employee
   
2. {
   
3. private String name;
   
4. private String id;
   
5. private double pay;
   
6. Employee(String name,String id,double pay)
   
7. {
   
8. this.name = name;
   
9. this.id = id;
   
10. this.pay = pay;
    
11. }
    
12. public abstract void work();//抽象方法
    
13. }
    
14. class Manager extends Employee
    
15. {
    
16. private int bonus;
    
17. Manager(String name,String id,double pay,int bonus)
    
18. {
    
19. super(name,id,pay);
    
20. this.bonus = bonus;
    
21. }
    
22. public void work()
    
23. {
    
24. System.out.println("manager work");
    
25. }
    
26. }
    
27. class Pro extends Employee
    
28. {
    
29. Pro(String name,String id,double pay)
    
30. {
    
31. super(name,id,pay);
    
32. }
    
33. public void work()
    
34. {
    
35. System.out.println("pro work");
    
36. }
    
37. }
    
38. class AbstractTest
    
39. {
    
40. public static void main(String[] args)
    
41. {
    
42. Manager m = new Manager("wp","as",1.10,1);
    
43. m.work();
    
44. }
    
45. }

复制代码

[img]file:///C:/Documents%20and%20Settings/wangpeng/Application%20Data/Tencent/Users/1198571320/QQ/WinTemp/RichOle/A_%7B%7DGZ[13U%60B47@QDGVFC)V.jpg[/img]
为什么编译不能通过?该怎么改代码才可以实现输出预定结果呢？

package mypack1;
abstract class Employee        //前面加上 abstract 因為你的类中有抽象方法，所以你的类也必须是抽象的。

{
        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();// 抽象方法

}

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("manager work");

        }

}

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 AbstractTest //前面加上 public

{

        public static void main(String[] args)

        {

                Manager m = new Manager("wp", "as", 1.10, 1);

                m.work();

        }

}

在你的Employee类中有一个抽象的方法，因此需要在类上面声明。另外经理应该继承的是Pro而不是Employee。具体的请看代码，看了你就明白了

1. abstract class Employee        //内中有抽象方法，必须要在类上声明。
   
2. {
   
3.         private String name;
   
4.         private String id;
   
5.         private double pay;
   
6. 
   
7.         Employee(String name,String id,double pay)
   
8.         {
   
9.                 this.name = name;
   
10.                 this.id = id;
    
11.                 this.pay = pay;
    
12.         }
    
13. 
    
14.         public abstract void work();//抽象方法
    
15. }
    
16. 
    
17. class Manager extends Pro        //经理应该继承的是员工，不是雇员。
    
18. {
    
19.         private int bonus;
    
20. 
    
21.         Manager(String name,String id,double pay,int bonus)
    
22.         {
    
23.                 super(name,id,pay);
    
24.                 this.bonus = bonus;
    
25.         }
    
26. 
    
27.         public void work()
    
28.         {
    
29.                 System.out.println("manager work");
    
30.         }
    
31. }
    
32. class Pro extends Employee
    
33. {
    
34.         Pro(String name,String id,double pay)
    
35.         {
    
36.                 super(name,id,pay);
    
37.         }
    
38. 
    
39.         public void work()
    
40.         {
    
41.                 System.out.println("pro work");
    
42.         }
    
43. }
    
44. class AbstractTest
    
45. {
    
46.         public static void main(String[] args)
    
47.         {
    
48.                 Manager m = new Manager("wp","as",1.10,1);
    
49.                 m.work();
    
50.         }
    
51. }

复制代码

1. [code]abstract class Employee //这里应该把类定义为抽象类
   
2. 
   
3. {
   
4. 
   
5. private String name;
   
6. 
   
7. private String id;
   
8. 
   
9. private double pay;
   
10. 
    
11. Employee(String name,String id,double pay)
    
12. 
    
13. {
    
14. 
    
15. this.name = name;
    
16. 
    
17. this.id = id;
    
18. 
    
19. this.pay = pay;
    
20. 
    
21. }
    
22. 
    
23. public abstract void work();//抽象方法
    
24. 
    
25. }
    
26. 
    
27. class Manager extends Employee
    
28. 
    
29. {
    
30. 
    
31. private int bonus;
    
32. 
    
33. Manager(String name,String id,double pay,int bonus)
    
34. 
    
35. {
    
36. 
    
37. super(name,id,pay);
    
38. 
    
39. this.bonus = bonus;
    
40. 
    
41. }
    
42. 
    
43. public void work()
    
44. 
    
45. {
    
46. 
    
47. System.out.println("manager work");
    
48. 
    
49. }
    
50. 
    
51. }
    
52. 
    
53. class Pro extends Employee
    
54. 
    
55. {
    
56. 
    
57. Pro(String name,String id,double pay)
    
58. 
    
59. {
    
60. 
    
61. super(name,id,pay);
    
62. 
    
63. }
    
64. 
    
65. public void work()
    
66. 
    
67. {
    
68. 
    
69. System.out.println("pro work");
    
70. 
    
71. }
    
72. 
    
73. }
    
74. 
    
75. class AbstractTest
    
76. 
    
77. {
    
78. 
    
79. public static void main(String[] args)
    
80. 
    
81. {
    
82. 
    
83. Manager m = new Manager("wp","as",1.10,1);
    
84. 
    
85. m.work();
    
86. 
    
87. }
    
88. 
    

复制代码

现在你就可以运行了。因为类中有抽象方法，所以其所在的类必须为抽象类。

因为你在Employee类中有一个抽象方法

1. public abstract void work();//抽象方法
   

复制代码

所以要在Employee类前加上abstract，写成abstract class Employee就行了。