1. /*
   
2.         super和this的区别：
   
3. 
   
4.         1.this始终是指向本类的成员：
   
5.                 1).访问本类的成员；
   
6.                 class A{
   
7.                         int num = 10;
   
8.                         void f1(){
   
9.                                 System.out.println("num = " + this.num);
   
10.                                 this.f2();//调用本类的f2()方法
    
11.                         }
    
12.                         void f2(){
    
13.                         }
    
14.                 }
    
15.                 2).在本类的构造方法中，调用本类其它的构造方法；
    
16.                         class A{
    
17.                                 A(){
    
18.                                         System.out.println("a1");
    
19.                                        
    
20.                                 }
    
21.                                 A(int b){
    
22.                                         this();//调用此类无参的构造方法；它必须是这个构造方法的第一条有效语句；
    
23.                                         System.out.println("a2");
    
24.                                 }
    
25.                         }
    
26.                         main(){
    
27.                                 A a = new A(2);
    
28. 
    
29.                         }
    
30.         2.super始终是指向父类的空间：
    
31.                 1.通过super可以访问父类的成员：
    
32. (重点)        2.可以调用父类的构造方法；
    
33.                 3.在子类中的构造方法，默认情况下会在第一行自动添加一句：super();//调用父类的无参的构造方法；
    
34.                 4.注意：
    
35.                         如果父类没有无参的构造方法，那么子类的构造方法中，就必须使用super()去显示的去调用父类的某个
    
36.                         带参的构造方法；
    
37.                 5.在子类的构造方法中调用父类的构造方法使用super().这里也要求super()必须是这个构造方法的第一句话；
    
38.                 6.在子类的构造方法中，不能即使用this()又使用super();因为都需要在第一句话；
    
39.           
    
40. 
    
41. 小结：
    
42. 1.this可以访问本类成员属性和成员方法；调用本类其它构造方法
    
43. 2.super可以访问父类的成员属性和成员方法；调用父类的构造方法；
    
44. 3.有一个时候，需要我们在子类中必须显示的使用super()去调用父类的构造方法：
    
45.   当父类没有无参构造方法时：
    
46.         class A{
    
47.                 A(int a){
    
48.                 }
    
49.         }
    
50.         class B extends A{
    
51.                 //不论子类中有多少个构造方法，每个构造方法内都要显示的去super()，调用父类带参构造方法；
    
52.                 B(int n){
    
53.                         super(n);
    
54.                 }
    
55.         }
    
56. */
    
57. class A{
    
58.         int num = 10;
    
59.        
    
60.         A(int b){
    
61.         //        this();//调用此类无参的构造方法；它必须是这个构造方法的第一条有效语句；
    
62.                 System.out.println("a2");
    
63.         }
    
64.         void fun(){
    
65.                 System.out.println("父类的fun()方法");
    
66.         }
    
67. }
    
68. class B extends A
    
69. {
    
70.        
    
71.         B(int n){
    
72.                 super(n);//调用了父类的带一个int参数的构造方法；
    
73. //                this("aaa");
    
74.         }
    
75.         B(String a ){
    
76.         }
    
77. 
    
78.         int num = 20;
    
79.         void show(){
    
80.                 System.out.println("num = " + super.num);//父类的num
    
81.                 super.fun();//父类的fun()方法
    
82.         }
    
83. }
    
84. class Demo
    
85. {
    
86.         public static void main(String[] args)
    
87.         {
    
88.         //        new B().show();
    
89.                 new B(20);
    
90.                
    
91.         }
    
92. }
    

复制代码

加油加油