非零基础自学Java (老师：韩顺平) 第8章 面向对象编程(中级部分) 8.9 super关键字

非零基础自学Java (老师：韩顺平)

✈【【零基础 快速学Java】韩顺平 零基础30天学会Java】

第8章 面向对象编程(中级部分)

8.9 super关键字

8.9.1 基本介绍

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

8.9.2 基本语法

1. 访问父类的属性【不能访问父类的private属性】

   super.属性名;
   1

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

   super.方法名(参数列表);
   1

3. 访问父类的构造器

   super(参数列表); //只能放在构造器的第一句，只能出现一次
   1

8.9.3 举个栗子

A类

package com.dingjiaxiong.super_;

/**
 * ClassName: A
 * date: 2022/9/3 10:40
 *
 * @author DingJiaxiong
 */

public class A extends Base{
    //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(){}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

B类

package com.dingjiaxiong.super_;

/**
 * ClassName: B
 * date: 2022/9/3 10:40
 *
 * @author DingJiaxiong
 */

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();
    }

    //访问父类的属性
    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方法
        //找 cal 方法时(cal() 和 this.cal())，顺序是:
        // (1)先找本类，如果有，则调用
        // (2)如果没有，则找父类(如果有，并可以调用，则调用)
        // (3)如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object 类
        // 提示：如果查找方法的过程中，找到了，但是不能访问， 则报错, cannot access
        // 如果查找方法的过程中，没有找到，则提示方法不存在
        super.cal();

        //调用自己的cal()
        cal();
        this.cal(); //这个和上面那个等价

        //访问属性的规则
        //n1 和 this.n1 查找的规则是
        //(1) 先找本类，如果有，则调用
        // (2) 如果没有，则找父类(如果有，并可以调用，则调用)
        //(3) 如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object 类
        // 提示：如果查找属性的过程中，找到了，但是不能访问， 则报错, cannot access
        // 如果查找属性的过程中，没有找到，则提示属性不存在
        System.out.println(n1);
        System.out.println(this.n1);

        System.out.println(super.n1);
    }

    //访问父类的方法
    //就private不能访问
    public void ok(){
        super.test100();
        super.test200();
        super.test300();
    }

    //访问父类的构造器
    public B(){
//        super();
//        super("Jack",10);
        super("Jack");
        //只能出现一个
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

父类

package com.dingjiaxiong.super_;

/**
 * ClassName: Base
 * date: 2022/9/3 10:41
 *
 * @author DingJiaxiong
 */

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()方法...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

调用类

package com.dingjiaxiong.super_;

/**
 * ClassName: Super01
 * date: 2022/9/3 10:41
 *
 * @author DingJiaxiong
 */

public class Super01 {
    public static void main(String[] args) {
        B b = new B();
        b.sum();
        b.test();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

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

8.9.5 super和this的比较