Java 常识（013）：Java中的super关键字

矫情吗；* 2021-10-18 08:30 283阅读 0赞

### 文章目录 ###

*   *  1、Java 中 super 是什么
     *  2、为什么要用 super 关键字
     *  3、Java 中 super 的用法
     *   *  3.1、使用 super 调用父类的构造方法
         *  3.2、引用父类实例变量
         *  3.3、调用父类方法
     *  4、super 关键字与 this 关键字的区别

## 1、Java 中 super 是什么 ##

java中的super关键字是一个引用变量，用于引用直接父类对象。  
每当创建子类的实例时，父类的实例被隐式创建，由super关键字引用变量引用。

## 2、为什么要用 super 关键字 ##

由于子类不能继承父类的构造方法，因此，要调用父类的构造方法，必须在子类的构造方法体的第一行使用 super() 方法。该方法会调用父类相应的构造方法来完成子类对象的初始化工作。

## 3、Java 中 super 的用法 ##

java super关键字的用法如下：

*  调用父类的构造方法
 *  访问父类中实例变量
 *  访问父类的方法

### 3.1、使用 super 调用父类的构造方法 ###

Student 类继承了 Person 类，并且使用 super 来调用 Person 类的构造方法。这里需要注意一点：  
**super() 必须是在子类构造方法的第一行。**  
如果没有构造函数，编译器会自动提供默认构造函数。

public class Person {
        /**
         * 姓名
         */
        private String name;
        /**
         * 性别
         */
        private Integer sex;
        /**
         * 年龄
         */
        private Integer age;
    
        public Person(String name, Integer sex) {
            this.name = name;
            this.sex = sex;
            this.age = 10;
        }
    
        public Person(String name, Integer sex, Integer age) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
    }
    
    public class Student extends Person {
    
        /**
         * 手机号
         */
        private String mobile;
        /**
         * 联系地址
         */
        private String address;
    
        public Student(String name, Integer sex, Integer age, String mobile, String address) {
            //调用父类三个参数的构造函数
            super(name, sex, age);
            this.mobile = mobile;
            this.address = address;
        }
    
        public Student(String name, Integer sex){
            //调用父类两个参数的构造函数
            super(name,sex);
        }
    }

### 3.2、引用父类实例变量 ###

使用 super 访问父类中的成员变量与 this 关键字的使用相似，只不过它引用的父类。 如果父类和子类具有相同的字段，则使用 super 来设置或获取父类的字段，使用this 来设置或获取子类的字段

@Data
    public class Person {
        /**
         * 姓名
         */
        private String name;
        /**
         * 性别
         */
        private Integer sex;
        /**
         * 年龄
         */
        private Integer age;
    
        public Person() {
        }
    
        public Person(String name, Integer sex) {
            this.name = name;
            this.sex = sex;
            this.age = 10;
        }
    
        public Person(String name, Integer sex, Integer age) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
    }
    
    
    @Data
    public class Student extends Person {
    
        /**
         * 手机号
         */
        private String mobile;
        /**
         * 联系地址
         */
        private String address;
        /**
         * 名字
         */
        private String name;
    
        public Student(String parentName,String name, Integer sex, Integer age, String mobile, String address) {
            //引用父类实例变量
            super.setName(parentName);
            super.setSex(sex);
            super.setAge(age);
            this.name=name;
            this.mobile = mobile;
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "我是子类的name："+this.name+"\n"+"我是父类的name："+super.getName();
        }

**示例：**

public class SuperDemo {
        public static void main(String[] args) {
            //引用父类实例变量
            Student student = new Student("父类","子类", 1, 10, "15062598456", "中国");
            System.out.println(student.toString());
        }
    }

**输出：**

我是子类的name：子类
    我是父类的name：父类

### 3.3、调用父类方法 ###

super 关键字也可以用于调用父类方法。 如果子类包含与父类相同的方法，则可以使用 super 关键字调用父类的方法。

本示例中，Person 和 Student 两个类都有 whoAmI() 方法，Student 类对该方法进行了重写，同时使用 super 关键字调用了父类中的方法，最后输出结果如下。

@Data
    public class Person {
        /**
         * 姓名
         */
        private String name;
        /**
         * 性别
         */
        private Integer sex;
        /**
         * 年龄
         */
        private Integer age;
    
        public Person() {
        }
    
        public Person(String name, Integer sex) {
            this.name = name;
            this.sex = sex;
            this.age = 10;
        }
    
        public Person(String name, Integer sex, Integer age) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
    
        public void whoAmI() {
            System.out.println("我是父类Person");
        }
    }
    @Data
    public class Student extends Person {
    
        /**
         * 手机号
         */
        private String mobile;
        /**
         * 联系地址
         */
        private String address;
        /**
         * 名字
         */
        private String name;
        public  Student(){}
    
        public Student(String parentName,String name, Integer sex, Integer age, String mobile, String address) {
            //引用父类实例变量
            super.setName(parentName);
            super.setSex(sex);
            super.setAge(age);
            this.name=name;
            this.mobile = mobile;
            this.address = address;
        }
    
        @Override
        public void whoAmI(){
            super.whoAmI();
            System.out.println("我是子类Student");
        }
    
    
    }

**示例：**

public static void main(String[] args) {        
            Student student = new Student();
            student.whoAmI();
        }

**输出：**

我是父类Person
    我是子类Student

## 4、super 关键字与 this 关键字的区别 ##

*  super 关键字：调用**基类**中的构造函数、成员变量或方法
 *  this 关键字：调用**本类**中构造函数、成员变量或方法
 *  this 关键字：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）
 *  super 关键字：必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
 *  super 关键字与 this 关键字：都指的是对象，所以，不可以在static环境中使用。this 关键字在静态类中使用时，代表的是当前类。

参考资料：  
[https://docs.oracle.com/javase/tutorial/java/IandI/super.html][https_docs.oracle.com_javase_tutorial_java_IandI_super.html]

[https_docs.oracle.com_javase_tutorial_java_IandI_super.html]: https://docs.oracle.com/javase/tutorial/java/IandI/super.html