Java `.super` 关键字深入解析

简介

在 Java 编程中，.super 关键字是一个强大且重要的工具，它为我们提供了访问父类成员的途径。通过 .super，我们可以调用父类的构造方法、访问父类的属性和方法，这在处理继承关系时非常有用。本文将详细介绍 .super 的基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地掌握和运用这一关键字。

基础概念
使用方法
- 调用父类的构造方法
- 访问父类的属性
- 调用父类的方法
常见实践
- 重写方法时调用父类方法
- 子类构造方法中调用父类构造方法
最佳实践
- 合理使用 .super 避免代码冗余
- 遵循构造方法调用规则
小结
参考资料

基础概念

在 Java 中，.super 关键字主要用于引用父类的成员。当子类继承父类时，可能会出现子类的成员（属性或方法）与父类的成员重名的情况。此时，如果我们想在子类中访问父类的同名成员，就可以使用 .super 关键字。另外，在子类的构造方法中，我们也可以使用 .super 来调用父类的构造方法。

使用方法

调用父类的构造方法

在子类的构造方法中，我们可以使用 super() 或 super(参数列表) 来调用父类的构造方法。需要注意的是，super() 调用必须是子类构造方法中的第一条语句。

// 父类
class Parent {
    public Parent() {
        System.out.println("Parent 类的无参构造方法");
    }

    public Parent(int value) {
        System.out.println("Parent 类的有参构造方法，参数值为: " + value);
    }
}

// 子类
class Child extends Parent {
    public Child() {
        // 调用父类的无参构造方法
        super();
        System.out.println("Child 类的无参构造方法");
    }

    public Child(int value) {
        // 调用父类的有参构造方法
        super(value);
        System.out.println("Child 类的有参构造方法，参数值为: " + value);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("创建无参 Child 对象:");
        new Child();
        System.out.println("\n创建有参 Child 对象:");
        new Child(10);
    }
}

访问父类的属性

当子类的属性与父类的属性重名时，我们可以使用 super.属性名 来访问父类的属性。

class Parent {
    int num = 10;
}

class Child extends Parent {
    int num = 20;

    public void printNumbers() {
        System.out.println("子类的 num 值: " + num);
        System.out.println("父类的 num 值: " + super.num);
    }
}

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

调用父类的方法

当子类重写了父类的方法时，我们可以使用 super.方法名(参数列表) 来调用父类的原方法。

class Parent {
    public void show() {
        System.out.println("父类的 show 方法");
    }
}

class Child extends Parent {
    @Override
    public void show() {
        // 调用父类的 show 方法
        super.show();
        System.out.println("子类的 show 方法");
    }
}

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

常见实践

重写方法时调用父类方法

在子类重写父类方法时，有时候我们需要在子类的方法中先执行父类的原方法逻辑，再添加子类特有的逻辑。例如，在 toString() 方法中：

class Parent {
    @Override
    public String toString() {
        return "Parent 类的对象";
    }
}

class Child extends Parent {
    @Override
    public String toString() {
        // 先调用父类的 toString 方法
        return super.toString() + "，再加上子类的信息";
    }
}

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

子类构造方法中调用父类构造方法

在创建子类对象时，父类的初始化工作通常需要在子类的初始化之前完成。因此，我们可以在子类的构造方法中使用 super() 或 super(参数列表) 来调用父类的构造方法。

class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
        System.out.println("Animal 类的构造方法，名字为: " + name);
    }
}

class Dog extends Animal {
    public Dog(String name) {
        // 调用父类的构造方法
        super(name);
        System.out.println("Dog 类的构造方法，名字为: " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("旺财");
    }
}

最佳实践

合理使用 `.super` 避免代码冗余

在重写方法时，如果父类的方法已经实现了部分通用逻辑，我们应该合理使用 super.方法名() 来调用父类的方法，避免重复编写相同的代码。

遵循构造方法调用规则

在子类的构造方法中，super() 或 super(参数列表) 必须是第一条语句。如果不手动调用，Java 会默认在子类构造方法的第一行调用父类的无参构造方法。因此，当父类没有无参构造方法时，我们必须手动调用父类的有参构造方法。

小结

.super 关键字在 Java 中是一个非常重要的工具，它允许我们在子类中访问父类的成员。通过本文的介绍，我们了解了 .super 的基础概念、使用方法、常见实践以及最佳实践。合理使用 .super 可以帮助我们更好地处理继承关系，避免代码冗余，提高代码的可维护性和可扩展性。

参考资料

《Effective Java》
Java 官方文档
《Java 核心技术》

Java .super 关键字深入解析

简介

目录