java23种设计模式（二）-- 建造者模式和原型模式

一、建造者模式

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创造不同的表示。

特点：

　　（1）、在某些属性没有赋值之前，复杂对象不能作为一个完整的产品使用。比如汽车包括方向盘、车门、发动机等各部件，缺少了这些部件就不能生产使用。

　　（2）、对象的一些属性必须按照顺序赋值，比如汽车应有车架才能装车轮和其他部件。

建造者模式涉及到以下四个角色的概念：

　　- 抽象建造者角色：提供一个接口，规范产品对象的建造，一般由子类实现。一般来说，产品的组成部分数与建造方法数相同，即有多少组成部分，就有多少个建造方法。

  - 具体建造者角色：该角色实现了抽象建造者抽象建造者接口，主要是实现所有声明的方法以及返回建造好的产品实例。

  - 导演者角色：负责调用具体建造者按照顺序建造产品。导演者只负责调度，真正执行的是具体建造者角色。

  - 产品角色：该角色是建造的复杂对象，提供基本方法。

具体实现

1、创建产品角色

 public class Production {

     private String part1;

     private String part2;

     public String getPart1() {
         return part1;
     }

     public void setPart1(String part1) {
         this.part1 = part1;
     }

     public String getPart2() {
         return part2;
     }

     public void setPart2(String part2) {
         this.part2 = part2;
     }

     @Override
     public String toString() {
         return "Production{" +
                 "part1='" + part1 + '\'' +
                 ", part2='" + part2 + '\'' +
                 '}';
     }
 }

2、创建抽象建造者角色

 public interface IBuilder {

     //产品有多少个组件，就有多少个建造方法
      void buildPart1();

      void buildPart2();

      //返回产品类

     Production build();

 }

3、创建具体建造者角色

 public class BuilderA implements IBuilder{

     private  Production production = new Production() ;

     @Override
     public void buildPart1() {
         System.out.println("兰博基尼建造第一部分");
         this.production.setPart1("This is part1 of Lamborghini");
     }

     @Override
     public void buildPart2() {
         System.out.println("兰博基尼建造第二部分");
         this.production.setPart2("This is part2 of Lamborghini");
     }

     @Override
     public Production build() {
         System.out.println("咔擦！兰博基尼已造好！");
         return this.production;
     }
 }

4、创建导演者角色

 public class Director {

     private IBuilder builder;

     public Director(IBuilder builder){
         this.builder = builder;
     }

     /**
      * 开始具体构造
      */
     public Production construct(){
         this.builder.buildPart1();
         this.builder.buildPart2();

         return this.builder.build();
     }
 }

5、客户端调用

 public class Client {
     public static void main(String[] args) {
         //建造一个产品A
         IBuilder builder = new BuilderA();
         Director director = new Director(builder);
         System.out.println(director.construct());
     }
 }

运行结果

兰博基尼建造第一部分
兰博基尼建造第二部分
咔擦！兰博基尼已造好！
Production{part1='This is part1 of Lamborghini', part2='This is part2 of Lamborghini'}

优点

1）降低代码耦合度。在建造者模式中，客户端不需要知道产品内部是如何实现的，我们只需得到产品的对象。并且使用导演者和建造者分离组装过程和组件具体构造过程，具有灵活的扩展性。

2）优秀的扩展性。具体建造者相互独立，方便扩展，符合开闭原则。

缺点

1）一定的使用范围限制。建造者模式的产品的组件基本相同，如果产品的差异性较大，建造者模式就不适用了。

跟工厂方法模式对比：建造者模式和工厂模式同样是创建一个产品，工厂模式就是一个方法，而建造者模式有多个方法，并且建造者模式是有顺序的执行方法。就是说建造者模式强调的是顺序，而工厂模式没有顺序一说。

二、原型模式

通过复制一个已存在对象来生成一个新对象，被复制的对象称为原型；

 补充：

1、JAVA中Object的clone方法已经为什么提供了复制对象的实现，且该方法为本地方法，性能好，在需要大量复制对象的情况，使用clone创建对象比new效率高；

补充下深拷贝和浅拷贝，深拷贝是通过拷贝内存（包括引用的对象）实现对象的创建；浅拷贝不拷贝引用的对象，但拷贝了引用的值，如果类的成员属性中都是基本类型，不含对象，也是可以达到深拷贝的效果；深拷贝可以通过将对象序列化成字节流以及反序列化实现，浅拷贝直接调用clone即可；

2、使用原型模式创建对象是没有调用类的构造方法的；

java已经很好的支持原型模式了，使用很简便，如下类，实现了Cloneable接口，即成了一个原型；

（参考另一篇博客：java的clone方法）

 package com.pichen.dp.creationalpattern.prototype;

 public class Cell implements Cloneable{
     private int cellId;
     public int getCellId() {
         return cellId;
     }
     public void setCellId(int cellId) {
         this.cellId = cellId;
     }
     public Cell(int id) {
         this.cellId = id;
     }
     @Override
     public Object clone() throws CloneNotSupportedException
     {
         System.out.println("clone a cell obj.");
         return (Cell) super.clone();
     }
 }

使用原型，复制10个拷贝：

 package com.pichen.dp.creationalpattern.prototype;

 public class Main {

     public static void main(String[] args) throws CloneNotSupportedException {
         Cell prototypeCell = new Cell(888);
         for(int i = 0; i < 10; i++){
             Cell copyCell = (Cell) prototypeCell.clone();
             System.out.println(copyCell.hashCode() + ":" + copyCell.getCellId());
         }
     }
 }