一段对话讲完建造者模式

截止今天，小秋学习Java刚刚满三个月。此刻的小秋感觉自己Java学的还不错，想去帅地面前炫耀一番，于是，就发生了一下一番对话…..

得意的小秋

帅地：嗨，小秋，看你今天气色不错啊。最近Java学的怎么样了？

小秋：说实话，比起三个月前我学指针的那段日子，这Java太友好了，感觉就是分分种的事(暗自得意)。

帅地：我靠，你这口气还挺大啊。从c的面向过程到Java的面向对象，还习惯不？

小秋：哎，还行，无非就是“一切皆对象”，Java中的对象感觉类似于C中的结构体。反正不过三七二十一，我脑子里都把他们当成是一个对象就得了。(内心自我感觉良好)

帅地：看你也学了三个月了，要不我随便拿道题考考你？(让你不谦虚，暗自偷笑)

小秋：好啊，正好练练手(嘿嘿，终于可以展现实力了)。

重载多次的构造函数

帅地：假如有一个蛋糕Cake对象，蛋糕这个对象有一个必选属性size，还有一些可选属性apple,banana,orange,mango等，必选属性代表用户必须要指定蛋糕的大小，可选属性代表这些蛋糕要加哪些材料。

小秋：这个很简单啊，创建一个Cake类，里面有size,apple,banana,orange,mango属性，然后构造器的参数里指定size这个参数就可以了。我直接上代码吧：

publicclassCake{
  privateintsize;
  privateString apple;
  privateString banana;
  privateString orange;
  privateString mango;
  //new时必须给出size
  publicCake(intsize){
    this.size = size;
  }
}

代码片段可以左右拉动

帅地：可选参数呢？我要new一个size=30,并且添加apple的蛋糕怎么办？

小秋：哦，我写的太快，忘了重载了，稍等(心想，这还不简单)。

publicclassCake{
  privateintsize;
  privateString apple;
  privateString banana;
  privateString orange;
  privateString mango;

  publicCake(intsize){
    this.size = size;
  }

  publicCake(intsize,String apple){
    this.size = size;
    this.apple = apple;
  }
  publicCake(intsize,String apple,String orange){
    this.size = size;
    this.apple = apple;
    this.orange = orange;
  }
  publicCake(intsize,String apple,String orange,String mango){
    this.size = size;
    this.apple = apple;
    this.orange = orange;
    this.mango = mango;
  }
}

小秋：这下总可以了吧，你要加哪些料，你就使用哪个构造器。全部给你重载了。

帅地：(露出狡猾的表情)写构造函数倒是挺快的，那如果我要只加apple和mango的蛋糕呢？

小秋：啊？好吧，你这是逼我把所有组合的构造器都写出来。

于是，小秋把所有构造器的组合都写了出来。由于size是个必须参数，把其他四个可选参数进行组合，一共有16种。

噼里啪啦，劈里啪啦，小秋一口气把他们全部写出来了

publicclassCake{
  privateintsize;
  privateString apple;
  privateString banana;
  privateString orange;
  privateString mango;
  
  publicCake(intsize){
    this.size = size;
  }

  publicCake(intsize,String apple){
    this.size = size;
    this.apple = apple;
  }
  publicCake(intsize,String banana){
    this.size = size;
    this.banana = banana;
  }
  .....
}

小秋：好了，这下，你要啥组合有啥组合了。

帅地：四个可选参数你就写了这么一大堆参数了。确定这样写？

小秋：我觉得挺好的啊，反正很快，多写几个就多写几个吧。

帅地：那如果给你6个可选参数呢？

这时候小秋偷偷算了一些，发现一共有74种组合？

小秋：不就是74种组合，我觉得问题不是很大(心有点虚)。

帅地：那万一有10个可选参数呢？

小秋：…..

帅地：而且你重载那么多构造器，用户在在new的时候，第一个参数和第二个参数代表什么，用户混乱了怎么吧？例如，你有个apple+banana的构造器

publicCake(intsize,String apple,String banana){
  this.size = size;
  this.apple = apple;
  this.banana = banana;

但是用户在new的时候，可能忘记了参数的顺序

Cake cake = newCake(size,“banana”,“apple”)。

小秋：我会提供相应的文档啊，忘记了可以看文档勒。

帅地：几百个构造函数，而且还那么相似，你去看下文档试试，然后说说你的心情。

小秋：……(不知所措)。

通过Javabean的模式

帅地：有没其他什么办法？

小秋：我想到另一种办法了，我可以通过set和get方法来设置可选参数的。我直接上代码你看看

publicclassCake{
  privateintsize;
  privateString apple;
  privateString banana;
  privateString orange;
  privateString mango;

  publicCake(intsize){
    this.size = size;
  }

  //通过set来添加材料
  publicvoidsetApple(String apple){
    this.apple = apple;
  }

  publicvoidsetBanana(String banana){
    this.banana = banana;
  }

  publicvoidsetMango(String mango){
    this.mango = mango;
  }

  publicvoidsetOrange(String orange){
    this.orange = orange;
  }
}

此时的小秋有点得意….

帅地：挺不错，这种方法比刚才的好多了，又简洁。

此时如果要new一个apple+orange+mango的蛋糕的话，代码如下：

Cake cake = newCake(30);
cake.setApple("apple");
cake.setOrange("orange");
cake.setMange("mange");

参数依赖检查问题

帅地：这种方法也是有缺点，例如用构造器重载时一行代码就可以搞定了，现在要用四行代码。

小秋：反正我觉得这样很nice(得意中…)。

帅地：不过这样写有一个致命的缺点，假如那些属性之间存在依赖性的话，怎么办？例如Cake多了A,B两个属性，并且这两个属性之间存在依赖关系。如果你设置了属性A,但是没有设置属性B，那么这个Cake对象就会出问题。或者属性的先后顺序设置也可能会导致出现问题。对于这种情况，你在什么地方检查这种相互依赖的逻辑？

小秋：有点蒙蔽，不知所措….。

小秋：那你说怎么办？

静态内部类

帅地：其实你已经做的相当不错了，不过我今天就教你另外一个办法，我们可以开放一个静态内部类专门用来与外界打交道，用来收集用户想要设置的属性并且做检查。直接上代码：

publicclassCake{
  privateintsize;
  privateString apple;
  privateString banana;
  privateString orange;
  privateString mango;
  //private,让外面无法直接创建
  privateCake(Builer builer){
    this.size = builer.size;
    this.apple = builer.apple;
    .....
  }

  //专门用来与外界打交道
  publicstaticclassBuiler{
    privateintsize;
    privateString apple;
    privateString banana;
    privateString orange;
    privateString mango;
    publicvoidsetSize(intsize){
      this.size = size;
    }
    //为了省点代码，其他的省略
    publicCake build(){
      //检查参数之间的依赖关系是否正确
      returnnewCake(this);
    }
    .....
  }
}

假如我要new一个apple+orange的Cake

Cake.Builer builer = newCake.Builer();
builer.setSize(30);
builer.setApple("apple");
builer.setOrange("orange");
//创建一个蛋糕
Cake cake = builer.build();

帅地：这种方法牛吧？这还不够，我们还可以采用链式调用的方法。

链式调用

publicclassCake{
  privateintsize;
  privateString apple;
  privateString banana;
  privateString orange;
  privateString mango;
  //private,让外面无法直接创建
  privateCake(Builer builer){
    this.size = builer.size;
    this.apple = builer.apple;
    .....
  }

  //专门用来与外界打交道
  publicstaticclassBuiler{
    privateintsize;
    privateString apple;
    privateString banana;
    privateString orange;
    privateString mango;
    //返回参数改为Builer
    publicBuiler setSize(intsize){
      this.size = size;
      returnthis;
    }

    publicBuiler setApple(String apple){
      this.apple = apple;
      returnthis;
    }
    //为了省点代码，其他的省略
    publicCake build(){
      //检查参数之间的依赖关系是否正确
      returnnewCake(this);
    }
  }
}

如何使用？

Cake cake = newCake.Builer()
      .setSize(30)
      .setApple("apple")
      .setOrange("orange")
      .build();

一行代码就搞定了。

帅地：厉害吧？

小秋：涨知识了，看来我还是太年轻了，以后得好好向帅地学习。

建造者模式

帅地：其实，上面那种方法算是23种设计模式中的其中一种—-建造者模式。不过这只是一个简化版的建造者模式。

对于建造者模式，具体的UML图是这样的：

在这个UML图中，Builder是一个接口，定义一套规范，而我们使用的例子中，没有使用接口，直接使用具体类，但核心思想还是一样的。

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

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