细节

  1. 调用父类构造器的好处（分工明确，父类属性由父类初始化，子类属性由子类初始化）
  2. 当子类中有和父类中的成员（属性和方法）重名时，为了访问父类成员，必须通过super。如果没有重名，使用super、this以及直接访问的效果是一样的。
  3. super的访问不限于直接父类，如果爷爷类和本类中有同名成员，也可以使用super去访问爷爷的成员。如果多个基类（上级类）中都有同名成员，使用super访问遵循就近原则。A->B->C。 ```java package super_TY;

public class Base {//父类是Object public int n1 = 999; public int age = 111;

  1. public void cal() {
  2.     System.out.println("Base类的cal() 方法...");
  3. }
  5. public void eat() {
  6.     System.out.println("Base类的eat().....");
  7. }

}

  1. ```java
  2. package super_TY;
  4. public class A extends Base{
  5.     //4个属性
  6.     public int n1 = 100;
  7.     protected int n2 = 200;
  8.     int n3 = 300;
  9.     private int n4 = 400;
  11.     public A() {
  12.     }
  14.     public A(String name) {
  15.     }
  17.     public A(String name, int age) {
  18.     }
  20. //    @Override
  21. //    public void cal() {
  22. //        System.out.println("A类的cal() 方法...");
  23. //    }
  25.     //4中方法
  26.     public void test100() {
  27.     }
  29.     protected void test200() {
  30.     }
  32.     void test300() {
  33.     }
  35.     private void test400() {
  36.     }
  37. }
  1. package super_TY;
  3. public class B extends A {
  4.     public int n1 = 888;
  6.     //编写测试方法
  7.     public void test() {
  8.         //super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；
  9.         //如果多个基类(上级类)中都有同名的成员，使用super访问遵循就近原则。A->B->C
  11.         System.out.println("super.n1=" + super.n1);
  12.         super.cal();
  13.     }
  15.     @Override
  16.     public void cal() {
  17.         System.out.println("B类的cal() 方法...");
  18.     }
  20.     public void sum() {
  21.         System.out.println("B类的sum()方法");
  22.         //希望调用父类A的cal方法
  23.         //因为子类没有cal方法，则可以采用以下三种方式调用
  25.         cal();
  26.         //找cal方法时(cal() 和 this.cal())，顺序是:
  27.         // (1)先找本类，如果有，则调用
  28.         // (2)如果没有，则找父类(如果有，并可以调用，则调用)
  29.         // (3)如果父类没有，则继续找父类的父类,整个规则，是一样的,直到 Object类
  30.         // 提示：
  31.         // 如果查找方法的过程中，找到了，但是不能访问， 则报错, cannot access
  32.         //如果查找方法的过程中，没有找到，则提示方法不存在
  33.         this.cal();//等价于cal();
  35.         //找cal方法(super.call()) 的顺序是直接查找父类，其他的规则一样
  36.         super.cal();
  38.         //演示访问属性的规则
  39.         //n1 和 this.n1 查找的规则是:
  40.         //(1) 先找本类，如果有，则调用
  41.         //(2) 如果没有，则找父类(如果有，并可以调用，则调用)
  42.         //(3) 如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object类
  43.         // 提示：
  44.         // 如果查找属性的过程中，找到了，但是不能访问， 则报错, cannot access
  45.         // 如果查找属性的过程中，没有找到，则提示属性不存在
  46.         System.out.println(n1);
  47.         System.out.println(this.n1);
  49.         //找n1 (super.n1) 的顺序是直接查找父类属性，其他的规则一样
  50.         System.out.println(super.n1);
  51.     }
  53.     //1. super可以访问父类的属性，但不能访问父类的private属性
  54.     public void hi() {
  55.         System.out.println(super.n1 + " " + super.n2 + " " + super.n3);
  56.         //私有属性无法访问
  57.         //System.out.println(super.n4);//报错！！！
  58.     }
  60.     //2. super可以访问父类的方法，但不能访问父类的private方法
  61.     public void ok() {
  62.         super.test100();
  63.         super.test200();
  64.         super.test300();
  65.         //私有方法无法访问
  66.         //super.test400();//报错！！！
  67.     }
  69.     //3. super访问父类的构造器
  70.     public B() {
  71.         //super();
  72.         //super("wty",19);
  73.         super("wty");
  74.     }
  75. }
  1. package super_TY;
  3. public class Super01 {
  4.     public static void main(String[] args) {
  5.         B b = new B();
  6.         b.sum();
  7.         System.out.println("================");
  8.         b.test();
  9.     }
  10. }

image.png

super和this的比较

image.png