一文了解 Java 中的构造器

C ++ 引入了构造器（constructor，也叫构造函数）的概念，它是在创建对象时被自动调用的特殊方法。

Java 也采用了构造器，并且还提供了一个垃圾收集器（garbage collector），当不再使用内存资源的时候，垃圾收集器会自动将其释放。

构造器定义

在 Java 中，可以通过编写构造器来确保每个对象的初始化。但是这里有两个问题：

1. 这个构造器使用的任何名字都有可能与类里某个成员相冲突；
2. 编译器负责调用构造器，所以它必须始终知道应该调用哪个方法。

C++ 语言采用的方案就是将构造器和类的名字定义相同，Java 也采用了这个方案。

构造器的作用是用来建立一个新的类的实例，当一个对象被创建时，JVM 使用一个构造函数，并为其分配内存空间。

语法结构

1class ClassName {
2 ClassName() {
3 }
4}

例如，在下面的示例中，我们创建了一个名为 ReLearnConstructor 的构造函数。在构造函数内部，我们正在初始化 hello 变量的值。：

1public class ReLearnConstructor {
2
3String hello; // 属性
4 // 构造器
5public ReLearnConstructor() {
6hello = "Hello, Constructor!";
7}
8
9public static void main(String[] args) {
10
11ReLearnConstructor rc = new ReLearnConstructor();
12System.out.println(rc.hello);
13}
14}

注意创建 ReLearnConstructor 类的对象的语句：ReLearnConstructor rc = new ReLearnConstructor ();

在这里，当创建对象时，调用 ReLearnConstructor 构造函数。并且，hello 变量的值被初始化。

因此打印的 hello 的值为:

构造器目的

构造函数的目的是初始化对象的状态，为所有声明的属性赋值。如果我们没有自定义构造函数，JVM 就会为这些属性分配默认值。

原始类型的默认值：

• 整数类型是 0
• 浮点类型是 0.0
• 布尔类型是 false

对于其他 Java 引用类型，默认值是 null，这意味着引用类型的属性没有被分配任何值。

后面可以用代码查看这些默认值。

构造器分类

在 Java 中，有三种类型的构造器：

1. 无参构造器
2. 有参构造器
3. 默认构造器

无参构造器

与方法类似，Java 构造函数可能有参数，也可能没有任何参数。如果构造函数不接受任何参数，则称为无参数构造器。例如上述代码中 ReLearnConstructor 构造器就是：

1// 无参构造器
2public ReLearnConstructor() {
3hello = "Hello, Constructor!";
4}

有参构造器

字面理解，具有参数的构造函数称为有参数构造器。那为什么需要使用有参构造器？

有参构造器可用于为不同对象提供不同初始化的值。 例如：

1public class ReLearnConstructor {
2
3String languages;
4
5// 接受单个参数的构造器
6public ReLearnConstructor(String lang) {
7languages = lang;
8System.out.println("我在学习 " + languages + " 语言!");
9}
10
11public static void main(String[] args) {
12// 向构造器中传入不同的值
13ReLearnConstructor rc1 = new ReLearnConstructor("Java");
14ReLearnConstructor rc2 = new ReLearnConstructor("Go");
15ReLearnConstructor rc3 = new ReLearnConstructor("Python");
16}
17}

运行结果：

默认构造器

如果我们不创建任何构造函数，Java 编译器会在程序执行期间自动创建一个无参数构造函数。这个构造函数称为默认构造函数。来看一个例子；

1public class ReLearnConstructor {
2
3String languages;
4int a;
5boolean b;
6float c;
7public static void main(String[] args) {
8ReLearnConstructor rc = new ReLearnConstructor();
9System.out.println("默认值：");
10System.out.println("languages:" + rc.languages);
11System.out.println("a:" + rc.a);
12System.out.println("b:" + rc.b);
13System.out.println("c:" + rc.c);
14}
15}

运行结果：

1默认值：
2languages:null
3a:0
4b:false
5c:0.0

可以看到，我们还没有创建任何构造函数。因此，Java 编译器会自动创建默认构造函数。上述表格得以印证。

原生方法和构造器的区别

• 构造函数必须与在 Java 中定义的类具有相同的名称
• 当方法没有返回任何值时，构造函数不会返回任何类型，而方法则具有返回类型或 void
• 在对象创建时，仅调用构造函数一次，而方法可以被调用任何次数

如果我们不用构造器来给属性赋值的话，可以先使用 new 运算符获取类的实例，并使用类的 setter 方法设置值，如下：

1import java.util.Arrays;
2class Person
3{
4 private String name;
5 private int age;
6    @Override
7 public String toString() {
8 return Arrays.asList(name, String.valueOf(age)).toString();
9 }
10 public void setName(String name) {
11 this.name = name;
12 }
13 public void setAge(int age) {
14 this.age = age;
15 }
16 // getters
17}
18// Initialize an object in Java
19class Main
20{
21 public static void main(String[] args)
22 {
23        Person person = new Person();
24 person.setName("Yuzhou1su");
25 person.setAge(22);
26 System.out.println(person);
27 }
28}

通过构造器进行初始化就可以省去我们的 setter 方法。

如下的例子：

1import java.util.Arrays;
2class Person {
3 private String name;
4 private int age;
5 // 构造器
6 public Person(String name, int age) {
7 this.name = name;
8 this.age = age;
9 }
10 public String toString() {
11 return Arrays.asList(name, String.valueOf(age)).toString();
12 }
13}
14class SimpleConstructor {
15 public static void main(String[] args) {
16        Person person = new Person("Yuzhou1su", 22);
17 System.out.println(person);
18 }
19}

运行结果：

1[Yuzhou1su, 22]

构造器重载

与 Java 方法重载类似，我们也可以创建两个或多个具有不同参数的构造函数。这称为构造函数重载。

1public class ReLearnConstructor {
2
3String language;
4
5public ReLearnConstructor() {
6this.language = "Java";
7}
8
9// 构造器
10public ReLearnConstructor(String language) {
11this.language = language;
12}
13
14public void getName() {
15System.out.println("编程语言：" + this.language);
16}
17
18public static void main(String[] args) {
19ReLearnConstructor rc1 = new ReLearnConstructor();
20
21ReLearnConstructor rc2 = new ReLearnConstructor("Python");
22
23rc1.getName();
24rc2.getName();
25}
26}

在上面的例子中，我们有两个构造函数：ReLearnConstructor () 和 ReLearnConstructor (String language)。在这里，两个构造函数都用不同的值初始化变量语言的值。根据创建对象时传递的参数，调用不同的构造函数，分配不同的值。

运行结果：

1编程语言：Java
2编程语言：Python

拷贝构造器

Java 中的拷贝构造方法是一种使用该类的一个对象构造另外一个对象的构造方法。

复制构造函数是一种特殊构造函数，用于将新对象创建为现有对象的副本。它只需要一个参数，它将是同一类的另一个实例。我们可以使用 this () 语句从复制构造函数中显式调用另一个构造函数:

1public class ReLearnConstructor {
2
3private String language;
4
5// 构造器
6public ReLearnConstructor(String language) {
7this.language = language;
8}
9
10// 拷贝构造器
11public ReLearnConstructor(ReLearnConstructor rc) {
12this.language = rc.language;
13}
14
15public void getName() {
16System.out.println("编程语言：" + this.language);
17}
18
19public static void main(String[] args) {
20ReLearnConstructor rc = new ReLearnConstructor("Python");
21
22ReLearnConstructor copyOfrc = new ReLearnConstructor(rc);
23
24rc.getName();
25copyOfrc.getName();
26}
27}

运行结果：

1编程语言：Python
2编程语言：Python

当需要拷贝一个带有多个成员变量的复杂对象或者想构造已存在对象的深拷贝对象时非常有用。

匿名内部类

除了上文介绍的使用构造器的方法，另一种初始化对象的方法是使用 “双大括号初始化”。这将创建一个匿名内部类，其中只有一个实例初始化程序。建议不要使用这种方法。

1import java.util.Arrays;
2class Person
3{
4 private String name;
5 private int age;
6    @Override
7 public String toString() {
8 return Arrays.asList(name, String.valueOf(age)).toString();
9 }
10 public void setName(String name) {
11 this.name = name;
12 }
13 public void setAge(int age) {
14 this.age = age;
15 }
16 // getters
17}
18// Initialize an object in Java
19class Main
20{
21 public static void main(String[] args)
22 {
23 // Anonymous class
24        Person person = new Person() {{
25 // Initializer block
26 setName("Yuzhou1su");
27 setAge(22);
28 }};
29 System.out.println(person);
30 }
31}

总结

以上环境博主都是部署在cnaaa云服务器上，感兴趣的伙伴可以自己也部署一套相同的环境进行测试。

• 实例化对象时会隐式调用构造函数。
• 创建构造函数的两条规则是：构造函数的名称应与类相同。Java 构造函数不能有返回类型。
• 如果一个类没有构造函数，Java 编译器会在运行时自动创建一个默认构造函数。默认构造函数使用默认值初始化实例变量。例如 int 变量将被初始化为 0
• 构造函数类型：
• 无参构造器 - 不接受任何参数的构造函数参数化构造函数
• 接受参数的构造器 - 接受参数的构造函数
• 默认构造器 - 如果没有明确定义，Java 编译器会自动创建一个构造函数。
• 构造函数不能被 abstract、static 或 final 修饰

编译器会报如下错误：

1Illegal modifier for the constructor in type ReLearnConstructor; only public, protected & private are permitted

• 构造函数可以重载但不能被覆盖