1. abstract 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. }
    
15. class Manager extends Employee
    
16. {
    
17.         private double bonus;
    
18.         Manager(String name,String id,double pay,double bonus)
    
19.         {
    
20.                 super(name,id,pay);
    
21.                 this.bonus = bonus;
    
22.         }
    
23.         public void work()
    
24.         {
    
25.                 System.out.println("manage");
    
26.         }
    
27. }
    
28. class Programmer extends Employee
    
29. {
    
30.         Programmer(String name,String id,double pay)
    
31.         {
    
32.                 super(name,id,pay);
    
33.                
    
34.         }
    
35.         public void work()
    
36.         {
    
37.                 System.out.println("code");
    
38.         }
    
39. }

复制代码

问题是super(name,id,pay);    this.bonus = bonus;这2句不是同一行了吗？为啥还是对的？？

一个是调用父类的构造函数，一个是给当前类的变量赋值，并没有冲突。   当你调用了super(...)时，不能在同一构造函数中使用this(...)，即不能调用了父类的构造函数之后又调用当前类的构造函数。

因为他们带入的数据不一样啊 this 是指代你当前Manager 中的数据，而 super 指代你继承的父类Employee中的

this和super在构造不能再共存。这是this和super的用法。
1.this.属性 表示本类中的属性
2.super.属性 表示父类中的属性。
3.this方法：this.方法 （）表述调用本类中的方法，如果找不到则从父类中查找
4.super方法：表示子类找到父类中被子类覆写的方法。
5.this构造：可以调用本类中的构造方法。
6.super构造：从子类直接调用父类的构造方法
7.this表示当前的对象
8.super：在子类构造方法首行。

希望以上的内容对你有所提高。

super是调用父类属性的关键字，而this是本类的关键字，你这行代码没错，只是没有换行，不规范而已

问题是super(name,id,pay);    this.bonus = bonus;这2句不是同一行了吗？为啥还是对的？？

我来说一下吧。
                super(name,id,pay);
                this.bonus = bonus;
这是正确的。

1. class Person
   
2. {
   
3.         private String name;
   
4.         Person(String name)
   
5.         {
   
6.                 this.name = name;
   
7.         }
   
8. }
   
9. class Student extends Person
   
10. {
    
11.         private String name;
    
12.         private int age;
    
13.         Student(String name)
    
14.         {
    
15.                 super(name);
    
16.         }
    
17.         Student(String name,int age)
    
18.         {
    
19.                 /*
    
20.                 在这里说了，所谓的super和this不能同时出现，是指，this(name)[调用Student类的构造函数对name进行赋值]和super(name)[调用父类的构造函数，对name属性进行赋值。]
    
21.                 这两句都是必须放在开头的，如果，你同时把两句都放在一起，系统就不知道该执行哪一句了。
    
22.                 你把调用本类构造函数的this和对本类对象进行赋值是使用this的使用方法理解错了。
    
23.                 你看下面两种代码：无论是调用父类的构造方法还是调用本类的构造函数进行复制，它们都必须在本类对象赋值语句之前。
    
24.                
    
25.         你再看一下这段话：
    
26.         子父类中的构造函数
    
27.         在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句 super（）。
    
28.         super（）：会访问父类中空参数的构造函数。而且子类中所有的构造函数会默认第一行都是super（）
    
29.        
    
30.         也许你会奇怪，不是说子类的构造函数默认第一行有一条隐式的语句 super（）么？那么如果使用的是this(name);岂不是没调用父类的Super()了？不是的，你看，this（name），调用的是
    
31.         Student(String name)
    
32.         {
    
33.                 super(name);
    
34.         }
    
35.         这个构造函数，也就是说它其实最先调用的还是父类的构造函数。完毕。
    
36.        
    
37.         因为我的例子里面没有写空参数构造函数，所以，两个类中都是木有的空参数构造函数的。所以调用的第一句就不是父类的空参数构造函数而是有参数的父类的构造函数啦！
    
38.                 */
    
39.                 this(name);
    
40.                 this.age = age;
    
41. //                        super(name);
    
42. //                        this.age = age;
    
43.         }
    
44.         /*我在Person中没有定义空参数构造方法，在这里定义的话，它里面的第一句就是一条隐式的super(),调用父类的空参数构造方法，而父类中没有这个方法，编译肯定不会通过       
    
45.         Student()
    
46.         {
    
47.                 super()
    
48.         }
    
49.         */
    
50.        
    
51. }

复制代码

super（）你调用父类的构造方法，为什么要调用父类的构造方法呢？
那是因为子类继承了父类，获取到了父类中内容（属性），所以在父类
内容之前，要先看父类是如何对自己的内容进行初始化的,所以子类在构造
对象时，必须访问父类中的构造函数，
this() 调用子类中其他的构造方法给对象初始化，就是间接的访问了父类的构造方法
this和super不能同时出现在一个构造函数里面，因为this必然会
调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所
以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也
不会通过。

楼主提的问题，本生就是错的。“问题是super(name,id,pay);    this.bonus = bonus;这2句不是同一行了吗？为啥还是对的？？”而“super(name,id,pay);    this.bonus = bonus;”本来就站了两行，你却问为啥它们会在同一行。
可能你的本意是想问:"super(name,id,pay);    this.bonus = bonus;为什么会在同一构造函数中？"但是你为什么会这样问呢？可能是你听老师说：“super()和this()是不能出现在同一个构造函数的第一行”。于是你把this.bonus想成了this(),如是你脑子里才会冒出“问题是super(name,id,pay);    this.bonus = bonus;这2句不是同一行了吗？为啥还是对的？？”。这只是我的一种猜测，我并没有什么恶意。提出这种问题也是理所当然的，因为每一天视频里讲的东西实在太多，对于初学者来说把一些东西记混淆了，也是理所当然的事情。

抱歉各位，插个话，个人觉得不就是个分号的问题么，回答那么复杂，看都看晕了.
针对于问题，楼主对同一行的理解有误，编程的时候说的同一行指的是代码执行时候的顺序，而代码的执行顺序是由“；”和“{}”作为开始和结束的。
简单的说这里注意super(name,id,pay);    this.bonus = bonus;  就相当于
super(name,id,pay);   
this.bonus = bonus;  
源代码中的行是按照  语句结构  划分的，不是写作文那样，这个知道就行了，也不要那么纠结，以后会遇到很多这种问题，知道就行了，没必要花费过多时间去理解。等你的知识体系全面了，再去深入理解，现在就狂练代码就OK

this  和  super  ，只能有一句在第一行，  要不this  要不 super

1  首先你要知道this 和super并不是不能同时出现的而是要看他们的是在什么情况下用的  各自要做什么事     
  a  构造方法重载：只需看参数即可。如果想在一个构造方法中调用另外一个构造方法，那么可以使用this() 的方式调用，this() 括号中的参数表示目标构造方法的参数。this()必须要作为构造方法的第一条语句，换句话说，this()之前不能有任何可执行的代码。
  b   如果子类使用 super()显式调用父类的某个构造方法，那么在执行的时候就会寻找与 super()所对应的构造方法而不会再去寻找父类的不带参数的构造方法。与this 一样，super 也必须要作为构造方法的第一条执行语句，前面不能有其他可执行语句。
2   this和super是在这两种情况同时出现时才不能同时出现   虽然你的super是去调用父类的构造方法  但是你用的this是将当前对象的那个属性赋值而不是去调用另一个构造方法     所以并不冲突  那当然就是对的了  

super是调用父类的指定构造函数，this是调用当前类的构造函数，只能存在一个。