super关键字的使用

1.基本介绍及语法

1.1基本介绍

super代表父类的引用，用于访问父类的属性、方法、构造器

1.2基本语法

1. 访问父类的属性，但不能访问父类的private属性
   super.属性名
2. 访问父类的方法，不能访问父类的private方法
   super.方法名(参数列表)
3. 访问父类的构造器
   super(参数列表)；
   只能放在构造器的第一句，只能出现一句！

2.代码细节查看

代码目的：

1. 创建一个A类，使用不同的权限修饰符定义四个属性及方法。编写一个无参和两个不同的有参构造器
2. 创建一个B类继承A类，创建测试方法，使用super的不同语法调用A类的属性和方法
3. 创建Super01类，在类中创建子类对象，调用子类方法

2.1 A类

public class A {
    //4个属性
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;

    public A() {
    }

    public A(String name) {
    }

    public A(String name, int age) {
    }

    public void cal() {
        System.out.println("A类的cal()方法...");
    }

    public void test100() {
    }

    protected void test200() {
    }

    void test300() {
    }

    private void test400() {
    }
}

2.2 B类

public class B extends A {
    public int n1 = 888;

    //编写测试方法
    public void test() {
        //super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；
        //如果多个基类(上级类)中都有同名的成员，使用super访问遵循就近原则。A->B->C
        System.out.println("super.n1=" + super.n1);
        super.cal();
    }

    //访问父类的属性 , 但不能访问父类的private属性 [案例]super.属性名
    public void hi() {
        System.out.println(super.n1 + " " + super.n2 + " " + super.n3);
    }

    public void cal() {
        System.out.println("B 类的 cal() 方法...");
    }

    public void sum() {
        System.out.println("B 类的 sum()");
        //希望调用父类-A 的cal方法
        //这时，因为子类B没有cal方法，因此我可以使用下面三种方式
        //找 cal 方法时(cal() 和 this.cal())，顺序是:
        // (1)先找本类，如果有，则调用
        // (2)如果没有，则找父类(如果有，并可以调用，则调用)
        //cal();
        this.cal(); //等价 cal
        // (3)如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object类
        // 提示：如果查找方法的过程中，找到了，但是不能访问， 则报错,cannotaccess
        //如果查找方法的过程中，没有找到，则提示方法不存在
        //找 cal 方法(super.call()) 的顺序是直接查找父类，其他的规则一样
        //super.cal();
        //演示访问属性的规则
        //n1 和 this.n1 查找的规则是
        //(1) 先找本类，如果有，则调用
        //(2) 如果没有，则找父类(如果有，并可以调用，则调用)
        //(3) 如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object类
        // 提示：如果查找属性的过程中，找到了，但是不能访问， 则报错,cannotaccess
        // 如果查找属性的过程中，没有找到，则提示属性不存在
        System.out.println(n1);
        System.out.println(this.n1);
        //找 n1 (super.n1) 的顺序是直接查找父类属性，其他的规则一样
        System.out.println(super.n1);
    }

    //访问父类的方法，不能访问父类的private方法 super.方法名(参数列表);
    public void ok() {
        super.test100();
        super.test200();
        super.test300();
        //super.test400();//不能访问父类 private 方法
    }

    public B() {
        //访问父类的构造器(这点前面用过)：super(参数列表);只能放在构造器的第一句，只能出现一句！
        //super();
        //super("jack", 10);
        super("jack");
    }
}

2.3 Super01类

public class Super01 {
    public static void main(String[] args) {
        B b = new B();//子类对象
        b.sum();
        b.test();
    }
}

3.super的好处

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

ps：super就是跳过本类，直接去父类查找成员，第2条后半句稍微有些歧义，仔细理解！

4.super和this的比较