一段对话讲完建造者模式

截止今天，小秋学习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是一个接口，定义一套规范，而我们使用的例子中，没有使用接口，直接使用具体类，但核心思想还是一样的。

其核心思想就是：将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

小秋：哇，强啊。我要给你点赞…..

算是第二次采取对话的方式写….，以后会多采取这种方式来写勒。

完

关注公我的众号：苦逼的码农，获取更多原创文章，后台回复礼包送你一份时下热门的资源大礼包。同时也感谢把文章介绍给更多需要的人

我的世界，不止有coding，还有writing