Java创建对象的方法清单 —— 原来还可以这样创建对象

本文结合《Effective Java》第二章《创建和销毁对象》和自己的理解及实践，介绍了两种比使用构造器更优雅的创建对象方法，文章发布于专栏Effective Java，欢迎读者订阅。

静态工厂方法创建对象

使用静态工厂方法代替构造器去创建对象，有很多的优点，由于内容比较独立，此前已经单独成篇，篇幅不多，建议读者在阅读下面内容之前，先浏览一下

Java静态工厂方法 —— 有了它，你还需要工厂模式吗

构建器  多构造参数时创建对象的利器

无论是使用构造函数，还是使用上面介绍的静态工厂方法，在遇上需要多个可选构造参数时，都不能有很好的扩展性。

举个例子，一个类，创建时有一个必填参数，五个可选参数，那么，如果采用构造器的方法，就要提供

构造器1： 包含1个必填参数

构造器2： 包含1个必填参数，1个可选参数

构造器3： 包含1个必填参数，2个可选参数

依此类推...

这种方式叫做重叠构造器模式，下面代码就是上面这种思路的一个例子：

public class NutritionFacts {
private final int servingSize; // (mL) required
private final int servings; // (per container) required
private final int calories; // optional
private final int fat; // (g) optional
private final int sodium; // (mg) optional
private final int carbohydrate; // (g) optional

public NutritionFacts(int servingSize, int servings) {
this(servingSize, servings, 0);
}

public NutritionFacts(int servingSize, int servings,
int calories) {
this(servingSize, servings, calories, 0);
}

public NutritionFacts(int servingSize, int servings,
int calories, int fat) {
this(servingSize, servings, calories, fat, 0);
}

public NutritionFacts(int servingSize, int servings,
int calories, int fat, int sodium) {
this(servingSize, servings, calories, fat, sodium, 0);
}

public NutritionFacts(int servingSize, int servings,
int calories, int fat, int sodium, int carbohydrate) {
this.servingSize = servingSize;
this.servings = servings;
this.calories = calories;
this.fat = fat;
this.sodium = sodium;
this.carbohydrate = carbohydrate;
}

public static void main(String[] args) {
NutritionFacts cocaCola =
new NutritionFacts(240, 8, 100, 0, 35, 27);
}
}

这样的代码显然是不可以接受的，一方面，写这个类的人需要提供很多构造函数，另一方面，使用这个构造函数的人，需要非常仔细的按照顺序给构造函数传入参数，如果不小心颠倒了其中两个参数的顺序，就会造成错误的发生。
当然，我们可以不在创建对象的时候就给对象的属性赋值呀，我们可以采用setter方法嘛，这也是一种方法，叫JavaBean模式。

举个例子：

public class NutritionFacts {
// Parameters initialized to default values (if any)
private int servingSize = -1; // Required; no default value
private int servings = -1; // " " " "
private int calories = 0;
private int fat = 0;
private int sodium = 0;
private int carbohydrate = 0;

public NutritionFacts() { }

// Setters
public void setServingSize(int val) { servingSize = val; }
public void setServings(int val) { servings = val; }
public void setCalories(int val) { calories = val; }
public void setFat(int val) { fat = val; }
public void setSodium(int val) { sodium = val; }
public void setCarbohydrate(int val) { carbohydrate = val; }

public static void main(String[] args) {
NutritionFacts cocaCola = new NutritionFacts();
cocaCola.setServingSize(240);
cocaCola.setServings(8);
cocaCola.setCalories(100);
cocaCola.setSodium(35);
cocaCola.setCarbohydrate(27);
}
}
这样子看似不错，但遗憾的是，这种方法存在两个缺陷：
1. 这种方法，使得构造的过程分成了好几个过程，在这几个过程中，对象处于不同的状态，而我们无法保证，在这个过程中间，对象不会被用来做其他的事。

2. 这种方法，阻止了把类做成不可变类的的可能，因为不可变类的示例一旦创建，就不会让外界去改变它的。

幸运的是，我们还有第三种方法，也就是今天要讲的——构建器模式，这种方法，不直接创建想要的对象，而是首先使用必要参数，创建一个bulider对象，然后使用类似于set的方法，给builder对象赋予需要的可选参数，最后调用bulider对象的bulider方法，最终创建想要的对象。

举个例子：

public class NutritionFacts {
private final int servingSize;
private final int servings;
private final int calories;
private final int fat;
private final int sodium;
private final int carbohydrate;

public static class Builder {
// Required parameters
private final int servingSize;
private final int servings;

// Optional parameters - initialized to default values
private int calories = 0;
private int fat = 0;
private int carbohydrate = 0;
private int sodium = 0;

public Builder(int servingSize, int servings) {
this.servingSize = servingSize;
this.servings = servings;
}

public Builder calories(int val)
{ calories = val; return this; }
public Builder fat(int val)
{ fat = val; return this; }
public Builder carbohydrate(int val)
{ carbohydrate = val; return this; }
public Builder sodium(int val)
{ sodium = val; return this; }

public NutritionFacts build() {
return new NutritionFacts(this);
}
}

private NutritionFacts(Builder builder) {
servingSize = builder.servingSize;
servings = builder.servings;
calories = builder.calories;
fat = builder.fat;
sodium = builder.sodium;
carbohydrate = builder.carbohydrate;
}
}
客户端调用代码：
public static void main(String[] args) {
NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8).
calories(100).sodium(35).carbohydrate(27).build();
}
使用构建器模式，代码变得更容易编写，易于阅读。同时避免了JavaBean模式将一个对象的创建过程拆分成子过程的缺点。

使用单例模式创建单例类

单例模式，是指把一个类设计成为只允许有一个实例的方法，这里也作为创建对象的知识点放在这篇文章吧，不过我就不自己讲了，因为已经有人讲的非常完美。这里安利一篇讲单例模式的文章，讲的非常全面 
Hi，我们再来聊一聊Java的单例吧

总结

构造函数并不是创建对象的首先方式，我们还可以采用静态工厂方法和构建器的方式去创建对象。

如果一个类的实例需要传入多个必填和可选参数，我们可以考虑使用构建器模式。