首页 > 编程笔记 > Java笔记 阅读：19

Java super的3种用法（附带实例）

在 Java 程序中，当子类继承父类后，有时候需要访问父类的一些成员变量或方法，这时可以使用 super 关键字来调用这些成员变量或方法。

super关键字的用法有 3 种，分别是：
1) 在子类的构造方法中，访问父类的构造方法。语法格式如下： 
super([参数列表])

2) 在子类的成员方法中，访问父类的成员变量。语法格式如下： 
super.成员变量

3) 在子类的成员方法中，访问父类的成员方法。语法格式如下： 
super.成员方法([实参列表])

Java super访问父类构造方法

在 Java 程序中，即使没有指明子类调用父类的构造方法，程序执行时还是会先调用父类中的无参构造方法，以便进行成员初始化操作。

那么，当父类中有多个构造方法时，如何才能调用父类中的某个特定构造方法呢？

Java 语言出于安全性的考虑，对于对象的初始化要求是非常严格的。例如，Java 要求一个父类的对象要在子类运行前完全初始化。

super 关键字可以用于在子类构造方法中调用父类的构造方法：
接下来，通过一个案例演示 super 关键字访问父类构造方法。 
class Animal { // 动物类
    private String name;
    private int age;
    public Animal() {
        System.out.println("调用了动物类的无参构造方法");
    }
    public Animal(String name, int age) {
        System.out.println("调用了动物类的有参构造方法");
        this.name = name;
        this.age = age;
    }
    public void show() {
        System.out.println("名字:" + name + ", 年龄: " + age);
    }
}

class Dog extends Animal { // 动物类的子类Dog类
    String color;
    public Dog() { // 子类无参构造方法
        System.out.println("调用了狗类的无参构造方法");
    }
    public Dog(String name, int age, String c) { // 子类有参构造方法
        super(name, age); // 调用父类的有参构造方法
        color = c;
        System.out.println("调用了狗类的有参构造方法");
        System.out.println(color + "的狗狗");
    }
}

public class Demo {
    public static void main(String[] args) {
        Dog d1 = new Dog();
        d1.show();
        System.out.println("----------------------");
        Dog d2 = new Dog("花花", 8, "黄色");
        d2.show();
    }
}
程序的运行结果如下：

调用了动物类的无参构造方法
调用了狗类的无参构造方法
名字:null，年龄：0
----------------------
调用了动物类的有参构造方法
调用了狗类的有参构造方法
黄色的狗狗
名字:花花，年龄：8

程序中 Dog 类继承自 Animal 类，Animal 类有两个成员变量 name 和 age，还有 1 个无参构造方法和 1 个有参构造方法，在子类 Dog 类的有参构造方法中（第 22 行）使用 super(name,age) 将参数 name 和 age 传递到父类 Animal 的有参构造方法内，因此只要子类的有参构造方法被调用，其父类对应的有参构造方法也会被调用。

第 32 行代码调用 Dog 类的无参构造方法 Dog()，该构造方法会自动调用父类中对应的无参构造方法 Animal()，然后再执行自己的构造方法 Dog()。

第 35 行代码调用子类带 3 个参数的构造方法，该方法通过子类的有参构造方法语句 super(name,age) 调用父类的有参构造方法（第 7 行）。如果第 23 行代码不在子类构造方法的首行，则会编译报错“Call to 'super()' must be first statement in constructor body”，中文含义为“对 super 的调用必须是构造器中的第 1 个语句”，因为在程序里面先执行的是子类的操作，而后才是父类初始化过程，这明显是不对的。

Java super访问父类成员变量和成员方法

在子类中使用 super 关键字除了可以访问父类的构造方法外，还可以访问父类的成员变量和成员方法，但是 super 关键字不能访问子类的成员。

接下来，通过一个案例来演示 super 访问父类的成员变量和成员方法。 
class Animal {
    protected String name;
    protected int age;
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void show() {
        System.out.println("父类名字:" + name + ", 年龄: " + age);
    }
}

class Dog extends Animal {
    String color;
    int age = 10;
    public Dog(String xm, int age, String c) {
        super.name = xm;
        super.age = age;
        color = c;
    }
    public void show() {
        System.out.println("子类Dog中的成员变量age:" + age);
        super.show(); // 调用父类的show()方法
        System.out.println("子类Dog, " + color + "的狗狗");
    }
}

public class Demo {
    public static void main(String[] args) {
        Dog d1 = new Dog("花花", 11, "黄色");
        d1.show();
    }
}
程序的运行结果如下：

子类Dog中的成员变量age:10
父类名字:花花，年龄：11
子类Dog，黄色的狗狗

程序中，子类 Dog 的构造方法没有使用 super 关键字来调用父类的有参构造方法，在父类 Animal 的第 2 行和第 3 行代码中将成员变量 name 和 age 声明为 protected 的，可以在子类构造方法中对父类的成员变量进行访问（第 19 行和第 20 行）。

同样，由于父类的 show() 方法声明为 public 的（第 10 行），所以可以在子类的普通方法中使用 super 关键字来调用（第 25 行）。

相关文章