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。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。