Java super()和this()的區別用法及代碼示例

類似的文章：super和此關鍵字super()以及this()都用於進行構造函數調用。 super()用於調用基類的構造函數(即，父類)，而this()用於調用當前類的構造函數。

讓我們詳細看看它們：

super()

super()用於調用基類的(父類的)構造函數。
```
// Java code to illustrate usage of super() 
  
class Parent { 
    Parent() 
    { 
        System.out.println("Parent class's No " +  
                              " arg constructor"); 
    } 
} 
  
class Child extends Parent { 
    Child() 
    { 
        super(); 
        System.out.println("Flow comes back from " +  
                        "Parent class no arg const"); 
    } 
    public static void main(String[] args) 
    { 
        new Child(); 
        System.out.println("Inside Main"); 
    } 
}
```
輸出：
```
Parent class's No arg constructor
Flow comes back from Parent class no arg const
Inside Main
```
程序流程：
- 總的來說，我們已經聲明了一個新的Child()語句，因此它調用了Child類的no參數構造函數。
- 在其中，我們有super()，因為我們已經編寫了super()，所以沒有調用Parent類的參數，這就是為什麽沒有調用Parent類的參數構造函數的原因，因為我們有一個SOP語句，因此它會打印出Parent類的No arg構造函數。
- 現在，當Parent類的No參數const完成時，流程返回到Child類的no參數，因為我們有一個SOP語句，因此它打印Flow從Parent類no arg const返回。
- 完成子類流的無參數構造函數之後，現在再次返回main並執行剩餘的語句並打印Inside Main。

我們隻能在構造函數內部使用super()，在其他任何地方都不能使用super()，即使在靜態上下文中也不可以在方法內部使用super()應該是構造函數內部的第一條語句。

// Java program to illustrate usage of 
// super() as first statement 
  
class Parent { 
    Parent() 
    { 
        System.out.println("Parent class's No " +  
                           "arg constructor"); 
    } 
}  
  
class Child extends Parent { 
    Child() 
    { 
        // Uncommenting below line causes compilation 
        // error because super() should be first statement 
        // System.out.println("Compile Time Error"); 
        super(); 
  
        System.out.println("Flow comes back from " +  
                       "Parent class no arg const"); 
    } 
  
    public static void main(String[] args) 
    { 
        new Child(); 
        System.out.println("Inside main"); 
    } 
}

輸出：

Parent class's No arg constructor
Flow comes back from Parent class no arg const
Inside main

注意：super()應該是任何構造函數中的第一條語句。它隻能在構造函數內部使用，不能在其他地方使用。 super()僅用於引用父類(超類)的構造函數。

this()

this()用於調用當前類的構造函數。
```
// Java code to illustrate usage of this() 
  
class RR { 
    RR() 
    { 
        this(10); 
        System.out.println("Flow comes back from " +  
                           "RR class's 1 arg const"); 
    } 
  
    RR(int a) 
    { 
        System.out.println("RR class's 1 arg const"); 
    } 
    public static void main(String[] args) 
    { 
        new RR(); 
        System.out.println("Inside Main"); 
    } 
}
```
輸出：
```
RR class's 1 arg const
Flow comes back from RR class's 1 arg const
Inside Main
```
程序流程：
- 首先從main開始，然後在其中聲明new Child()，從而調用Child類的no參數構造函數，在其中包含this(10)，其調用當前類的1參數(即RR類)
- 由於我們已經編寫了this(10)和1個參數，因此才調用RR類的1個參數構造函數。因為我們有一個SOP語句，因此它輸出RR類的1 arg常量。
- 現在，當RR類的1參數const完成時，流程回到RR類的no參數，因為我們有一個SOP語句，因此它輸出Flow從RR類的1 arg const返回。
- 此外，在完成RR類流程的無參數構造函數之後，現在再次返回main並執行剩餘的語句並打印Inside Main。

我們隻能在構造函數內部使用this()，在其他任何地方都不能使用this()，即使在靜態上下文中也不可以在方法內部使用this()應該是構造函數內部的第一條語句。

// Java program to illustrate usage of 
// this() as first statement 
  
class RR { 
    RR() 
    { 
        // Uncommenting below line causes compilation 
        // error because this() should be first statement 
        // System.out.println("Compile Time Error"); 
        this(51); 
        System.out.println("Flow comes back from RR " +  
                                 "class 1 arg const"); 
    } 
    RR(int k) 
    { 
        System.out.println("RR class's 1 arg const"); 
    } 
    public static void main(String[] args) 
    { 
        new RR(); 
        System.out.println("Inside main"); 
    } 
}

輸出：

RR class's 1 arg constructor
Flow comes back from RR class 1 arg const
Inside main

注意：this()應該是任何構造函數中的第一條語句。它隻能在構造函數內部使用，不能在其他地方使用。 this()僅用於引用當前類的構造函數。

Important points about this() and super()

我們隻能在構造函數中使用一次super()和this()。如果我們兩次使用super()或兩次this()或super()，然後使用this()或this()，然後使用super()，則立即出現編譯時錯誤，即可以在構造函數中將super()或this()用作第一個語句，而不能同時使用。

由您決定是否使用super()或this()，因為如果我們不使用this()或super()，則默認情況下編譯器會將super()用作構造函數中的第一條語句。

// Java program to illustrate super() by default 
// executed by compiler if not provided explicitly 
  
class Parent { 
    Parent() 
    { 
        System.out.println("Parent class's No " + 
                          "argument constructor"); 
    } 
    Parent(int a) 
    { 
        System.out.println("Parent class's 1 argument" +  
                                      " constructor"); 
    } 
  
} 
  
class Base extends Parent { 
    Base() 
    { 
        // By default compiler put super()  
        // here and not super(int) 
        System.out.println("Base class's No " +  
                        "argument constructor"); 
    } 
    public static void main(String[] args) 
    { 
        new Base(); 
        System.out.println("Inside Main"); 
    } 
}

Output:
Parent class's No argument constructor
Base class's No argument constructor
Inside Main

程序流程：

在main內部，我們有新的Base()，然後流程轉到Base類的No參數構造函數。
之後，如果我們既不放置super()也不放置this()，則默認情況下編譯器放置super()。
因此，流程轉到Parent類的No arg構造函數而不是1個參數構造函數。
之後，它會顯示父類的No參數構造函數。
之後，當Parent()構造函數完成時，流程又回到基類的No參數構造函數，並執行下一個SOP語句，即Base類的No參數構造函數。
完成此操作後，無參數構造器流程將再次返回main()並在main()內部打印其餘語句，即在內部main

但是，如果明確指定，則可以在超級之前使用this()。

// Java program to illustrate super() put by  
// compiler always if not provided explicitly 
  
class Parent { 
    Parent() 
    { 
        System.out.println("Parent class's No " +  
                           "argument constructor"); 
    } 
    Parent(int a) 
    { 
        System.out.println("Parent class's one " +  
                           " argument constructor"); 
    } 
} 
  
class Base extends Parent { 
    Base() 
    { 
        this(10); 
        System.out.println("No arg const"); 
    } 
    Base(int a) 
    { 
        this(10, 20); 
        System.out.println("1 arg const"); 
    } 
    Base(int k, int m) 
    { 
        // See here by default compiler put super(); 
        System.out.println("2 arg const"); 
    } 
    public static void main(String[] args) 
    { 
        new Base(); 
        System.out.println("Inside Main"); 
    } 
}

輸出：

Parent class's No argument constructor
2 arg const
1 arg const
No arg const
Inside Main

不允許遞歸構造函數調用
```
// Java program to illustrate recursive  
// constructor call not allowed 
  
class RR { 
    RR() 
    { 
        this(30); 
    } 
    RR(int a) 
    { 
        this(); 
    } 
    public static void main(String[] args) 
    { 
        new RR(); 
    } 
}
```
輸出：
```
Compile time error saying recursive constructor invocation
```
程序流程：在此，從main()開始，然後轉到RR類的No arg構造函數。之後，我們有this(30)，並且流轉到RR的1個arg構造函數，並且因為我們有this()，所以又有一個流向基類的無arg構造函數，在那之後，我們又有this(30)，並且流又回到1基本類的arg構造函數，它像遞歸一樣繼續進行。因此，這是無效的，這就是我們收到編譯時錯誤並指出遞歸構造函數調用的原因。因此在Java中不允許遞歸構造函數調用。

相關用法

注：本文由純淨天空篩選整理自GeeksforGeeks大神的英文原創作品 Difference between super() and this() in java。非經特殊聲明，原始代碼版權歸原作者所有，本譯文未經允許或授權，請勿轉載或複製。