Java 中的 super 方法

简介

在 Java 面向对象编程中，super 关键字起着至关重要的作用，尤其是在处理继承关系时。super 关键字主要用于引用对象的直接父类对象。通过它，我们可以访问父类的属性、方法以及调用父类的构造函数。深入理解 super 方法对于编写高效、清晰且可维护的 Java 代码至关重要。

基础概念
使用方法
- 访问父类的属性
- 调用父类的方法
- 调用父类的构造函数
常见实践
- 重写方法时调用父类方法
- 初始化子类对象时调用父类构造函数
最佳实践
- 遵循里氏替换原则
- 确保代码清晰和可维护性
小结
参考资料

基础概念

super 关键字在 Java 中有三个主要用途：访问父类的属性、调用父类的方法以及调用父类的构造函数。当一个类继承自另一个类（父类）时，子类自动获得父类的属性和方法（在访问权限允许的情况下）。然而，有时候我们需要明确地使用 super 关键字来访问父类的特定成员。

使用方法

访问父类的属性

如果子类中有与父类同名的属性，直接访问该属性时会访问子类的属性。若要访问父类的同名属性，则需要使用 super 关键字。

class Parent {
    int value = 10;
}

class Child extends Parent {
    int value = 20;

    void printValues() {
        // 访问子类的 value
        System.out.println("Child's value: " + value);
        // 访问父类的 value
        System.out.println("Parent's value: " + super.value);
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.printValues();
    }
}

调用父类的方法

当子类重写了父类的方法时，若想在子类中调用父类的原始方法，可以使用 super 关键字。

class Animal {
    void makeSound() {
        System.out.println("Generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof!");
    }

    void makeParentSound() {
        super.makeSound();
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.makeParentSound();
    }
}

调用父类的构造函数

在子类的构造函数中，可以使用 super 关键字来调用父类的构造函数。super() 必须是子类构造函数中的第一条语句。

class Shape {
    String color;

    Shape(String color) {
        this.color = color;
    }
}

class Rectangle extends Shape {
    int width;
    int height;

    Rectangle(String color, int width, int height) {
        super(color);
        this.width = width;
        this.height = height;
    }

    void printInfo() {
        System.out.println("Color: " + color + ", Width: " + width + ", Height: " + height);
    }
}

public class Main {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle("Red", 5, 3);
        rectangle.printInfo();
    }
}

常见实践

重写方法时调用父类方法

在子类重写父类方法时，有时需要在子类方法中调用父类的原始实现。例如，在 JFrame 子类中重写 paint 方法时，可能需要先调用父类的 paint 方法来进行一些基本的绘制。

import javax.swing.*;
import java.awt.*;

class CustomFrame extends JFrame {
    @Override
    public void paint(Graphics g) {
        super.paint(g); // 调用父类的 paint 方法
        g.drawString("Custom content", 50, 50);
    }
}

public class Main {
    public static void main(String[] args) {
        CustomFrame frame = new CustomFrame();
        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}

初始化子类对象时调用父类构造函数

当创建子类对象时，通常需要先初始化父类部分的状态。通过在子类构造函数中使用 super()，可以确保父类的构造函数被正确调用，从而正确初始化继承的属性。

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }
}

class Student extends Person {
    int studentId;

    Student(String name, int studentId) {
        super(name);
        this.studentId = studentId;
    }

    void printInfo() {
        System.out.println("Name: " + name + ", Student ID: " + studentId);
    }
}

public class Main {
    public static void main(String[] args) {
        Student student = new Student("Alice", 12345);
        student.printInfo();
    }
}

最佳实践

遵循里氏替换原则

在使用 super 关键字时，应确保子类对象可以无缝地替换父类对象。这意味着子类重写的方法应保持与父类方法相同的语义，并且在调用父类方法时，不应破坏子类的行为。

确保代码清晰和可维护性

避免过度使用 super 关键字导致代码逻辑混乱。在调用父类方法或访问父类属性时，确保其目的明确，让代码易于理解和维护。

小结

super 关键字在 Java 的继承机制中扮演着关键角色。它允许我们访问父类的属性、方法以及调用父类的构造函数，从而在子类中实现对父类成员的有效利用。通过合理使用 super 关键字，我们可以编写更加健壮、清晰和可维护的面向对象代码。