Java中的构造函数是一种特殊的函数，它允许您创建对象的实例。 构造函数没有返回类型。
构造函数有两个要点：
- 构造函数的名字应该与class名称相同
- 构造函数没有任何返回类型，否则它将与其他方法一样。
Java中有以下3种类型的构造函数
- 默认构造函数
- 无参构造函数
- 参数化的构造函数
怎么调用一个构造函数
要调用构造函数，需要使用关键字new，接着是类的名称，然后是参数（如果有）。
例如：如果你想创建Employee类的对象，你可以这样调用构造函数：new Employee（）
构造函数的类型
默认构造函数
如果你没有为你的类创建一个构造函数，那么JVM将创建一个默认构造函数。它不会被你看到，JVM将在初始化类的对象时自动创建它。
让我们通过一个示例来理解它。
package org.constructor;
public class Employee {
String name;
int age;
public void workOnAssignment() {
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[]) {
Employee e1 = new Employee();
e1.setName("Leo");
e1.setAge(6);
System.out.println(e1.getName());
System.out.println(e1.getAge());
}
}
正如上面示例所示，我们并没有为这个类提供任何构造函数，但JVM将在这种情况下创建默认构造函数。
运行上面程序结果如下：
Leo
6
无参构造函数
无参构造函数是在类中明确提供的构造函数，且它没有任何参数。
package org.constructor;
public class Employee {
String name;
int age;
public Employee() {
System.out.println("Calling no arg constructor");
}
public void workOnAssignment() {
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[]) {
Employee e1 = new Employee();
e1.setName("Leo");
e1.setAge(6);
System.out.println(e1.getName());
System.out.println(e1.getAge());
}
}
Calling no arg constructor
Leo
6
如果你创建参数化构造函数，那么你创建类的时候需要小心。
让我们来看一个实例：
package org.constructor;
public class Employee {
String name;
int age;
public Employee(String name, int age) {
System.out.println("Calling Parameterized constructor");
this.name = name;
this.age = age;
}
public void workOnAssignment() {
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[]) {
Employee e1 = new Employee();
e1.setName("Leo");
e1.setAge(6);
System.out.println(e1.getName());
System.out.println(e1.getAge());
}
}
从上面示例中，你会发现在第38行有编译错误。 为什么这样？
因为如果你在类中创建参数化构造函数，JVM将不会为你提供默认构造函数。 如果你不写任何构造函数，那么JVM会为你提供默认的构造函数。
构造函数链
构造器链接指的是子类在内部或显式调用其父类的构造函数。
每当你用Java创建一个对象时，它的父类构造函数都会被调用。 编译器只是在内部将super()放在该对象的构造函数中。
我们来通过一个示例来理解它：
package org.constructor;
public class Person {
String name;
public Person() {
System.out.println("Calling Person constructor");
name = "John";
}
}
public class Employee extends Person {
int age;
public Employee() {
System.out.println("Calling Employee class constructor");
name = "Paul";
}
public void workOnAssignment() {
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[]) {
Employee e1 = new Employee();
System.out.println(e1.getName());
}
}
上面示例运行结果如下：
Calling Person constructor
Calling Employee class constructor
Paul
正如上例所示，起先Person类的构造函数被调用并且将它的变量name设置为“John”
然后Employee类的构造函数被调用，且将它的变量name重写为“Paul”。
这就是为什么我们最终看到变量的name为“Paul”。
怎样显式调用父类参数化构造函数呢？
只需简单地通过super关键字
package org.parameterized.constructor;
public class Person {
String name;
public Person(String name) {
this.name = name;
System.out.println("Calling Person Parameterized constructor");
}
}
public class Employee extends Person {
int age;
public Employee(String name) {
super(name);
System.out.println("Calling Employee class constructor");
}
public void workOnAssignment() {
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[]) {
Employee e1 = new Employee("Paul");
System.out.println("Employee's name:" + e1.getName());
}
}
示例程序运行结果如下：
Calling Person Parameterized constructor
Calling Employee class constructor
Employee's name:Paul
怎么调用同一个类的另一个构造函数？
你可通过this关键字来调用另一个构造函数
package org.constructor;
public class EmployeeNew {
String name;
int age;
public EmployeeNew() {
System.out.println("Calling No arg constructor");
}
public EmployeeNew(String name, int age) {
this();
System.out.println("Calling Parameterized constructor");
this.name = name;
this.age = age;
}
public void workOnAssignment() {
// Working on assignment
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String args[]) {
EmployeeNew e1 = new EmployeeNew("Paul", 36);
System.out.println("Employee's name : " + e1.getName());
System.out.println("Employee's age : " + e1.getAge());
}
}
示例代码运用结果如下：
Calling No arg constructor
Calling Parameterized constructor
Employee's name : Paul
Employee's age : 36
不过需要注意的是，用于调用重载构造函数的this关键字应该是该构造函数中的第一条语句。
