复习：super关键字

目录

一、super的作用

二、基本语法

三、细节

第一条

第二条

 第三条

---

一、super的作用

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

二、基本语法

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

父类

package com.hspedu.super_;

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

    public void test100() {
    }

    protected void test200() {
    }

    void test300() {
    }

    private void test400() {
    }
}

子类

package com.hspedu.super_;

import com.hspedu.homework.Super;

public class B extends A{

    public void hi(){
        //1.访问父类的属性，但不能访问父类的private属性
        System.out.println(super.n1 + " " + super.n2 + " " + super.n3 + " " + super.n4);
    }
 
}

 

2.访问父类的方法，但不能访问父类的private方法

3.访问父类的构造器，super(参数列表):只能放在构造器的第一句，只能出现第一句

 

三、细节

第一条

调用父类的构造器的好处 (分工明确,父类属性由父类初始化，子类的属性由子类初始化)

第二条

当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员必须使用super

如果没有重名，super、this、直接访问是一样的效果（举例说明）

package com.hspedu.super_;

public class A {

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

    //3个构造器
    public A() {
        System.out.println("父类A()的构造器....");
    }

    public A(String name) {
        System.out.println("父类A(String name)的构造器....");
    }

    public A(String name, int age) {
        System.out.println("父类A(String name, int age)的构造器....");
    }

    public void test100() {
    }

    protected void test200() {
    }

    void test300() {
    }

    private void test400() {
    }
    public void cal(){
        System.out.println("父类-A类cal()方法...");
    }
}

package com.hspedu.super_;


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

    public void hi() {
        //1.访问父类的属性，但不能访问父类的private属性
        System.out.println(super.n1 + " " + super.n2 + " " + super.n3);
        //System.out.println(super.n4);
    }

    //2.访问父类的方法，但不能访问父类的private方法
    public void sayOk() {
        test100();
        test200();
        test300();
        //test400();
    }
    //3.访问父类的构造器，super(参数列表):只能放在构造器的第一句，只能出现第一句
//    public void hello(){
//        super();
//    }

    public B() {
        //super();
        //super("jack");
        super("jack", 20);
        System.out.println("子类B()构造器...");
    }

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

    public void eat() {
        System.out.println("B类的eat()方法...");
//        当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员必须使用super
//        如果没有重名，super、this、直接访问是一样的效果（举例说明）

//        1)先找本类，如果有，则调用（本类不受访问修饰符限制）
//        2)如果没有，则找父类，如果有且可以调用则调用
//        3)如果父类没有，则继续找父类的父类，规则同上,直到Object类
//        tips：如果查找方法的过程中找到了，但是不能访问，则报private access
//        如果直到Object类都没找到，则提示方法不存在（无法解析）
        cal();
        this.cal();//查找逻辑和cal()相同
        //super.cal();//首先从父类查起，跳过本类，除此之外，逻辑和cal()相同

        //属性和方法的原则相同
        System.out.println(n1);//输出888
        System.out.println(this.n1);//888
        System.out.println(super.n1);//100
    }
}

package com.hspedu.super_;

public class Super01 {
    public static void main(String[] args) {
        B b = new B();
        b.eat();
    }
}

 第三条

如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员;如果多个基类(上级类)中都有同名的成员，使用super访问遵循就近原则。A->B->C（父类—>爷爷类—>曾祖父类—>......—>Object类），当然也需要遵守访问权限的相关规则（四个访问修饰符）

祖父类

package com.hspedu.extend_;

public class Base01 {//父类是Object类
    public int n1 = 999;
    public int age = 111;
    public void cal(){
        System.out.println("Base类的cal()方法....");
    }
    public void eat(){
        System.out.println("Base类的eat()方法....");
    }


}

父类

package com.hspedu.super_;

import com.hspedu.extend_.Base01;

public class A extends Base01 {

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

    //3个构造器
    public A() {
        System.out.println("父类A()的构造器....");
    }

    public A(String name) {
        System.out.println("父类A(String name)的构造器....");
    }

    public A(String name, int age) {
        System.out.println("父类A(String name, int age)的构造器....");
    }

    public void test100() {
    }

    protected void test200() {
    }

    void test300() {
    }

    private void test400() {
    }
//    public void cal(){
//        System.out.println("父类-A类cal()方法...");
//    }
}

子类

package com.hspedu.super_;


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

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

    public void hi() {
        //1.访问父类的属性，但不能访问父类的private属性
        System.out.println(super.n1 + " " + super.n2 + " " + super.n3);
        //System.out.println(super.n4);
    }

    //2.访问父类的方法，但不能访问父类的private方法
    public void sayOk() {
        test100();
        test200();
        test300();
        //test400();
    }
    //3.访问父类的构造器，super(参数列表):只能放在构造器的第一句，只能出现第一句
//    public void hello(){
//        super();
//    }

    public B() {
        //super();
        //super("jack");
        super("jack", 20);
        System.out.println("子类B()构造器...");
    }

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

    public void eat() {
        System.out.println("B类的eat()方法...");
//        当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员必须使用super
//        如果没有重名，super、this、直接访问是一样的效果（举例说明）

//        1)先找本类，如果有，则调用（本类不受访问修饰符限制）
//        2)如果没有，则找父类，如果有且可以调用则调用
//        3)如果父类没有，则继续找父类的父类，规则同上,直到Object类
//        tips：如果查找方法的过程中找到了，但是不能访问，则报private access
//        如果直到Object类都没找到，则提示方法不存在（无法解析）
        cal();
        this.cal();//查找逻辑和cal()相同
        //super.cal();//首先从父类查起，跳过本类，除此之外，逻辑和cal()相同

        //属性和方法的原则相同
        System.out.println(n1);//输出888
        System.out.println(this.n1);//888
        System.out.println(super.n1);//100
    }
}

Super01

package com.hspedu.super_;

public class Super01 {
    public static void main(String[] args) {
        B b = new B();
        //b.eat();
        b.test();
    }
}