java 中的super关键字 · BeginnersBook 中文系列教程

# java 中的`super`关键字 > 原文： [https://beginnersbook.com/2014/07/super-keyword-in-java-with-example/](https://beginnersbook.com/2014/07/super-keyword-in-java-with-example/) `super`关键字指的是直接父类的对象。在学习`super`关键字之前，您必须具备 Java 中[继承](https://beginnersbook.com/2013/03/inheritance-in-java/)的知识，以便您能够理解本指南中给出的示例。 ## 使用`super`关键字 1）当父类和子类都具有相同名称的成员时访问父类的数据成员 2）显式调用父类的无参和参数化构造函数 3）访问父类的方法当子类重写该方法时的类。 **现在让我们借助示例**详细讨论它们： ### 1）如何使用`super`关键字访问父类的变量当子类中的变量已存在于父类中时，为了访问父类的变量，您需要使用`super`关键字。让我们举一个例子来理解这一点：在下面的程序中，我们在子类中声明了一个数据成员`num`，父类中已经存在同名的成员。如果不使用`super`关键字，则无法访问父类的`num`变量。。 ```java //Parent class or Superclass or base class class Superclass { int num = 100; } //Child class or subclass or derived class class Subclass extends Superclass { /* The same variable num is declared in the Subclass * which is already present in the Superclass */ int num = 110; void printNumber(){ System.out.println(num); } public static void main(String args[]){ Subclass obj= new Subclass(); obj.printNumber(); } } ``` 输出： ``` 110 ``` **访问父类的`num`变量：** 通过调用这样的变量，如果类（父类和子类）具有相同的变量，我们可以访问父类的变量。 ```java super.variable_name ``` 让我们采用我们在上面看到的相同示例，这次在`print`语句中我们传递`super.num`而不是`num`。 ```java class Superclass { int num = 100; } class Subclass extends Superclass { int num = 110; void printNumber(){ /* Note that instead of writing num we are * writing super.num in the print statement * this refers to the num variable of Superclass */ System.out.println(super.num); } public static void main(String args[]){ Subclass obj= new Subclass(); obj.printNumber(); } } ``` 输出： ``` 100 ``` 正如您通过使用`super.num`所看到的，我们访问了父类的`num`变量。 ### 2）使用`super`关键字来调用父类的构造函数当我们创建子类的对象时，`new`关键字调用子类的[构造函数](https://beginnersbook.com/2013/03/constructors-in-java/)，它隐式调用父类的构造函数。因此，当我们创建子类的对象时执行的顺序是：首先执行父类构造函数，然后执行子类构造函数。这是因为编译器本身添加了`super()`（这会调用父类的无参数构造函数）作为子类构造函数中的第一个语句。让我们看一个例子来理解我上面解释的内容： ```java class Parentclass { Parentclass(){ System.out.println("Constructor of parent class"); } } class Subclass extends Parentclass { Subclass(){ /* Compile implicitly adds super() here as the * first statement of this constructor. */ System.out.println("Constructor of child class"); } Subclass(int num){ /* Even though it is a parameterized constructor. * The compiler still adds the no-arg super() here */ System.out.println("arg constructor of child class"); } void display(){ System.out.println("Hello!"); } public static void main(String args[]){ /* Creating object using default constructor. This * will invoke child class constructor, which will * invoke parent class constructor */ Subclass obj= new Subclass(); //Calling sub class method obj.display(); /* Creating second object using arg constructor * it will invoke arg constructor of child class which will * invoke no-arg constructor of parent class automatically */ Subclass obj2= new Subclass(10); obj2.display(); } } ``` **输出：** ```java Constructor of parent class Constructor of child class Hello! Constructor of parent class arg constructor of child class Hello! ``` #### 参数化的`super()`调用来调用父类的参数化构造函数我们可以在子类的构造函数中显式调用`super()`，但它没有任何意义，因为它会是多余的。这就像明确地做一些其他方式隐含的事情。但是当我们在父类中有一个带有参数的构造函数时，我们可以使用参数化的超类，如`super(100);`从子类的构造函数中调用父类的[参数化构造函数](https://beginnersbook.com/2014/01/parameterized-constructor-in-java-example/)。让我们看一个例子来理解这个： ```java class Parentclass { //no-arg constructor Parentclass(){ System.out.println("no-arg constructor of parent class"); } //arg or parameterized constructor Parentclass(String str){ System.out.println("parameterized constructor of parent class"); } } class Subclass extends Parentclass { Subclass(){ /* super() must be added to the first statement of constructor * otherwise you will get a compilation error. Another important * point to note is that when we explicitly use super in constructor * the compiler doesn't invoke the parent constructor automatically. */ super("Hahaha"); System.out.println("Constructor of child class"); } void display(){ System.out.println("Hello"); } public static void main(String args[]){ Subclass obj= new Subclass(); obj.display(); } } ``` **输出：** ```java parameterized constructor of parent class Constructor of child class Hello ``` 在这个例子中有几点需要注意： 1）`super()`（或参数化的`super`必须是构造函数中的第一个语句，否则你将得到编译错误：“构造函数调用必须是构造函数中的第一个语句” 2）当我们在构造函数中明确地放置`super`时，java 编译器没有调用父类的默认无参构造函数。 ### 3）如何在方法覆盖的情况下使用`super`关键字当子类声明父类中已存在的相同方法时，这称为[方法覆盖](https://beginnersbook.com/2014/01/method-overriding-in-java-with-example/)。我们将在本系列的下一个教程中学习方法覆盖。现在您只需要记住这一点：当子类重写父类的方法时，从子类对象调用该方法总是调用该方法的子类版本。但是通过使用这样的`super`关键字：`super.method_name`可以调用父类的方法（被覆盖的方法）。在方法覆盖的情况下，使用这些术语：重写方法：父类的方法重写方法：子类的方法让我们举一个例子来理解这个概念： ```java class Parentclass { //Overridden method void display(){ System.out.println("Parent class method"); } } class Subclass extends Parentclass { //Overriding method void display(){ System.out.println("Child class method"); } void printMsg(){ //This would call Overriding method display(); //This would call Overridden method super.display(); } public static void main(String args[]){ Subclass obj= new Subclass(); obj.printMsg(); } } ``` **输出：** ```java Child class method Parent class method ``` #### 如果子类没有覆盖任何方法怎么办：不需要`super` 当子类没有覆盖父类方法时，我们不需要使用`super`关键字来调用父类方法。这是因为在这种情况下我们只有每个方法的一个版本，子类可以访问父类方法，所以我们可以直接调用父类的方法而不使用`super`。 ```java class Parentclass { void display(){ System.out.println("Parent class method"); } } class Subclass extends Parentclass { void printMsg(){ /* This would call method of parent class, * no need to use super keyword because no other * method with the same name is present in this class */ display(); } public static void main(String args[]){ Subclass obj= new Subclass(); obj.printMsg(); } } ``` **输出：** ```java Parent class method ```