13、super关键字

1、基本介绍：super代表父类的引用，用于访问父类的属性、方法、构造器

2、基本语法：

（1）访问父类的属性，但不能访问父类的private属性

super.属性名

（2）访问父类的方法，不能访问父类的private方法

super.方法名（参数列表）

（3）访问父类的构造器（只能放在构造器的第一句且只能出现一句）

super(参数列表);

package package20221105;
public class Super01 {
    public static void main(String[] args) {
        Bb t1=new Bb();
        t1.hi();
        t1.ok();
    }
}
/*输出：
name=jack age=10
100 200 300
 */

package package20221105;
public class Aa {
    public int n1=100;
    protected  int n2=200;
    int n3=300;
    private int n4=400;
    public Aa(){}
    public Aa(String name){}
    public Aa(String name,int age){
        System.out.println("name="+name+" age="+age);
    }
    public void test100(){}
    protected void test200(){}
    void test300(){}
    private void test400(){}
}

package package20221105;
public class Bb extends Aa{
    public void hi(){
        //不能访问父类private的属性n4
        System.out.println(super.n1+" "+super.n2+" "+super.n3);
    }
    public void ok(){
        //不能访问父类private的方法test400
        super.test100();
        super.test200();
        super.test300();
    }
    //调用父类构造器
    public Bb(){
        super("jack",10);
    }
}

3、super的优点：

（1）调用父类构造器的好处：分工明确，父类属性由父类初始化，子类的属性由子类初始化

（2）当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super，如果没有重名，使用super、this、直接访问是一样的效果

package package20221105;
public class Super01 {
    public static void main(String[] args) {
        Bb t1=new Bb();
        t1.sum();
    }
}
/*输出：
B类的sum()方法
B类的cal()方法...
B类的cal()方法...
A类的cal()方法...
800
800
900
 */

package package20221105;
public class Aa {
    int n1=900;
    public void cal(){
        System.out.println("A类的cal()方法...");
    }
}

package package20221105;
public class Bb extends Aa {
    int n1=800;
    //访问父类的方法
    public void cal() {
        System.out.println("B类的cal()方法...");
    }
    public void sum() {
        System.out.println("B类的sum()方法");
        //找cal方法时，顺序是：
        //（1）先找本类，如果有，则调用
        //（2）如果没有，则找父类（如果有，并可以调用，则调用）
        //（3）如果父类没有，则继续找父类的父类
        //（4）如果找到了，但不能访问，则直接报错（cannot access），且不再继续查找了
        //（5）如果没有找到，则提示方法不存在
        cal();//输出：B类的cal()方法...
        this.cal();//等价于cal，输出：B类的cal()方法...
        super.cal();//直接查找父类，跳过本类，输出：A类的cal()方法...

        //访问父类的属性：
        //先从本类查起，往父类上面查去
        System.out.println(n1);
        System.out.println(this.n1);
        System.out.println(super.n1);//直接从父类查起
    }
}

4、super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类中都有同名的成员，使用super访问遵循就近原则，也要遵守访问权限的相关规则。A→B→C