第1条：考虑用静态工厂方法代替构造器
通常情况下，我们创建一个对象采取new的形式，但是还有一种方法也是经常使用到的，它的名称叫做静态工厂方法。
例如，java中基本类型boolean的包装类Boolean就采用了这种方式，源代码如下：
public static Boolean valueOf(boolean b) {
return (b ? TRUE : FALSE);
}
当然，除了valueOf这种比较low的名字之外，我们常用的还有getInstance(最常见)，newInstance，getType等。
静态工厂方法相对于构造器，好处多多。
①静态工厂方法有名称，而构造器是固定的。
例如，BigInteger的构造方法返回一个数字。如果想返回一个随机素数，用名为BigInteger.probablePrime的静态方法表示显然会更加清晰易读。
②不必每次调用的时候都创建一个新的对象。
这使得不可变类可以使用预先构建好的实例，或者将构建好的实例缓存起来重复利用，从而避免创建不必要的重复对象。例如上例中的Boolean.valueOf(boolean b)方法，调用它时，它从来没有创建对象。
③它可以返回原返回类型的任何子类型对象。
这里就不得不提及以下简单工厂模式，大家在平时开发中使用频率极高。
例如，有物理型英雄和法术型英雄，想要根据传入的类型获取对应的英雄。
public abstract class Hero {
}
public class APHero extends Hero {
@Override
public String toString() {
return "法术型英雄";
}
}
public class ADHero extends Hero {
@Override
public String toString() {
return "物理型英雄";
}
}
使用静态工厂方法就可以获取到指定的子类型，大大增加了可扩展性。
public class HeroFactory {
APHero ap = new APHero();
ADHero ad = new ADHero();
public Hero getHeroInstance(String type){
switch(type){
case "AP":return ap;
case "AD":return ad;
default: return null;
}
}
}
第2条：遇到多个构造器参数时考虑用构建器
静态工厂和构造器有个共同的局限性：它们都不能很好地扩展到大量的可选参数。
有时候会碰到这样的情况，一个类里面属性很多，有些是必须的，有些是可选的。这样一来，普通的构造方法就得写一大堆(因为创建对象时可能性太多了)。
还有一种方法也是我们最常用的，就是构造方法就用默认的，每个属性都添加get set方法（JavaBean）。这样创建一个实例很容易，代码也清晰很多。但遗憾的是JavaBean自身有很严重的缺点，因为构造过程被分到了若个个调用中，可能出现不一致状态，导致多线程操作时不安全。
构建器方法既能保证安全性，又能保证可读性。下面大家来看一个例子(食品上的营养成分表)：
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 {
// 必需参数
private final int servingSize;
private final int servings;
// 不必需参数
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;
}
//注意这里，跟Javabean很像，设置了一系列属性之后，Builder调用build方法构建真正的对象
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;
}
}
在客户端我们就可以使用类似于jquery中连缀的这种语法来创建对象了
public static void main(String[] args) {
NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8)
.calories(100).sodium(35).carbohydrate(27).build();
}
实际上，就相当于将NutritionFacts类将创建对象的功能委托给了静态内部类Builder。而且，因为static类本身是线程安全的，也避免了javabean的缺陷。