Java中的构造函数重载过程类似于方法重载，这意味着在一个类中，我们可以拥有多个构造函数，其中构造函数的参数数量有所不同。

重载构造函数有什么用

Java中的构造函数重载带来了根据需要初始化对象的灵活性。例如，在ArrayList类中，有一个无参构造函数，它使用默认容量初始化ArrayList，还有另一个构造函数，可以将初始容量作为参数传递，以使用所需的初始容量来初始化ArrayList。

Java中的构造函数重载帮助的另一种情况是，当已经有参数化的构造函数时，提供一个无参数的构造函数。
如果类中未提供构造函数，则Java会隐式插入一个默认的no-arg构造函数。如果我们自己提供构造函数，则不会自动提供此默认的无参数构造函数。

public class ConstructorDemo {
  int num;
  String name;
  // Parameterized constructor
  private ConstructorDemo(int num, String name){
    this.num = num;
    this.name = name;
  }

  public static void main(String[] args) {
    ConstructorDemo cd = new ConstructorDemo();// Compiler error
  }
}

在此类中，有一个参数化的构造函数，因此Java不会自动提供默认的no-arg构造函数。因此，语句ConstructorDemo cd = new ConstructorDemo();导致编译时错误"构造函数ConstructorDemo()未定义"

在这种情况下，我们可以提供多个构造函数，以根据需要灵活地进行对象初始化。像上面的示例一样，我们还可以具有默认的no-arg构造函数以及参数化的构造函数。

public class ConstructorDemo {
  int num;
  String name;
  // Parameterized constructor
  private ConstructorDemo(int num, String name){
    this.num = num;
    this.name = name;
  }
	
  // no-arg constructor
  private ConstructorDemo(){
    
  }

  public static void main(String[] args) {
    ConstructorDemo cd = new ConstructorDemo();
  }
}

构造函数重载示例

这是构造函数重载的示例，其中有一个类型为Object的数组。如果未传递初始容量，则使用no-arg构造函数中的默认容量创建该数组。如果传递了初始容量，则调用具有初始容量的构造函数作为参数来创建具有传递的初始容量的数组。

public class MyList {
  Object[] elementArray;
  private static final int DEFAULT_CAPACITY = 10;

  public MyList(int initialCapacity) {
    this.elementArray = new Object[initialCapacity];
  }
  public MyList(){
    this.elementArray = new Object[DEFAULT_CAPACITY];
  }
  public static void main(String[] args) {
    MyList myList1 = new MyList();
    System.out.println("Array Length- " + myList1.elementArray.length);
    
    MyList myList2 = new MyList(20);
    System.out.println("Array Length- " + myList2.elementArray.length);
  }
}

输出：

Array Length- 10
Array Length- 20

Java中构造方法重载最佳实践

如果有多个构造函数，则应在其中一个构造函数中执行初始化任务。所有其他构造函数最终都应使用此关键字调用该构造函数进行初始化。

一个示例将有助于清除它。考虑这样一种情况：班级中有3个字段，并且希望提供一个选项来初始化它们中的所有一个或者两个，或者仅初始化一个或者一个。

public class ConstrChaining {
  int a;
  double b;
  String name;
  ConstrChaining(){
    this(0);
  }
  ConstrChaining(int a){
    this(a, 0.0);
  }
  ConstrChaining(int a, double b){
    this(a, b, null);
  }
  ConstrChaining(int a, double b, String name){
    this.a = a;
    this.b = b;
    this.name = name;
  }
  public static void main(String[] args) {
    ConstrChaining cc = new ConstrChaining();
    System.out.println("a- " + cc.a + " b- " + cc.b + " name- " + cc.name);
    
    ConstrChaining cc1 = new ConstrChaining(5, 7.8);
    System.out.println("a- " + cc1.a + " b- " + cc1.b + " name- " + cc1.name);
    
    ConstrChaining cc2 = new ConstrChaining(18, 13.45, "theitroad");
    System.out.println("a- " + cc2.a + " b- " + cc2.b + " name- " + cc2.name);
  }
}

输出：

a- 0 b- 0.0 name- null
a- 5 b- 7.8 name- null
a- 18 b- 13.45 name- theitroad

在示例中，我们可以看到初始化仅由以下构造函数完成

ConstrChaining(int a, double b, String name){
  this.a = a;
  this.b = b;
  this.name = name;
}

所有其他重载的构造函数都在逐步调用此构造函数以完成对象初始化。