super关键字

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第19天，点击查看活动详情

super关键字

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

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

   super.属性名；

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

      super.方法名（参数列表）；

      3. 访问父类的构造器：

         super(参数列表)；只能放在构造器第一句！！！

package com.hspedu.super_;
public class A extends Base{//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() {
}
}

package com.hspedu.super_;
public class Base { //基类，它的父类是 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_;
public class Super01 {
public static void main(String[] args) {//主方法
B b = new B();//子类对象
//b.sum();
b.test();
}
}

package com.hspedu.super_;
public class B extends A {//B类
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)如果没有，则找父类(如果有，并可以调用，则调用)
// (3)如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object 类
// 提示：如果查找方法的过程中，找到了，但是不能访问， 则报错, cannot access
// 如果查找方法的过程中，没有找到，则提示方法不存在
    //这就是双亲委派机制
//cal();
this.cal(); //等价 cal
//找 cal 方法(super.call()) 的顺序是直接查找父类，其他的规则一样
//super.cal();
//演示访问属性的规则
//n1 和 this.n1 查找的规则是
//(1) 先找本类，如果有，则调用
//(2) 如果没有，则找父类(如果有，并可以调用，则调用)
//(3) 如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object 类
// 提示：如果查找属性的过程中，找到了，但是不能访问， 则报错, cannot access
// 如果查找属性的过程中，没有找到，则提示属性不存在
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 方法
}
//访问父类的构造器(这点前面用过)：super(参数列表);只能放在构造器的第一句，只能出现一句！
public B() {
//super();
//super("jack", 10);
super("jack");
}
}

super带来的便利/细节

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

super和this的比较