构造函数

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关键字应该是该构造函数中的第一条语句。