super关键字基本使用

基本介绍

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

基本语法

访问父类的属性，但不能访问父类的private属性，super.属性名
访问父类的方法,不能访问父类的private方法，super.方法名(参数列表);
访问父类的构造器：super(参数列表);只能放在构造器的第一句，只能出现一句。
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 test100() {
    }

    protected void test200() {
    }

    void test300() {
    }

    private void test400() {
    }
}
public class B extends A{
    //1.访问父类的属性 , 但不能访问父类的private属性 [案例]super.属性名
    public void hi(){
        System.out.println(super.n1 + " " + super.n2 + " " + super.n3);
    }
    //2.访问父类的方法，不能访问父类的private方法 super.方法名(参数列表);
    public void ok(){
        super.test100();
        super.test200();
        super.test300();
    }
    //3.访问父类的构造器：super(参数列表);只能放在构造器的第一句，只能出现一句！
    public B() {
        //super();
        //super("jack", 10);
        super("jack");
    }
}

super 给编程带来的便利/细节

调用父类的构造器的好处(分工明确,父类属性由父类初始化,子类的属性由子类初始化)
当子类中有和父类中的成员(属性和方法)重名时,为了访问父类地成员,必须通过super,如果没有重名,使用super,this,直接访问是一样的效果!
super地访问不限于直接父类,如果爷爷类和本类中有同名地成员,也可以使用super去访问爷爷类的成员;如果多个基类(上级类)中都有同名的成员,使用super访问遵循就近原则.当然也需要访问权限的相关规则.

A类

package com.xdr630.super_;

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 test100() {
    }

    protected void test200() {
    }

    void test300() {
    }

    private void test400() {
    }

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

B类

package com.xdr630.super_;

public class B extends A{
    //1.访问父类的属性 , 但不能访问父类的private属性 [案例]super.属性名
    public void hi(){
        System.out.println(super.n1 + " " + super.n2 + " " + super.n3);
    }
    //2.访问父类的方法，不能访问父类的private方法 super.方法名(参数列表);
    public void ok(){
        super.test100();
        super.test200();
        super.test300();
    }
    //3.访问父类的构造器：super(参数列表);只能放在构造器的第一句，只能出现一句！
    public B() {
        //super();
        //super("jack", 10);
        super("jack");
    }
    public void sum(){
        System.out.println("B类中的sum()方法");
        //调用父类A的cal()方法
        //因为子类B没有cal方法，因此可以使用下面三种方式来调用

        //1.找 cal 方法时，顺序是：先找本类，如果有，则调用
        //2.如果没有，找父类（如果有并可以调用）
        //3.如果父类没有，则继续找父类的父类，直到找到 Object 类
        //提示：如果查到方法的过程当中，找到了，但是不能访问(private)，则报错
        //      如果查到方法的过程当中，没有找到，则提示方法不存在
        //cal();
        //this.cal(); 等价于 cal
        super.cal(); // 找 cal 方法的顺序是直接查找父类

    }
}

Super01 类

package com.xdr630.super_;

public class B extends A{
    //1.访问父类的属性 , 但不能访问父类的private属性 [案例]super.属性名
    public void hi(){
        System.out.println(super.n1 + " " + super.n2 + " " + super.n3);
    }
    //2.访问父类的方法，不能访问父类的private方法 super.方法名(参数列表);
    public void ok(){
        super.test100();
        super.test200();
        super.test300();
    }
    //3.访问父类的构造器：super(参数列表);只能放在构造器的第一句，只能出现一句！
    public B() {
        //super();
        //super("jack", 10);
        super("jack");
    }
    public void sum(){
        System.out.println("B类中的sum()方法");
        //调用父类A的cal()方法
        //因为子类B没有cal方法，因此可以使用下面三种方式来调用

        //1.找 cal 方法时，顺序是：先找本类，如果有，则调用
        //2.如果没有，找父类（如果有并可以调用）
        //3.如果父类没有，则继续找父类的父类，直到找到 Object 类
        //提示：如果查到方法的过程当中，找到了，但是不能访问(private)，则报错
        //     如果查到方法的过程当中，没有找到，则提示方法不存在
        //cal();
        //this.cal(); 等价于 cal
        super.cal(); // 找 cal 方法的顺序是直接查找父类

    }
}

super 和 this 的比较

No.

区别点

this

super

1

访问属性

访问本类中的属性,如果本类没有此属性则从父类中继续查找

从父类开始查找属性

2

调用方法

访问本类中的方法,如果本类没有此方法则从父类继续查找

从父类开始查找方法

3

调用构造器

调用本类构造器,必须放在构造器首行

调用父类构造器,必须放在子类构造器的首行

4

特殊

表示当前对象

子类中访问父类对象