设计模式——创建模式

设计模式中属于创建模式的有单例模式、原型模式、工厂方法模式、抽象工厂模式、建造者模式共五种
《设计模式之禅》笔记

单例模式、原型模式

• 单例模式
  单例模式思想，一个对象只产生一个实例，在用单例模式的时候注意一下，注意一下内存安全性问题，可以使用静态内部类来实现。
• 原型模式
  原型模式思想，用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。Java语言Object中有clone()方法，只要实现Cloneable接口，重写clone()就可以实现。注意点final属性是无法深拷贝的只能浅拷贝，因为是final修饰的。

工厂方法模式：

思想：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
例子：制造小汽车汽车SVU和MPV两种汽车
实现：

工厂方法模式类图

  /**
 *  抽象一个汽车接口
 */
public interface ICar {


  /**
   * 小汽车干的事情
   */
  void car();

}


/**
* MPV 小汽车类
*/
public class MpvCar implements ICar{
  @Override
  public void car() {
      System.out.println("MPV 闹闹开");
  }
}


/**
* SUV 汽车类
*/
public class SuvCar implements ICar{
  @Override
  public void car() {
      System.out.println("SUV 嗷嗷开");
  }
}


/**
* 小汽车生产工厂
*/
public class CarFactory {

  public static ICar createCar(String type){

      if(type.equals("SUV")){
          return new SuvCar();
      }
      if(type.equals("MPV")){
          return new MpvCar();
      }
      return null;
  }

}



public class Client {
  public static void main(String[] args) {
      /* 我喜欢SUV 给我来个SUV爽爽 */
      ICar suvcar = CarFactory.createCar("SUV");
      suvcar.car();
      /* 我现在想做的舒服一点 给我来个MPV */
      ICar mpvcar = CarFactory.createCar("MPV");
      mpvcar.car();
  }
}

工厂方法模式的优点：
1.良好的封装性，调用者只需要告诉工厂我要的小汽车类型就可以了，不要关注对象创建过程，降低耦合度；
2.结构清晰，代码中没有那么多的new了，对象的创建都是通过工厂来的。
3.扩展性非常优秀，如果新增一个小轿车，只需要在创建一个小轿车类，工厂类稍微修改一下就可以，如果工单类是通过反射生产对象调用者传入类路径工厂类也可以做到无修改。

抽象工厂模式

思想：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。
例子：还是制造小汽车，增加了品牌的概念，两个牌子Benz(奔驰)、BMW(宝马)两个牌子，每个牌子都有自己的工厂，每个牌子有SUV、VAN两种小汽车
实现：

抽象工厂类图

/**
*  小汽车接口
*/
public interface ICar {
  //汽车的生产商，也就是牌子
  public String getBand();
  //汽车的型号
  public String getModel();
}

/**
*  宝马车抽象类
*/
public abstract class AbsBMW implements ICar {
  private final static String BMW_BAND = "宝马汽车";
  //宝马车
  public String getBand() {
    return BMW_BAND;
  }
  //型号由具体的实现类实现
  public abstract String getModel();
}

/**
*  宝马van
*/
public class BMWVan extends AbsBMW {
  private final static String SEVENT_SEARIES = "7系列车型商务车";
  public String getModel() {
    return SEVENT_SEARIES;
  }
}


/**
*  宝马SUV
*/
public class BMWSuv extends AbsBMW {
  private final static String X_SEARIES = "X系列车型SUV";
  public String getModel() {
    return X_SEARIES;
  }
}


/**
*  奔驰车抽象类
*/
public abstract class AbsBenz implements ICar {
  private final static String BENZ_BAND = "奔驰汽车";
  public String getBand() {
    return BENZ_BAND;
  }
  //具体型号由实现类完成
  public abstract String getModel();
}

/**
*  奔驰VAN
*/
public class BenzVan extends AbsBenz {
  private final static String R_SERIES = "R系列商务车";
  public String getModel() {
    return R_SERIES;
  }
}

/**
*  奔驰SUV
*/
public class BenzSuv extends AbsBenz {
  private final static String G_SERIES = "G系列SUV";
  public String getModel() {
    return G_SERIES;
  }
}

/**
* 工厂抽象接口
*/
public interface CarFactory {
  //生产SUV
  public ICar createSuv();
  //生产商务车
  public ICar createVan();
}

/**
* 宝马工厂
*/
public class BMWFactory implements CarFactory {
  //生产SUV
  public ICar createSuv() {
    return new BMWSuv();
  }
  //生产商务车
  public ICar createVan(){
    return new BMWVan();
  }
}

/**
* 奔驰工厂
*/
public class BenzFactory implements CarFactory {
  //生产SUV
  public ICar createSuv() {
    return new BenzSuv();
  }
  //生产商务车
  public ICar createVan(){
    return new BenzVan();
  }
}

public class Client {
  public static void main(String[] args) {
    //要求生产一辆奔驰SUV
    System.out.println("===要求生产一辆奔驰SUV===");
    //首先找到生产奔驰车的工厂
    System.out.println("A、找到奔驰车工厂");
    CarFactory carFactory= new BenzFactory();
    //开始生产奔驰SUV
    System.out.println("B、开始生产奔驰SUV");
    ICar benzSuv = carFactory.createSuv();
    //生产完毕，展示一下车辆信息
    System.out.println("C、生产出的汽车如下：");
    System.out.println("汽车品牌："+benzSuv.getBand());
    System.out.println("汽车型号：" + benzSuv.getModel());
  }
}

抽象工厂模式缺点：
良好的封装性，调用者只需要告诉工厂我要的小汽车类型就可以了，不要关注对象创建过程，降低耦合度。
抽象工厂模式缺点：
扩展比较困难，如果我想增加一个汽车种类，工厂接口、工厂抽象类、工厂实现类都需要修改。

建造者模式

思想：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
例子：建造者模式设计一个生产车辆需要把车辆进行拆分，拆分成引擎和车轮两部分，然
后由建造者进行建造，想要什么车，你只要有设计图纸就成，马上可以制造一辆车出来。
实现：

建造者模式类图

/**
* 汽车抽象接口
*/
public interface ICar {
  //汽车车轮
  public String getWheel();
  //汽车引擎
  public String getEngine();
}

/**
* 汽车实体
*/
public class Car implements ICar {
  //汽车引擎
  private String engine;
  //汽车车轮
  private String wheel;
  //一次性传递汽车需要的信息
  public Car(String _engine,String _wheel){
    this.engine = _engine;
    this.wheel = _wheel;
  }
  public String getEngine() {
    return engine;
  }
  public String getWheel() {
    return wheel;
  }
  public String toString(){
    return "车的轮子是：" + wheel + "\n车的引擎是：" + engine;
  }
}


/**
* 建造者抽象
*/
public abstract class CarBuilder {
  //待建造的汽车
  private ICar car;
  //设计蓝图
  private Blueprint bp;
  public Car buildCar(){
  //按照顺序生产一辆车
    return new Car(buildEngine(),buildWheel());
  }
  //接收一份设计蓝图
  public void receiveBlueprint(Blueprint _bp){
    this.bp = _bp;
  }
  //查看蓝图，只有真正的建造者才可以查看蓝图
  protected Blueprint getBlueprint(){
    return bp;
  }
  //建造车轮
  protected abstract String buildWheel();
  //建造引擎
  protected abstract String buildEngine();
}

/**
* 汽车设计蓝图
*/
public class Blueprint {
  //车轮的要求
  private String wheel;
  //引擎的要求
  private String engine;
  public String getWheel() {
    return wheel;
  }
  public void setWheel(String wheel) {
    this.wheel = wheel;
  }
  public String getEngine() {
    return engine;
  }
  public void setEngine(String engine) {
    this.engine = engine;
  }
}

/**
* 宝马建造者
*/
public class BMWBuilder extends CarBuilder {
  public String buildEngine() {
    return super.getBlueprint().getEngine();
  }
  public String buildWheel() {
    return super.getBlueprint().getWheel();
  }
}


/**
* 奔驰建造者
*/
public class BenzBuilder extends CarBuilder {
  public String buildEngine() {
    return super.getBlueprint().getEngine();
  }
  public String buildWheel() {
    return super.getBlueprint().getWheel();
  }
}


/**
* 导演类
*/
public class Director {
  //声明对建造者的引用
  private CarBuilder benzBuilder = new BenzBuilder();
  private CarBuilder bmwBuilder = new BMWBuilder();
  //生产奔驰SUV
  public ICar createBenzSuv(){
    //制造出汽车
    return createCar(benzBuilder, "benz的引擎", "benz的轮胎");
  }
  //生产出一辆宝马商务车
  public ICar createBMWVan(){
    return createCar(benzBuilder, "BMW的引擎", "BMW的轮胎");
  }
  //生产出一个混合车型
  public ICar createComplexCar(){
    return createCar(bmwBuilder, "BMW的引擎", "benz的轮胎");
  }
  //生产车辆
  private ICar createCar(CarBuilder _carBuilder,String engine,String wheel){
    //导演怀揣蓝图
    Blueprint bp = new Blueprint();
    bp.setEngine(engine);
    bp.setWheel(wheel);
    System.out.println("获得生产蓝图");
    _carBuilder.receiveBlueprint(bp);
    return _carBuilder.buildCar();
  }
}


public class Client {
  public static void main(String[] args) {
    //定义出导演类
    Director director =new Director();
    //给我一辆奔驰车SUV
    System.out.println("===制造一辆奔驰SUV===");
    ICar benzSuv = director.createBenzSuv();
    System.out.println(benzSuv);
    //给我一辆宝马商务车
    System.out.println("\n===制造一辆宝马商务车===");
    ICar bmwVan = director.createBMWVan();
    System.out.println(bmwVan);
    //给我一辆混合车型
    System.out.println("\n===制造一辆混合车===");
    ICar complexCar = director.createComplexCar();
    System.out.println(complexCar);
  }
}

建造者模式优点：
1.封装性：使用建造者模式可以使客户端不必知道产品内部组成的细节
2.建造者独立，容易扩展 BenzBuilder和BMWBuilder是相互独立的，对系统的扩展非常有利。
3.便于控制细节风险，由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

使用场景

工厂方法模式、抽象工厂模式：

典型的一个解耦设计模式，调用者不需要关注实现，只依赖接口就好了，新增功能和类型只需要扩展类就可以，符合开闭原则和依赖倒置原则。抽象工厂模式对开闭原则兼容的不是特别好，因为在扩展汽车种类的时候需要修改工厂抽象接、抽象类、实现类。
工厂模式可以理解为是一个new的替代品，所以在有需要生成对象的地方都可以考虑使用工厂模式实现，工厂方法模式适用于单一产品多工厂，抽象工厂适用于多钟产品多工厂。

建造者模式：

对象结构复杂， 需要多个零部件装配，装配不同的零部件会产生不同的结果时候可以考虑使用建造者模式，或者在创建的对象聚合了其他的对象这种聚合也可以交给建造者模式完事。

工厂和建造者模式对比

工厂模式关注的是对象，我所有的对象都是在我工厂是产生的，不关注对象创建的过程。
建造者关注的是对象创建的过成，每个零部件的组成和搭配产生不同的结果。
spring 举例，spring每个bean实例的前身都是一个BeanDefinition，BeanDefinition怎么来的呢就是通过，BeanDefinitionBuilder建造者通过解析Bean配置装配出来的。在我们getBean的时候再根据BeanDefinition创建我们的实例，实现BeanFactory。