SCI实验万事屋

菜单

面向对象编程(进阶) 5-super关键字
Zemise
Zemise
发布于 2023-06-12 / 44 阅读 / 0 评论 / 0 点赞

面向对象编程(进阶) 5-super关键字

#Java

5.1 super前言

在Java类中使用super来调用父类中的指定操作：

  • super可用于访问父类中定义的属性
  • super可用于调用父类中定义的成员方法
  • super可用于在子类构造器中调用父类的构造器

总体来说，和this关键字挺像的，只是super默认的是父类

注意：

  • 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
  • super的追溯不仅限于直接父类
  • super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

5.2 super的使用场景

5.2.1 子类中调用父类被重写的方法

  • 如果子类没有重写父类的方法，只要权限修饰符允许，在子类中完全可以直接调用父类的方法；
  • 如果子类重写了父类的方法，在子类中需要通过super.才能调用父类被重写的方法，否则默认调用的子类重写的方法
public class Phone {
    public void sendMessage() {
        System.out.println("发短信");
    }

    public void call() {
        System.out.println("打电话");
    }

    public void showNum() {
        System.out.println("来电显示号码");
    }
}

//Smartphone：智能手机
public class SmartPhone extends Phone {
    //重写父类的来电显示功能的方法
    public void showNum() {
        //来电显示姓名和图片功能
        System.out.println("显示来电姓名");
        System.out.println("显示头像");

        //保留父类来电显示号码的功能
        super.showNum(); //此处必须加super.，否则就是无限递归，那么就会栈内存溢出
    }
}

总结：

  • 方法前面没有super.和this.
    • 先从子类找匹配方法，如果没有，再从直接父类找，再没有，继续往上追溯
  • 方法前面有this.
    • 先从子类找匹配方法，如果没有，再从直接父类找，再没有，继续往上追溯
  • 方法前面有super. 从当前子类的直接父类找，如果没有，继续往上追溯

其实日常写的代码中，相当于前面默认有个this

5.2.2 子类中调用父类中同名的成员变量

  • 如果实例变量与局部变量重名，可以在实例变量前面加this.进行区别
  • 如果子类实例变量和父类实例变量重名，并且父类的该实例变量在子类仍然可见，在子类中要访问父类声明的实例变量需要在父类实例变量前加super.，否则默认访问的是子类自己声明的实例变量
  • 如果父子类实例变量没有重名，只要权限修饰符允许，在子类中完全可以直接访问父类中声明的实例变量，也可以用this.实例访问，也可以用super.实例变量访问
class Father {
    int a = 10;
    int b = 11;
}

class Son extends Father {
    int a = 20;

    public void test() {
        //子类与父类的属性同名，子类对象中就有两个a
        System.out.println("子类的a：" + a); //20  先找局部变量找，没有再从本类成员变量找
        System.out.println("子类的a：" + this.a); //20   先从本类成员变量找
        System.out.println("父类的a：" + super.a); //10    直接从父类成员变量找

        //子类与父类的属性不同名，是同一个b
        System.out.println("b = " + b); //11  先找局部变量找，没有再从本类成员变量找，没有再从父类找
        System.out.println("b = " + this.b); //11   先从本类成员变量找，没有再从父类找
        System.out.println("b = " + super.b); //11  直接从父类局部变量找
    }

    public void method(int a, int b) {
        //子类与父类的属性同名，子类对象中就有两个成员变量a，此时方法中还有一个局部变量a
        System.out.println("局部变量的a：" + a); //30  先找局部变量
        System.out.println("子类的a：" + this.a); //20  先从本类成员变量找
        System.out.println("父类的a：" + super.a); //10  直接从父类成员变量找

        System.out.println("b = " + b); //13  先找局部变量
        System.out.println("b = " + this.b); //11  先从本类成员变量找
        System.out.println("b = " + super.b); //11  直接从父类局部变量找
    }
}

class Test {
    public static void main(String[] args) {
        Son son = new Son();
        son.test();
        son.method(30, 13);
    }
}

总结：起点不同（就近原则）

  • 变量前面没有super.和this.
    • 在构造器、代码块、方法中如果出现使用某个变量，先查看是否是当前块声明的局部变量，
    • 如果不是局部变量，先从当前执行代码的本类去找成员变量
    • 如果从当前执行代码的本类中没有找到，会往上找父类声明的成员变量（权限修饰符允许在子类中访问的）
  • 变量前面有this.
    • 通过this找成员变量时，先从当前执行代码的本类去找成员变量
    • 如果从当前执行代码的本类中没有找到，会往上找==父类声明的成员变量==（权限修饰符允许在子类中访问的）
  • 变量前面super.
    • 通过super找成员变量，直接从当前执行代码的直接父类去找成员变量（权限修饰符允许在子类中访问的）
    • 如果直接父类没有，就去父类的父类中找（权限修饰符允许在子类中访问的）

==特别说明：应该避免子类声明和父类重名的成员变量==

在阿里的开发规范等文档中都做出明确说明：

【强制】避免在子父类的成员变量之间、或者不同代码块的局部变量之间采用完全相同的命名， 使可读性降低。

说明：子类、父类成员变量名相同，即使是 public 类型的变量也是能够通过编译，而局部变量在同一方法内的不同代码块中同名也是合法的，但是要避免使用。对于非 setter/getter 的参数名称也要避免与成员变量名称相同。

5.2.3 子类构造器中调用父类构造器

① 子类继承父类时，不会继承父类的构造器。只能通过“super(形参列表)”的方式调用父类指定的构造器。

② 规定：“super(形参列表)”，必须声明在构造器的首行。

③ 前面讲过，在构造器的首行可以使用"this(形参列表)"，调用本类中重载的构造器， 结合②，结论：在构造器的首行，“this(形参列表)” 和 "super(形参列表)"只能二选一。

④ 如果在子类构造器的首行既没有显示调用"this(形参列表)“，也没有显式调用"super(形参列表)”， 则子类此构造器默认调用"super()"，即调用父类中空参的构造器。

⑤ 由③和④得到结论：子类的任何一个构造器中，要么会调用本类中重载的构造器，要么会调用父类的构造器。只能是这两种情况之一。

⑥ 由⑤得到：一个类中声明有n个构造器，最多有n-1个构造器中使用了"this(形参列表)“，则剩下的那个一定使用"super(形参列表)”。

开发中常见错误：

如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有空参的构造器，则编译出错。

情景举例1：

class A {

}

class B extends A {

}

class Test {
    public static void main(String[] args) {
        B b = new B();
        // A类和B类都是默认有一个无参构造，B类的默认无参构造中还会默认调用A类的默认无参构造
        // 但是因为都是默认的，没有打印语句，看不出来
    }
}

情景举例2：

class A {
    A() {
        System.out.println("A类无参构造器");
    }
}

class B extends A {
    
}

class Test {
    public static void main(String[] args) {
        B b = new B();
        // A类显示声明一个无参构造，
        // B类默认有一个无参构造，
        // B类的默认无参构造中会默认调用A类的无参构造
        // 可以看到会输出“A类无参构造器”
    }
}

情景举例3：

class A {
    A() {
        System.out.println("A类无参构造器");
    }
}

class B extends A {
    B() {
        System.out.println("B类无参构造器");
    }
}

class Test {
    public static void main(String[] args) {
        B b = new B();
        //A类显示声明一个无参构造，
        //B类显示声明一个无参构造，
        //B类的无参构造中虽然没有写super()，但是仍然会默认调用A类的无参构造
        //可以看到会输出“A类无参构造器"和"B类无参构造器"
    }
}

情景举例4：

class A {
    A() {
        System.out.println("A类无参构造器");
    }
}

class B extends A {
    B() {
        super();
        System.out.println("B类无参构造器");
    }
}

class Test {
    public static void main(String[] args) {
        B b = new B();
        //A类显示声明一个无参构造，
        //B类显示声明一个无参构造，
        //B类的无参构造中明确写了super()，表示调用A类的无参构造
        //可以看到会输出“A类无参构造器"和"B类无参构造器"
    }
}

情景举例5：

class A {
    A(int a) {
        System.out.println("A类有参构造器");
    }
}

class B extends A {
    B() {
        System.out.println("B类无参构造器");
    }
}

class Test05 {
    public static void main(String[] args) {
        B b = new B();
        // A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
        // B类显示声明一个无参构造，
        // B类的无参构造没有写super(...)，表示默认调用A类的无参构造
        // 编译报错，因为A类没有无参构造
    }
}

情景举例6：

class A {
    A(int a) {
        System.out.println("A类有参构造器");
    }
}

class B extends A {
    B() {
        super();
        System.out.println("B类无参构造器");
    }
}

class Test06 {
    public static void main(String[] args) {
        B b = new B();
        //A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
        //B类显示声明一个无参构造，
        //B类的无参构造明确写super()，表示调用A类的无参构造
        //编译报错，因为A类没有无参构造
    }
}

情景举例8：

以下是Java代码的复原：

```
class A {
    A() {
        System.out.println("A类无参构造器");
    }
    A(int a) {
        System.out.println("A类有参构造器");
    }
}

class B extends A {
    B() {
        super();
        System.out.println("B类无参构造器");
    }
    B(int a) {
        super(a);
        System.out.println("B类有参构造器");
    }
}

class Test8 {
    public static void main(String[] args) {
        B b1 = new B();
        B b2 = new B(10);
    }
}
```

5.3 小结：this与super

5.3.1 this和super的意义

this：当前对象

  • 在构造器和非静态代码块中，表示正在new的对象
  • 在实例方法中，表示调用当前方法的对象

super：引用父类声明的成员

5.3.2 this和super的使用格式

  • this
    • this.成员变量：表示当前对象的某个成员变量，而不是局部变量
    • this.成员方法：表示当前对象的某个成员方法，完全可以省略this.
    • this()或this(实参列表)：调用另一个构造器协助当前对象的实例化，只能在构造器首行，只会找本类的构造器，找不到就报错
  • super
    • super.成员变量：表示当前对象的某个成员变量，该成员变量在父类中声明的
    • super.成员方法：表示当前对象的某个成员方法，该成员方法在父类中声明的
    • super()或super(实参列表)：调用父类的构造器协助当前对象的实例化，只能在构造器首行，只会找直接父类的对应构造器，找不到就报错
Java基础数据结构 1.2 二分查找法
面向对象编程(进阶) 4-修饰权限

评论