# 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 ```