设计模式——创建模式

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

单例模式、原型模式

  • 单例模式
    单例模式思想,一个对象只产生一个实例,在用单例模式的时候注意一下,注意一下内存安全性问题,可以使用静态内部类来实现。
  • 原型模式
    原型模式思想,用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。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。

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 211,348评论 6 491
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 90,122评论 2 385
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 156,936评论 0 347
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 56,427评论 1 283
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 65,467评论 6 385
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 49,785评论 1 290
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 38,931评论 3 406
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 37,696评论 0 266
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 44,141评论 1 303
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,483评论 2 327
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,625评论 1 340
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 34,291评论 4 329
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 39,892评论 3 312
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,741评论 0 21
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,977评论 1 265
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 46,324评论 2 360
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 43,492评论 2 348

推荐阅读更多精彩内容