截止今天，小秋学习Java刚刚满三个月。此刻的小秋感觉自己Java学的还不错，想去帅地面前炫耀一番，于是，就发生了一下一番对话.....
得意的小秋
帅地：嗨，小秋，看你今天气色不错啊。最近Java学的怎么样了？
小秋：说实话，比起三个月前我学指针的那段日子，这Java太友好了，感觉就是分分种的事(暗自得意)。
帅地：我靠，你这口气还挺大啊。从c的面向过程到Java的面向对象，还习惯不？
小秋：哎，还行，无非就是“一切皆对象”，Java中的对象感觉类似于C中的结构体。反正不过三七二十一，我脑子里都把他们当成是一个对象就得了。(内心自我感觉良好)
帅地：看你也学了三个月了，要不我随便拿道题考考你？(让你不谦虚，暗自偷笑)
小秋：好啊，正好练练手(嘿嘿，终于可以展现实力了)。
重载多次的构造函数
帅地：假如有一个蛋糕Cake对象，蛋糕这个对象有一个必选属性size，还有一些可选属性apple,banana,orange,mango等，必选属性代表用户必须要指定蛋糕的大小，可选属性代表这些蛋糕要加哪些材料。
小秋：这个很简单啊，创建一个Cake类，里面有size,apple,banana,orange,mango属性，然后构造器的参数里指定size这个参数就可以了。我直接上代码吧：
public class Cake {
private int size;
private String apple;
private String banana;
private String orange;
private String mango;
//new时必须给出size
public Cake(int size) {
this.size = size;
}
}
帅地：可选参数呢？我要new一个size=30,并且添加apple的蛋糕怎么办？
小秋：哦，我写的太快，忘了重载了，稍等(心想，这还不简单)。
public class Cake {
private int size;
private String apple;
private String banana;
private String orange;
private String mango;
public Cake(int size) {
this.size = size;
}
public Cake(int size, String apple) {
this.size = size;
this.apple = apple;
}
public Cake(int size, String apple, String orange) {
this.size = size;
this.apple = apple;
this.orange = orange;
}
public Cake(int size, String apple, String orange, String mango) {
this.size = size;
this.apple = apple;
this.orange = orange;
this.mango = mango;
}
}
小秋：这下总可以了吧，你要加哪些料，你就使用哪个构造器。全部给你重载了。
帅地：(露出狡猾的表情)写构造函数倒是挺快的，那如果我要只加apple和mango的蛋糕呢？
小秋：啊？好吧，你这是逼我把所有组合的构造器都写出来。
于是，小秋把所有构造器的组合都写了出来。由于size是个必须参数，把其他四个可选参数进行组合，一共有16种。
噼里啪啦，劈里啪啦，小秋一口气把他们全部写出来了
public class Cake {
private int size;
private String apple;
private String banana;
private String orange;
private String mango;
public Cake(int size){
this.size = size;
}
public Cake(int size, String apple){
this.size = size;
this.apple = apple;
}
public Cake(int size, String banana){
this.size = size;
this.banana = banana;
}
.....
}
小秋：好了，这下，你要啥组合有啥组合了。
帅地：四个可选参数你就写了这么一大堆参数了。确定这样写？
小秋：我觉得挺好的啊，反正很快，多写几个就多写几个吧。
帅地：那如果给你6个可选参数呢？
这时候小秋偷偷算了一些，发现一共有74种组合？
小秋：不就是74种组合，我觉得问题不是很大(心有点虚)。
帅地：那万一有10个可选参数呢？
小秋：.....
帅地：而且你重载那么多构造器，用户在在new的时候，第一个参数和第二个参数代表什么，用户混乱了怎么吧？例如，你有个apple+banana的构造器
public Cake(int size, String apple, String banana){
this.size = size;
this.apple = apple;
this.banana = banana;
}
但是用户在new的时候，可能忘记了参数的顺序
Cake cake = new Cake(size,“banana”,“apple”)。
小秋：我会提供相应的文档啊，忘记了可以看文档勒。
帅地：几百个构造函数，而且还那么相似，你去看下文档试试，然后说说你的心情。
小秋：......(不知所措)。
通过Javabean的模式
帅地：有没其他什么办法？
小秋：我想到另一种办法了，我可以通过set和get方法来设置可选参数的。我直接上代码你看看
public class Cake {
private int size;
private String apple;
private String banana;
private String orange;
private String mango;
public Cake(int size) {
this.size = size;
}
//通过set来添加材料
public void setApple(String apple) {
this.apple = apple;
}
public void setBanana(String banana) {
this.banana = banana;
}
public void setMango(String mango) {
this.mango = mango;
}
public void setOrange(String orange) {
this.orange = orange;
}
}
此时的小秋有点得意....
帅地：挺不错，这种方法比刚才的好多了，又简洁。
此时如果要new一个apple+orange+mango的蛋糕的话，代码如下：
Cake cake = new Cake(30);
cake.setApple("apple");
cake.setOrange("orange");
cake.setMange("mange");
参数依赖检查问题
帅地：这种方法也是有缺点，例如用构造器重载时一行代码就可以搞定了，现在要用四行代码。
小秋：反正我觉得这样很nice(得意中...)。
帅地：不过这样写有一个致命的缺点，假如那些属性之间存在依赖性的话，怎么办？例如Cake多了A,B两个属性，并且这两个属性之间存在依赖关系。如果你设置了属性A,但是没有设置属性B，那么这个Cake对象就会出问题。或者属性的先后顺序设置也可能会导致出现问题。对于这种情况，你在什么地方检查这种相互依赖的逻辑？
小秋：有点蒙蔽，不知所措....。
小秋：那你说怎么办？
静态内部类
帅地：其实你已经做的相当不错了，不过我今天就教你另外一个办法，我们可以开放一个静态内部类专门用来与外界打交道，用来收集用户想要设置的属性并且做检查。直接上代码：
public class Cake {
private int size;
private String apple;
private String banana;
private String orange;
private String mango;
//private,让外面无法直接创建
private Cake(Builer builer) {
this.size = builer.size;
this.apple = builer.apple;
.....
}
//专门用来与外界打交道
public static class Builer {
private int size;
private String apple;
private String banana;
private String orange;
private String mango;
public void setSize(int size) {
this.size = size;
}
//为了省点代码，其他的省略
public Cake build() {
//检查参数之间的依赖关系是否正确
return new Cake(this);
}
.....
}
}
假如我要new一个apple+orange的Cake
Cake.Builer builer = new Cake.Builer();
builer.setSize(30);
builer.setApple("apple");
builer.setOrange("orange");
//创建一个蛋糕
Cake cake = builer.build();
帅地：这种方法牛吧？这还不够，我们还可以采用链式调用的方法。
链式调用
public class Cake {
private int size;
private String apple;
private String banana;
private String orange;
private String mango;
//private,让外面无法直接创建
private Cake(Builer builer) {
this.size = builer.size;
this.apple = builer.apple;
.....
}
//专门用来与外界打交道
public static class Builer {
private int size;
private String apple;
private String banana;
private String orange;
private String mango;
//返回参数改为Builer
public Builer setSize(int size) {
this.size = size;
return this;
}
public Builer setApple(String apple) {
this.apple = apple;
return this;
}
//为了省点代码，其他的省略
public Cake build() {
//检查参数之间的依赖关系是否正确
return new Cake(this);
}
}
}
如何使用？
Cake cake = new Cake.Builer()
.setSize(30)
.setApple("apple")
.setOrange("orange")
.build();
一行代码就搞定了。
帅地：厉害吧？
小秋：涨知识了，看来我还是太年轻了，以后得好好向帅地学习。
建造者模式
帅地：其实，上面那种方法算是23种设计模式中的其中一种---建造者模式。不过这只是一个简化版的建造者模式。
对于建造者模式，具体的UML图是这样的：
![]()
在这个UML图中，Builder是一个接口，定义一套规范，而我们使用的例子中，没有使用接口，直接使用具体类，但核心思想还是一样的。
其核心思想就是：将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
小秋：哇，强啊。我要给你点赞.....
算是第二次采取对话的方式写....，以后会多采取这种方式来写勒。
完
关注公我的众号：苦逼的码农，获取更多原创文章，后台回复礼包送你一份时下热门的资源大礼包。同时也感谢把文章介绍给更多需要的人
