JAVA中的隐式参数super

在Java中，`super` 关键字是一个非常重要的概念，它主要用于在子类中引用父类的成员（包括属性和方法）。虽然 `super` 并非传统意义上的“参数”，因为它不直接传递给方法，但它在访问父类成员时扮演着类似“隐式参数”的角色。这里，我们将详细探讨 `super` 的用法，并通过代码示例和注释来解释其工作机制。

 1. `super` 的基本用法

1.1 访问父类的属性

在子类中，如果子类与父类有同名的属性，则可以通过 `super` 关键字来明确指定访问的是父类的属性。

class Parent {
    int number = 10;
}

class Child extends Parent {
    int number = 20;

    void display() {
        System.out.println("Parent number: " + super.number); // 访问父类的number属性
        System.out.println("Child number: " + this.number);   // 访问子类的number属性
    }

    public static void main(String[] args) {
        Child c = new Child();
        c.display();
    }
}

1.2 调用父类的方法

如果子类重写了父类的方法，那么在子类中可以通过 `super` 关键字来调用父类中被重写的方法。

class Parent {
    void show() {
        System.out.println("This is Parent show()");
    }
}

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

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

 

1.3 调用父类的构造器

在子类的构造器中，`super()` 可以用来调用父类的构造器。如果省略 `super()` 调用，并且父类没有无参构造器，则会导致编译错误。

class Parent {
    Parent() {
        System.out.println("Parent Constructor");
    }

    Parent(String msg) {
        System.out.println(msg);
    }
}

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

    Child(String msg) {
        super(msg); // 调用父类的带参构造器
        System.out.println("Child Constructor with message");
    }

    public static void main(String[] args) {
        Child c1 = new Child();
        Child c2 = new Child("Hello from Child");
    }
}

 

 2. `super` 的深入讨论

2.1 `super` 在构造器中的限制

• `super()` 必须是子类构造器的第一条语句（除了注释和变量声明）。
• 如果父类没有无参构造器，并且子类构造器中没有显式调用父类的某个构造器，则会导致编译错误。
• 可以通过 `super` 调用父类的构造器，但无法直接访问父类的其他成员（属性和方法）直到构造器执行完毕。

2.2 `super` 与 `this` 的对比

• `this` 关键字用于引用当前对象。
• `super` 关键字用于引用当前对象的直接父类。
• 两者都可用于访问成员变量和方法，但 `this` 指向当前对象的成员，而 `super` 指向父类的成员。
• `this()` 和 `super()` 都必须放在构造器的第一行（如果有的话），但两者不能同时出现在同一个构造器中。

 3. `super` 在实际应用中的例子

3.1 继承中的方法覆盖与调用

在面向对象编程中，继承允许我们复用代码，并通过方法覆盖（Overriding）来修改或扩展父类的行为。`super` 在这种情况下非常有用，因为它允许我们调用被覆盖的父类方法。

class Animal {
    void eat() {
        System.out.println("Animal eats food.");
    }
}

class Dog extends Animal {
    @Override
    void eat() {
        super.eat(); // 调用父类的eat方法
        System.out.println("Dog eats meat.");
    }


    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat(); // 输出：Animal eats food. Dog eats meat.
    }
}

 

在这个例子中，我们定义了一个父类 `Animal` 和一个子类 `Dog`。在 `Dog` 类中，我们覆盖了 `eat()` 方法，并使用 `super.eat()` 来调用父类的实现。这样做的好处是，我们可以保留父类的默认行为，同时在子类中添加或修改它。

4. `super` 的最佳实践

• 当子类覆盖了父类的某个方法时，如果需要在子类的实现中调用父类的版本，应该使用 `super`。
• 在构造器中，确保使用 `super()` 来调用父类的构造器，除非你确定不需要这么做（例如，父类有默认的无参构造器）。
• 当使用 `this()` 时要小心，因为它只在构造器中有效，并且通常是为了调用另一个构造器，而不是为了调用 `super()`。
• 在子类中访问父类的成员时，尽量显式地使用 `super`，这有助于代码的可读性和可维护性。
• 避免在子类的方法中不必要地使用 `super`，因为这可能会干扰代码的逻辑并增加复杂性。只有当需要访问父类被覆盖的方法时才使用它。