自己在敲代码，不停的编译，改错，终于成功，但是请问下面这个代码 为啥 输出的结果会是这样的？  还是不会具体分析。。。
class Demo01 {
        public static void main(String[] args) {
                Worker w1 = new D("zhangsan",5,100);
                w1.show();
                System.out.println(w1.name);
                System.out.println(w1.id);
                System.out.println(w1.pay);
        }
}

abstract class Worker {
        String name;
        int id;
        double pay;
        Worker(String name,int id,double pay) {
                this.name = name;
                this.id = id;
                this.pay = pay;
        }
        abstract void show();
}

class D extends Worker {
        String name = "lisi";
        int id;
        double pay;
        D(String name,int id,double pay) {
                super(name,id,pay);
                }
        void show() {
                System.out.println("编程");
                System.out.println(super.name);
                System.out.println(this.name);
        }
        
}

super() 它的作用:执行父类的构造方法
                                this()  它的作用:执行本类的构造方法

                                super()与this()在使用时注意事项
                                       
                                        1.它们只能出现在构造方法中

                                        2.它们如果要出现，必须是构造方法中的第一句.                       

                                        3.super()与this()不能共存

最简单的理解方法我感觉就是看代码
Worker w1 = new D("zhangsan",5,100);
                w1.show();
这两句就是建立Worker 类型的w1对象,    然后把一个新的D类型的对象赋值给w1,那么就会调用D里面带有参数的构造函数,.       也就是父类的引用指向子类的对象
D(String name,int id,double pay) {
                super(name,id,pay);
                }
也就是这句,这个构造函数里面又调用  super(name,id,pay),这个构造函数,因此就是给父类的name赋值为"zhangsan"    id赋值为5, pay赋值为100

因此当你下面调用show方法的时候,父类中的show方法被子类的show方法覆写,因此调用的是子类的show方法,    (上面建立的对象是父类的引用指向子类的对象,也就是说指向D这个对象所在的内存地址,从这个方面考虑你也是调用的是子类的show方法)   
此时收方法里面又调用super.name    这时候肯定是zhangsan    this.name  肯定是子类的name啊   

这时候前几句打印的就是
编程
zhangsan
lisi

System.out.println(w1.name);
System.out.println(w1.id);
System.out.println(w1.pay)
这几句打印的是对象w1的name   id    pay   
前面不是说新建立对象D("zhangsan",5,100),并把对象D赋值给w1吗?
因此这里w1 肯定指向的是这里zhangsan     5      100了

有些时候只是我们自己想的太多,而把自己绕进去.

1. class Demo01
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Worker w1 = new D("zhangsan",5,100);
   
6.                 w1.show();
   
7.                 System.out.println(w1.name);
   
8.                 System.out.println(w1.id);
   
9.                 System.out.println(w1.pay);
   
10.     }
    
11. }
    
12. 
    
13. abstract class Worker
    
14. {
    
15.         String name;
    
16.     int id;
    
17.     double pay;
    
18.     Worker(String name,int id,double pay)
    
19.         {
    
20.         this.name = name;//这里的this.就是在指代对象，谁调用这个这个函数，this.就代表是谁，在主函数中调用它的是w1，那就说this.就是w1
    
21.         this.id = id;
    
22.         this.pay = pay;
    
23.     }
    
24.     abstract void show();
    
25. }
    
26. 
    
27. class D extends Worker
    
28. {
    
29.         //String name = "lisi";这里不用这么定义，因为你要在D函数中想其中输入名字的
    
30.     //int id;
    
31.     //double pay;  这三个地方没有必要再写一遍因为你已经继承了Worker中的所有，包括这三条属性
    
32.     D(String name,int id,double pay)
    
33.         {
    
34.                 super(name,id,pay);//这里的super()就是在访问父类中的Worker（）构造函数，因为原本这个函数中的内容是个父类中的那个构造函数中的内容是一样，但是那样写的话就会显得很麻烦，既然两个类中的内容都是一样的，又何必再写一遍，直接拿过来用就好了，所以直接使用super()访问父类构造函数
    
35.         }
    
36.     void show()
    
37.         {
    
38.                 System.out.println("编程");
    
39.         System.out.println(super.name);
    
40.         System.out.println(this.name);
    
41.      }
    
42.       
    
43. }
    
44. //最后在说说输出的情况
    
45. /*
    
46. 输出结果：
    
47. 编程
    
48. zhangsan
    
49. zhangsan
    
50. zhangsan
    
51. 5
    
52. 100.0
    
53. 
    
54. 首先  你在new对象的时候，JVM将数据先传进D子类的D构造函数中，这个时候，构造函数D（） 再将数据传给super(),
    
55. spuer（）通过访问父类的构造函数Worker() 将数据进行赋值后。
    
56. 接着回头来继续读取show()
    
57. show()中先输出了  编程
    
58. 接着读取第二行的 super.name，因为之前的赋值，父类中的name已经有了值，就是 zhangsan  输出zhangsan
    
59. 接着读取第三行的this.name 这里因为w1的调用 ，也就指代是w1
    
60. 所以this.name 也是zhangsan
    
61. 接下来
    
62. 再回到主函数中，一句一句读取，
    
63. 你应该明白了。。。。。。
    
64. */

复制代码

斑马 这应该能给1分了吧

我来给你解释一下吧。其实是super作用于继承的父类，this作用于当前对象，就是本类中的对象，看你的代码来分析，给你写上注释，
class Demo01 {
        public static void main(String[] args) {
                Worker w1 = new D("zhangsan",5,100);//你创建了抽象的对象，实例是子类，并且为它的构造函数赋值，那么，我们现在应该到D这个子类中看它的构造函数
                w1.show();
                System.out.println(w1.name);
                System.out.println(w1.id);
                System.out.println(w1.pay);
        }
}

abstract class Worker {
        String name;
        int id;
        double pay;
        Worker(String name,int id,double pay) {
                this.name = name;
                this.id = id;
                this.pay = pay;
        }
        abstract void show();
}

class D extends Worker {
        String name = "lisi";
        int id;
        double pay;
        D(String name,int id,double pay) {
                super(name,id,pay);//在此构造函数中，你使用了super();这个方法就是将你得到的值，赋给父类的构造方法。所以父类的name=zhangsan,id=5,pay=100,然后再看下面的show方法，
         //注：此处代码是我给你分析完添加进去，让你能明白this的主要作用。
         //如果你的程序中加入下面代码，那么，它将会把你赋予的值从新赋予给这3个参数。就覆盖了你前面String name="lisi"的值，this是当前类的对象，那么，你下面show()方法中输出的this.name也会是zhangsan而不是list
            this.name=name;
            this.id=id;
            this.pay=pay;
                }
        void show() {
                System.out.println("编程");
                System.out.println(super.name);//在这里，你输出了父类的name值，因为你刚才给父类赋于了zhangsan的值，所有，父类输出的是zhangsan,
                System.out.println(this.name);//这里，你使用了this来输出本类中的name值。因为上面String name 你自己给予它的值是list，所有它会输出本地你赋予的lisi
        }

结论：this是当前对象。super是父类对象，就算你的父类跟子类都不是抽象的，他们的作用也是一样的。如果你没有父类，那么，supur是不能用的。希望能帮助到你。this是当前类的对象，所以不管是什么类，都能使用。

class Demo01 {
        public static void main(String[] args)
       {
                Worker w1 = new D("zhangsan",5,100);    //创建一个D对象，并初始化name,id,pay，D在这里又继承了Worker
                w1.show();  //调用show方法，输出“编程”，然后是父类Worker的name: zhangsan,然后是本类中的name:   Liisi
                System.out.println(w1.name); //打印的是w1初始化的name：zhangsan
                System.out.println(w1.id);  //打印的是w1初始化的id：5
                System.out.println(w1.pay);  //打印的是w1初始化的pay：100   
      }
}
abstract class Worker {
        String name;
        int id;
        double pay;
        Worker(String name,int id,double pay) {
                this.name = name;
                this.id = id;
                this.pay = pay;
        }
        abstract void show();
}
class D extends Worker {
        String name = "lisi";
        int id;
        double pay;
        D(String name,int id,double pay) {
                super(name,id,pay);
                }
        void show() {
                System.out.println("编程");
                System.out.println(super.name);
                System.out.println(this.name);
        }
        
}

如果问题未解决，请继续追问，如果没有问题了，请将帖子分类 改为“已解决”，谢谢