1、静态工厂和构造器有个共同的局限性：它们都不能很好地扩展到大量的可选参数。比如用一个类表示包装食品外面显示的营养成分标签。这些标签中有几个域是必需的：每份的含量、每罐的含量以及每份的卡路里。还有超过2 0 个的可选域： 总脂肪量、饱和脂肪量、转化脂肪、胆固醇、纳，等等。大多数产品在某几个可选域中都会有非零的值。
2、对于这样的类，应该用哪种构造器或者静态工厂来编写呢？程序员一向习惯采用重叠构造器（ telescoping cons tructor ）模式，在这种模式下，提供的第一个构造器只有必要的参数，第二个构造器有一个可选参数，第三个构造器有两个可选参数，依此类推，最后一个构造器包含所有可选的参数。下面有个示例，为了简单起见，它只显示四个可选域
第一种方法 构造器
public class Computer {
private String cup;
private String keybord;
private String screen;
private String mouse;
private String hardDisk;
private String ram;
private String colour;
public Computer(String cup,String keybord) {
this(cup,keybord,"");
}
public Computer(String cup,String keybord,String screen) {
this(cup,keybord,screen,"");
}
public Computer(String cup,String keybord,String screen,String mouse) {
this(cup,keybord,screen,mouse,"");
}
public Computer(String cup,String keybord,String screen,String mouse,String hardDisk) {
this(cup,keybord,screen,mouse,hardDisk,"");
}
public Computer(String cup,String keybord,String screen,String mouse,String hardDisk,String ram) {
this(cup,keybord,screen,mouse,hardDisk,ram,"");
}
public Computer(String cup,String keybord,String screen,String mouse,String hardDisk,
String ram,String colour) {
this.cup = cup;
this.keybord = keybord;
this.screen = screen;
this.mouse = mouse;
this.hardDisk = hardDisk;
this.ram = ram;
this.colour = colour;
}
public static void main(String[] args) {
Computer computer = new Computer("I7","三星");
}
}
这个构造器调用通常需要许多你本不想设置的参数，但还是不得不为它们传递值。在这个例子中，我们给colour传递了一个值为"" 。如果“仅仅”是这7个参数，看起来还不算太糟糕，问题是随着参数数目加，它很快就失去了控制
简而言之，重叠构造器模式可行，但是当有许多参数的时候，客户端代码会很难缩写，并且仍然较难以阅读
遇到许多可选的构造器参数的时候，还有第二种代替办法，即JavaBeans 模式，在这种模式下，先调用一个无参构造器来创建对象，然后再调用setter 方法来设置每个必要的参数，以及每个相关的可选参数：
第二种方法
//实体类
public class Computer {
private String cup;
private String keybord;
private String screen;
private String mouse;
private String hardDisk;
private String ram;
private String colour;
public String getCup() {
return cup;
}
public void setCup(String cup) {
this.cup = cup;
}
public String getKeybord() {
return keybord;
}
public void setKeybord(String keybord) {
this.keybord = keybord;
}
public String getScreen() {
return screen;
}
public void setScreen(String screen) {
this.screen = screen;
}
public String getMouse() {
return mouse;
}
public void setMouse(String mouse) {
this.mouse = mouse;
}
public String getHardDisk() {
return hardDisk;
}
public void setHardDisk(String hardDisk) {
this.hardDisk = hardDisk;
}
public String getRam() {
return ram;
}
public void setRam(String ram) {
this.ram = ram;
}
public String getColour() {
return colour;
}
public void setColour(String colour) {
this.colour = colour;
}
}
遗憾的是， JavaBeans 模式自身有着很严重的缺点。因为构造过程被分到了几个调用中在构造过程中Java Bean 可能处于不一致的状态。类无法仅仅通过检验构造器参数的有效性来保证一致性。试图使用处于不一致状态的对象将会导致失败，这种失败与包含错误的代码大相径庭，因此调试起来十分困难。与此相关的另一点不足在于， Java Beans 模式使得把类做成不可变的可能性不复存在，这就需要程序员付出额外的努力来确保它的线程安全
我们现在来介绍第三种方式、它既能保证重叠构造器模式那样安全、也能像JavaBean那样可读。这就是建造之(Builder)模式。它不直接生成想要的对象，而是让客户端利用所有必要的参数调用构造器（或者静态工厂），得到一个builder 对象。然后客户端在builder 对象上调用类似于setter 的方法，来设置每个相关的可选参数。最后客户端调用无参的build 方法来生成通常是不可变的对象。
//实体类
public class ProduceComputer implements Serializable {
private String cup;
private String keybord;
private String screen;
private String mouse;
private String hardDisk;
private String ram;
private String colour;
public static class Comuterbuilder implements Serializable{
private String cup;
private String keybord;
private String screen;
private String mouse;
private String hardDisk;
private String ram;
private String colour;
public Comuterbuilder(String cup,String keybord) {
this.cup = cup;
this.keybord = keybord;
}
public Comuterbuilder screen(String screen) {
this.screen = screen;
return this;
}
public Comuterbuilder mouse(String mouse) {
this.mouse = mouse;
return this;
}
public Comuterbuilder hardDisk(String hardDisk) {
this.hardDisk = hardDisk;
return this;
}
public Comuterbuilder colour(String colour) {
this.colour = colour;
return this;
}
public Comuterbuilder ram(String ram) {
this.ram = ram;
return this;
}
public ProduceComputer build() {
return new ProduceComputer(this);
}
}
private ProduceComputer(Comuterbuilder comuterbuilder) {
cup = comuterbuilder.cup;
keybord = comuterbuilder.keybord;
screen = comuterbuilder.screen;
mouse = comuterbuilder.mouse;
hardDisk = comuterbuilder.hardDisk;
ram = comuterbuilder.ram;
colour = comuterbuilder.colour;
}
@Override
public String toString() {
return super.toString();
}
public String getCup() {
return cup;
}
public void setCup(String cup) {
this.cup = cup;
}
public String getKeybord() {
return keybord;
}
public void setKeybord(String keybord) {
this.keybord = keybord;
}
public String getScreen() {
return screen;
}
public void setScreen(String screen) {
this.screen = screen;
}
public String getMouse() {
return mouse;
}
public void setMouse(String mouse) {
this.mouse = mouse;
}
public String getHardDisk() {
return hardDisk;
}
public void setHardDisk(String hardDisk) {
this.hardDisk = hardDisk;
}
public String getRam() {
return ram;
}
public void setRam(String ram) {
this.ram = ram;
}
public String getColour() {
return colour;
}
public void setColour(String colour) {
this.colour = colour;
}
public static void main(String[] args) {
ProduceComputer produceComputer =
new ProduceComputer.Comuterbuilder("I7", "三星").colour("yellow").hardDisk("1G").build();
System.out.println(JSON.toJSONString(produceComputer));
}
}
Builder 模式十分灵活，可以利用单个builder 构建多个对象。build町的参数可以在调用build 方法来创建对象期间进行调整，也可以随着不同的对象而改变。builder 可以自动填充某些域，例如每次创建对象时自动增加序列号。
Builder 模式的确也有它自身的不足。为了创建对象，必须先创建它的构建器。虽然创建这个构建器的开销在实践中可能不那么明显但是在某些十分注重性能的情况下，可能就成问题了。Builder 模式还比重叠构造器模式更加冗长，因此它只在有很多参数的时候才使用，比如4 个或者更多个参数。但是记住，将来你可能需要添加参数。如果一开始就使用构造器或者静态工厂，等到类需要多个参数时才添加构造器，就会无法控制，那些过时的构造器或者静态工厂显得十分不协调。因此，通常最好一开始就使用构建器。
简而言之， 如果类的构造器或者静态工厂中具有多个参数，设计这种类时，
Builde 模式就是一种不错的选择， 特别是当大多数参数都是可选或者类型相同的时候。与使用重叠构造器模式相比，使用Bui lder 模式的客户端代码将更易于阅读和编写，构建器也比JavaBeans 更加安全。
