抽象类可以被很多类继承，有没有可能这样一种情况，我在抽象类里面写一个带对象参数的抽象方法，如下代码所示，请问可以实现吗？？可以实现的话，这个类参数该怎写呢？

1. class Demo6 {
   
2.         public static void main(String[] args) {
   
3.                 Programmer p = new Programmer("asd","123",8000);
   
4.                 p.work();
   
5.                 Manager m =new Manager("zxc","456",20000,5000);
   
6.                 m.work();
   
7.         }
   
8. }
   
9. abstract class Employee{
   
10.         private String name;
    
11.         private String id;
    
12.         private int pay;
    
13.         private int bonus;
    
14. 
    
15.         public abstract void work(类参数);
    
16. 
    
17.         Employee(){};
    
18.         Employee(String name,String id,int pay){
    
19.                 this.name = name;
    
20.                 this.id = id;
    
21.                 this.pay = pay;
    
22.         };
    
23.         Employee(String name,String id,int pay,int bonus){
    
24.                 this.name = name;
    
25.                 this.id = id;
    
26.                 this.pay = pay;
    
27.                 this.bonus = bonus;
    
28.         };
    
29. 
    
30.         public String getName(){
    
31.                 return name;
    
32.         }
    
33.         public String getId(){
    
34.                 return id;
    
35.         }
    
36.         public int getPay(){
    
37.                 return pay;
    
38.         }
    
39.         public int getBonus(){
    
40.                 return bonus;
    
41.         }
    
42.        
    
43.         public void speak(){
    
44.                 if(bonus == 0)
    
45.                 System.out.println("我是"+name+",我的ID是"+id+"我的工资是："+pay+"，我没有奖金。");
    
46.                 else
    
47.                         System.out.println("我是"+name+",我的ID是"+id+"我的工资是："+pay+"奖金是："+bonus);
    
48.         }
    
49.        
    
50. }
    
51. 
    
52. class Programmer extends Employee{
    
53.         Programmer(){};
    
54.         Programmer(String name,String id, int pay){
    
55.                 super(name,id,pay);
    
56.         };
    
57.         public void work(类参数){
    
58.                 System.out.println("我是程序员，我的工作是编程！");
    
59.                 类.speak();
    
60.        
    
61.         }
    
62. }
    
63. 
    
64. class Manager extends Employee{
    
65.         Manager(){};
    
66.         Manager(String name,String id,int pay,int bonus){
    
67.                 super(name,id,pay,bonus);
    
68.         };
    
69.         public void work(类参数){
    
70.                 System.out.println("我是经理，我的工作是管理！");
    
71.                 类.speak();
    
72.         }
    
73. }
    

复制代码

抽象类可以被很多类继承，有没有可能这样一种情况，我在抽象类里面写一个带对象参数的抽象方法，如下代码所示，请问可以实现吗？？可以实现的话，这个类参数该怎写呢？

=-= 你好像和我就是一个班的说

类可以作为参数传递，你这个代码我没改成功，不过类作为形参传递成功了
构造函数的大括号结尾应该是不能加分号的吧·····

1. class Demo6 {
   
2.         public static void main(String[] args) {
   
3.                 Programmer p = new Programmer("asd","123",8000);
   
4.                                 CeShi cs = new CeShi();
   
5.                 p.work(cs);
   
6.                 Manager m =new Manager("zxc","456",20000,5000);
   
7.                 m.work(cs);
   
8.         }
   
9. }
   
10. 
    
11. [color=Red]//这个类是我新建的，就是为了测试看看能不能传递。感觉这个和对象传递很像，就像老师之前举例子说两个人比较年龄，传递的是Person的对象，而不是直接传//递age
    
12. class CeShi {[/color]
    
13.        
    
14.         public void speak(){
    
15. //                if(bonus == 0)
    
16. //                        System.out.println("我是"+getName()+",我的ID是"+getId()+"我的工资是："+getPay()+"，我没有奖金。");
    
17. //                else
    
18. //                         System.out.println("我是"+getName()+",我的ID是"+getId()+"我的工资是："+getPay()+"奖金是："+getBonus());
    
19.         System.out.println("22222222222");
    
20.                 }
    
21.        
    
22. }
    
23. abstract class Employee{
    
24.         private String name;
    
25.         private String id;
    
26.         private int pay;
    
27.         private int bonus;
    
28. 
    
29.         public abstract void work(CeShi cs);
    
30. 
    
31.         Employee(){}
    
32.         Employee(String name,String id,int pay){
    
33.                 this.name = name;
    
34.                 this.id = id;
    
35.                 this.pay = pay;
    
36.         }
    
37.         Employee(String name,String id,int pay,int bonus){
    
38.                 this.name = name;
    
39.                 this.id = id;
    
40.                 this.pay = pay;
    
41.                 this.bonus = bonus;
    
42.         }
    
43. 
    
44.         public String getName(){
    
45.                 return name;
    
46.         }
    
47.         public String getId(){
    
48.                 return id;
    
49.         }
    
50.         public int getPay(){
    
51.                 return pay;
    
52.         }
    
53.         public int getBonus(){
    
54.                 return bonus;
    
55.         }
    
56.         
    
57.         
    
58.         
    
59. }
    
60. 
    
61. class Programmer extends Employee{
    
62.         Programmer(){}
    
63.         Programmer(String name,String id, int pay){
    
64.                 super(name,id,pay);
    
65.         }
    
66.         public void work(CeShi cs){
    
67.                 System.out.println("我是程序员，我的工作是编程！");
    
68.                 cs.speak();
    
69.         
    
70.         }
    
71. }
    
72. 
    
73. class Manager extends Employee{
    
74.         Manager(){}
    
75.         Manager(String name,String id,int pay,int bonus){
    
76.                 super(name,id,pay,bonus);
    
77.         }
    
78.         public void work(CeShi cs){
    
79.                 System.out.println("我是经理，我的工作是管理！");
    
80.                 cs.speak();
    
81.         }
    
82. }
    

复制代码