Java中super() 和 this() 的区别

super() 和 this() 都用于进行构造函数调用。 super() 用于调用基类的构造函数(即父类)，而 this() 用于调用当前类的构造函数。

下面来详细看看它们：

super()

1、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 

程序执行流程：

• 在 main 中，我们做了一个 new Child() 语句，所以它调用了 Child 类的无参数构造函数。
• 在里面有 super() 调用 Parent 类的无参数，因为编写了 super() 并且没有参数，这就是它调用 Parent 类的无参数构造函数的原因，因为有一个 SOP 语句，因此它打印 Parent 类的 No arg 构造函数。
• 现在，随着 Parent 类的 No argument const 完成，flow 回到 Child 类的 no argument 并且有一个 SOP 语句，因此它打印 Flow 从 Parent class no arg const 返回。
• 在完成子类流的无参数构造函数之后，现在再次回到 main 并执行剩余的语句并在 Main 中打印。

2、只能在构造函数内部使用 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 类的无参数构造函数，在里面有 this(10) 它调用当前类的第一个参数(即 RR 类)
• 由于编写了 this(10) 和 1 个参数，它调用 RR 类的 1 个参数构造函数。 因为有一个 SOP 语句，因此它打印 RR 类的 1 arg const。
• 随着 RR 类的 1 参数 const 完成，flow 回到 RR 类的无参数，因为有一个 SOP 语句，因此它打印 Flow 从 RR 类的 1 arg const 回来。
• 在完成 RR 类流的无参数构造函数之后，现在再次回到 main 并执行剩余的语句并打印 Inside Main。

只能在构造函数中使用 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()仅用于引用当前类的构造函数。

关于 this() 和 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");     } } 

运行结果：

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

程序执行流程：

• 在 main 有 new Base() 然后流程转到基类的无参数构造函数。
• 之后，如果不放 super() 或 this() 代码，那么编译器默认放 super()。
• 所以流程转到"Parent class’s No arg constructor"而不是" 1 argument constructor"。
• 之后它会打印 Parent 类的无参数构造函数。
• 之后，当 Parent() 构造函数完成时，流程再次回到基类的无参数构造函数并执行下一个 SOP 语句，即基类的无参数构造函数。
• 完成无参数构造函数流程后，再次返回 main() 并打印 main() 内的剩余语句，即 Inside main。

但是，如果明确指定，可以在 super() 之前使用 this()。

// 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() 所以再次流转到基类的 No arg 构造函数，然后再次有了 this(30) 并再次流 到 Base 类的 1 个 arg 构造函数，它继续……就像一个递归。 所以它是无效的，这就是为什么得到编译时错误：递归构造函数调用。 所以java中不允许递归构造函数调用。