1. class java0405d1
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 System.out.println("怎一乱字了得");
   
6.                 JingLi kao=new JingLi("lishi","NPC",10000,10000);
   
7.         }
   
8. }
   
9. abstract class YuanGong
   
10. {
    
11.         private String name;
    
12.         private String id;
    
13.         private double pay;
    
14. 
    
15.         YuanGong(String name,String id,double pay)
    
16.         {
    
17.                 this.name=name;
    
18.                 this.id=id;
    
19.                 this.pay=pay;
    
20.         }
    
21.         public abstract void gongzuo();
    
22. }
    
23. class JingLi extends YuanGong
    
24. {
    
25.         private int jiangjin;
    
26.         JingLi(String name,String id,double pay,int jiangjin)        
    
27.         {
    
28.                 super(name,id,pay);
    
29.                 this.jiangjin=jiangjin;
    
30.         }
    
31.         public void gongzuo()
    
32.         {
    
33.                 System.out.println("我的心太乱");
    
34.         }
    
35. }
    
36. class pro extends YuanGong
    
37. {
    
38.         pro(String name,String id,double pay)
    
39.         {
    
40.                 super(name,id,pay);
    
41.         }
    
42.         public void gongzuo()
    
43.         {
    
44.                 System.out.println("脑子更乱");
    
45.         }
    
46. }
    

复制代码

求解 这个是老师第七天的视频里的习题 我打完用不了

抄老师的也不行  老师的那段代码也是会报错的 求高手改一下  最好在错误后面加上注解

把打印语句改成名字 工号 工资 数值你们自己写  我这个是发泄心情写进去的......

1. 
   
2. class java0405d1
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 System.out.println("怎一乱字了得");
   
7.                 JingLi kao=new JingLi("lishi","NPC",10000,10000);
   
8.                 pro  cao = new pro("wangwu","W3C",1000);
   
9.                 kao.gongzuo();
   
10.                 cao.gongzuo();
    
11.             }
    
12. }
    
13. abstract class YuanGong
    
14. {
    
15.         private String name;
    
16.         private String id;
    
17.         private double pay;
    
18. 
    
19.         YuanGong(String name,String id,double pay)
    
20.         {
    
21.                 this.name=name;
    
22.                 this.id=id;
    
23.                 this.pay=pay;
    
24.         }
    
25.         public abstract void gongzuo();
    
26. }
    
27. class JingLi extends YuanGong
    
28. {
    
29.         private int jiangjin;
    
30.         JingLi(String name,String id,double pay,int jiangjin)        
    
31.         {
    
32.                 super(name,id,pay);
    
33.                 this.jiangjin=jiangjin;
    
34.         }
    
35.         public void gongzuo()
    
36.         {
    
37.                 System.out.println("我是经理  我的心太乱");
    
38.         }
    
39. }
    
40. class pro extends YuanGong
    
41. {
    
42.         pro(String name,String id,double pay)
    
43.         {
    
44.                 super(name,id,pay);
    
45.         }
    
46.         public void gongzuo()
    
47.         {
    
48.                 System.out.println("我是普通员工   我恨经理这个二叉树");
    
49.         }
    
50. }

复制代码

自己改着玩的...

1. class java01
   
2. {
   
3. public static void main(String[] args)
   
4. {
   
5. System.out.println("怎一乱字了得");
   
6. JingLi kao=new JingLi("lishi","NPC",10000,10000);
   
7. kao.gongzuo(); //你这里创建了对象，确没有调用。。。
   
8. }
   
9. }
   
10. abstract class YuanGong
    
11. {
    
12. private String name;
    
13. private String id;
    
14. private double pay;
    
15. 
    
16. YuanGong(String name,String id,double pay)
    
17. {
    
18. this.name=name;
    
19. this.id=id;
    
20. this.pay=pay;
    
21. }
    
22. public abstract void gongzuo();
    
23. }
    
24. class JingLi extends YuanGong
    
25. {
    
26. private int jiangjin;
    
27. JingLi(String name,String id,double pay,int jiangjin)
    
28. {
    
29. super(name,id,pay);
    
30. this.jiangjin=jiangjin;
    
31. }
    
32. public void gongzuo()
    
33. {
    
34. System.out.println("我的心太乱");
    
35. }
    
36. }
    
37. class pro extends YuanGong
    
38. {
    
39. pro(String name,String id,double pay)
    
40. {
    
41. super(name,id,pay);
    
42. }
    
43. public void gongzuo()
    
44. {
    
45. System.out.println("脑子更乱");
    
46. }
    
47. }

复制代码

1. //在同一个.java文件中,不管定义了多少个类，都只能有一个主类（用public修饰），主类名要与java文件名相同，main方法要放在主类里面。
   
2. public class JavaTest {
   
3.         public static void main(String[] args) {          //main方法是Java程序的入口，就如爆竹的导火线，必须放在public类中，暴露出来，然后点燃！
   
4.                 System.out.println("怎一乱字了得");
   
5.                 JingLi kao = new JingLi("lishi", "NPC", 10000, 10000);
   
6.                 kao.gongzuo();
   
7.         }
   
8. }
   
9. 
   
10. //定义一个抽象类：
    
11. abstract class YuanGong {
    
12.         //定义了抽象类的所有属性：
    
13.         private String name;
    
14.         private String id;
    
15.         private double pay;
    
16.         
    
17.         //定义了此抽象类的构造函数：
    
18.         YuanGong(String name, String id, double pay) {
    
19.                 this.name = name;
    
20.                 this.id = id;
    
21.                 this.pay = pay;
    
22.         }
    
23.         //定义了一个抽象方法：
    
24.         public abstract void gongzuo();
    
25. }
    
26. 
    
27. //定义一个类：JingLi，它继承于抽象类：YuanGong
    
28. class JingLi extends YuanGong {
    
29.         //此类内部除了继承YuanGong的属性外，还自定义了一个属性：
    
30.         private int jiangjin;
    
31.         
    
32.         //定义此类自身的构造函数：
    
33.         JingLi(String name, String id, double pay, int jiangjin) {
    
34.                 super(name, id, pay);    //调用父类的构造函数，并将参数传进去，所以此父类对象会先被创建出来。
    
35.                 this.jiangjin = jiangjin;
    
36.         }
    
37. 
    
38.         //实现父类的抽象方法：
    
39.         public void gongzuo() {
    
40.                 System.out.println("我的心太乱");
    
41.         }
    
42. }
    
43. 
    
44. //定义一个类：Pro，它继承于抽象类：YuanGong
    
45. class Pro extends YuanGong {   //Java命名规则之一：类名要大写开头！切记，养成习惯！
    
46.         //定义此类自身的构造函数：
    
47.         Pro(String name, String id, double pay) {
    
48.                 super(name, id, pay);    //调用父类的构造函数，并将参数传进去，所以此父类对象会先被创建出来。
    
49.         }
    
50.         
    
51.         //实现父类的抽象方法：
    
52.         public void gongzuo() {
    
53.                 System.out.println("脑子更乱");
    
54.         }
    
55. }

复制代码

耐心看注释吧，有些细节，我都耐心地写在里面了，希望能帮到你！

刘焕新 发表于 2013-4-5 14:07
耐心看注释吧，有些细节，我都耐心地写在里面了，希望能帮到你！

:handshake太详细了 谢谢了