设计模式之---工厂模式、建造者模式
☺ 对于工厂模式，个人学习需要掌握
- 注意答案的重点标黑了。对于工厂模式、建造者模式，掌握，我下面这几点就很棒棒。
一、工厂模式
1、什么是工厂模式：【关键字
factory】答：创建对象时，不直接new，而是交由一个工厂类/工厂接口的
工厂方法负责创建。2、工厂模式的意义
答：将实例化对象的代码提取出来，放到一个类(工厂类)中统一管理和维护；实现了创建者和调用者的分离，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
3、工厂模式包括哪三种
答：简单工厂模式、工厂方法模式、抽象工厂模式
4、工厂模式的使用对比[简单工厂模式和工厂方法模式对比]：
答：简单工厂模式：虽然某种程度上不符合设计原则，但实际使用最多；工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展；抽象工厂模式：不可以增加产品，可以增加产品族。
★ 虽然简单工厂模式不符合理论中的开闭原则，但是工厂方法模式定义的大量子类工厂实现类，管理也非常麻烦，
实际开发中使用的最多是简单工厂模式.5、抽象工厂是什么
答：是工厂的工厂，超级工厂。适合生产一个稳定的产品族，采用
抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。6、工厂模式的应用场景：
- jdk中calendar的getInstance方法----简单工厂模式
- JDBC中的Connection对象的获取
- Spring中的IOC容器创建管理bean对象
- 反射中Class对象的newInstance方法
二、建造者模式
1、什么是建造者模式：【关键字
builder】答：又叫生成器模式，是一种对象构建模式。将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
2、四种角色是什么
答：
（1) Product(产品角色)：一个具体的产品对象。
（2) Builder(抽象建造者): 创建一个产品对象的各个部件的
接口/抽象类。（3) ConcreteBuilder(具体建造者): 实现或继承抽象建造者接口，具体地构建和装配各个部件。
（4) Director(指挥者): 构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。负责指挥构建一个工程，决定了工程如何构建，按照什么顺序构建。
举例：建造房子:
需要建房子：这一过程为打桩、砌墙、封顶。不管是普通房子也好，别墅也好都 需要经历这些过程，下面我们使用建造者模式(Builder Pattern)来完成.
1、产品角色：Product-房子，定义了房子的属性
2、
抽象建造者：Builder-抽象的工人，定义了一些建造房子组件的方法和接口3、
具体建造者：ConcreteBuilder-具体的工人，实现了建造房子组件4、
指挥者：Director-房子的指挥设计者，：负责指挥构建一个工程，决定了工程如何构建，按照什么顺序构建3、建造者模式在JDK的应用和源码分析 (java.lang.StringBuilder中的建造者模式)
答：源码中建造者模式角色分析：
(1) Appendable接口，是抽象建造者, 定义了抽象方法，定义了多个append方法(抽象方法)
(2) AbstractStringBuilder抽象类，实现了 Appendable接口方法，AbstractStringBuilder 是建造者，只是不能实例化
(3)StringBuilder 继承了AbstractStringBuilder，即充当了指挥者角色，同时充当了具体的建造者，建造方法的实现是由 AbstractStringBuilder 完成, 而StringBuilder 继承了 AbstractStringBuilder
4、建造者模式的优缺点：
答：优点：(1) 产品的建造和表示分离，实现了解耦。使用建造者模式可以使客户端不必知道产品内部组成的细节;
(2) 用户使用不同的具体建造者即可得到不同的产品对象;
(3) 增加新的具体建造者无需修改原有类库代码，符合“开闭原则”
缺点：
建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式5、抽象工厂模式VS建造者模式
答：抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品，采用
抽象工厂模式不需要关心构建过程，只关心什么产品 由什么工厂生产即可。而建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。
一、工厂设计模式
1、作用和意义：实现了创建者和调用者的分离。
★ 工厂模式的意义：将实例化对象的代码提取出来，放到一个类(工厂类)中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
2、三种工厂模式：
简单工厂模式、工厂方法模式、抽象工厂模式
3、 设计模式的依赖抽象原则：
创建对象实例时，不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中，并返回。
不要让类继承具体类，而是继承抽象类或者是实现interface(接口)
不要覆盖基类中已经实现的方法
4、核心本质：
实例化对象不使用new，用工厂方法代替 factory
将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦
■ 简单工厂模式（静态工厂模式）
用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码）
★ 对于简单工厂模式的举例：消费者买车
情况一：在没有使用简单工厂模式下，消费者(Consumer类)要买车，需要自己 new来构建一辆自己想要买的车。【
需要消费者自己制作车(new 构建 车对象)，则消费者是需要车的内部细节，才能new出车对象】情况二：使用简单工厂模式下，消费者只需要调用汽车工厂（CarFactory类）的获取车的方法，就可以买车了，不用关系车的创建的各种细节。而汽车工厂（CarFactory类）作用就是来制作车 (new 构建 车对象)的，并为外界提供获取车对象的方法。
public class Consumer {public static void main(String[] args) {// 1、没有使用简单工厂模式的情况：// Car car = new WuLing();// Car car1 = new Tesla();// 2、使用工厂创建Car car = CarFactory.getCar("wuling");Car car1 = CarFactory.getCar("tesila");car.name();car1.name();}
}public interface Car {void name();
}public class WuLing implements Car{@Overridepublic void name() {System.out.println("五菱宏光");}
}public class Tesla implements Car{@Overridepublic void name() {System.out.println("特斯拉");}
}// 静态工厂模式
// 开闭原则
public class CarFactory {// 方法一： 不满足开闭原则public static Car getCar(String car){if(car.equals("wuling")){return new WuLing();}else if(car.equals("tesila")){return new Tesla();}else {return null;}}// 方法二：public static Car geyWuling(){return new WuLing();}public static Car geyTesla(){return new Tesla();}}
□ 弊端：增加一个新的产品，做不到不修改代码。
例如：扩展一个大众的汽车，则需要修改工厂类(CarFactory)的Car(String car)方法的代码，不符合开闭原则【对扩展开发，对修改关闭】。
- 解决：工厂方法模式
■ 工厂方法模式：
用来生产同一等级结构中的固定产品（支持增加任意产品）
public class Consumer {public static void main(String[] args) {Car car = new WulingFactory().getCar();Car car1 = new TeslaFactory().getCar();car.name();car1.name();Car car2 = new MoBaiFactory().getCar();car2.name();}
}public interface Car {void name();
}public class WuLing implements Car {@Overridepublic void name() {System.out.println("五菱宏光");}
}public class Tesla implements Car {@Overridepublic void name() {System.out.println("特斯拉");}
}// 工厂方法模式
public interface CarFactory {Car getCar();
}public class WulingFactory implements CarFactory{@Overridepublic Car getCar() {return new WuLing();}
}public class TeslaFactory implements CarFactory{@Overridepublic Car getCar() {return new Tesla();}
}
■ 工厂方法模式：通过将简单工厂模式原先的工厂类抽象成接口，然后根据车的种类，决定了抽象工厂接口的子类工厂实现类，并在子类工厂实现类内创建对应车种类的对象。
- 举例：现在多了一个车的品牌，叫宝马，相应的车工厂就有宝马工厂(实现工厂接口)，在宝马车工厂实现了制作宝马车的方法。
3、理论和实际应用对比【对比简单工厂模式和工厂方法模式】
1、结构复杂度：simple>method
2、代码复杂度：simple>method
3、编程复杂度：simple>method
4、管理上的复杂度：simple>method
★ 虽然简单工厂模式不符合理论中的开闭原则，但是工厂方法模式定义的大量子类工厂实现类，管理也非常麻烦，
实际开发中使用的最多是简单工厂模式
4、抽象工厂模式：“工厂的工厂，超级工厂。适合生产一个稳定的产品族”
围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂
(1) 定义：
抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定他们的具体的类（针对整个产品族，产品等级数量相对固定的产品族）
(2) 适用场景：
- 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
- 强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码
- 提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体实现
■ 抽象工厂模式-其实就是工厂方法模式的抽象，体现在将原先的工厂定义为超级工厂接口，且包含的属性成员也是接口。
1、定义一个超级工厂接口IProductFactory：包含两个产品接口(接口属性成员)-手机产品接口IphoneProduct、路由器产品接口IRouterProduct 【产品族】
2、然后超级工厂接口有具体的实现子类-小米工厂XiaomiFactory、华为工厂HuaweiFactory
3、对于超级工厂接口定义的接口属性成员有对应的实现子类
然后手机产品接口IphoneProduct有具体的实现子类-小米手机实现子类XiaomiPhone、华为手机实现子类HuaweiPhone
同样路由器产品接口IRouterProduct 也有具体的实现子类-小米路由实现子类XiaomiRouter、华为路由实现子类HuaweiRouter
// 手机产品接口
public interface IphoneProduct {void start();void shutdown();void callup();void sendSMS();
}// 小米手机
public class XiaomiPhone implements IphoneProduct{@Overridepublic void start() {System.out.println("开启小米手机");}@Overridepublic void shutdown() {System.out.println("关闭小米手机");}@Overridepublic void callup() {System.out.println("小米手机打电话");}@Overridepublic void sendSMS() {System.out.println("小米手机发短信");}
}// 华为手机
public class HuaweiPhone implements IphoneProduct{@Overridepublic void start() {System.out.println("开启华为手机");}@Overridepublic void shutdown() {System.out.println("关闭华为手机");}@Overridepublic void callup() {System.out.println("华为手机打电话");}@Overridepublic void sendSMS() {System.out.println("华为手机发短信");}
}// 路由器产品接口
public interface IRouterProduct {void start();void shutdown();void openWifi();void setting();
}// 小米路由器
public class XiaomiRouter implements IRouterProduct{@Overridepublic void start() {System.out.println("启动小米路由器");}@Overridepublic void shutdown() {System.out.println("关闭小米路由器");}@Overridepublic void openWifi() {System.out.println("打开小米Wi-Fi");}@Overridepublic void setting() {System.out.println("小米设置");}
}// 华为路由器
public class HuaweiRouter implements IRouterProduct{@Overridepublic void start() {System.out.println("启动华为路由器");}@Overridepublic void shutdown() {System.out.println("关闭华为路由器");}@Overridepublic void openWifi() {System.out.println("打开华为Wi-Fi");}@Overridepublic void setting() {System.out.println("华为设置");}
}// 抽象产品工厂
public interface IProductFactory {// 生产手机IphoneProduct iphoneProduct();// 生产路由器IRouterProduct irouterProduct();}public class XiaomiFactory implements IProductFactory{@Overridepublic IphoneProduct iphoneProduct() {return new XiaomiPhone();}@Overridepublic IRouterProduct irouterProduct() {return new XiaomiRouter();}
}public class HuaweiFactory implements IProductFactory{@Overridepublic IphoneProduct iphoneProduct() {return new HuaweiPhone();}@Overridepublic IRouterProduct irouterProduct() {return new HuaweiRouter();}
}public class Client {public static void main(String[] args) {System.out.println("小米系列产品--------------------");// 小米工厂XiaomiFactory xiaomiFactory = new XiaomiFactory();IphoneProduct iphoneProduct = xiaomiFactory.iphoneProduct();iphoneProduct.callup();iphoneProduct.sendSMS();IRouterProduct iRouterProduct = xiaomiFactory.irouterProduct();iRouterProduct.openWifi();System.out.println("华为系列产品--------------------");// 小米工厂HuaweiFactory huaweiFactory = new HuaweiFactory();iphoneProduct = huaweiFactory.iphoneProduct();iphoneProduct.callup();iphoneProduct.sendSMS();iRouterProduct = huaweiFactory.irouterProduct();iRouterProduct.openWifi();}
}
(3) 抽象工厂模式优缺点：
优点
具体产品在应用层的代码隔离，无需关心创建的细节
将一个系列的产品统一到一起创建
缺点：
规定了所有可能被创建的产品集合，产品族中扩展新的产品困难；增加了系统的抽象性和理解难度
5、工厂模式小结：
简单工厂模式：虽然某种程度上不符合设计原则，但实际使用最多
工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展
抽象工厂模式：不可以增加产品，可以增加产品族
6、工厂模式的应用场景：
jdk中calendar的getInstance方法----简单工厂模式
JDBC中的Connection对象的获取
Spring中的IOC容器创建管理bean对象
反射中Class对象的newInstance方法
二、建造者模式
它提供了一种创建对象的最佳方式
1、定义：
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
建造者模式（Builder Pattern） 又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。
2、主要作用：
在用户不知道 对象的建造过程和细节的情况下就可以直接创建复杂的对象。
用户只需要给出指定复杂对象的类型和内容，建造者牧师负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来）
3、四种角色[★ 结合第四点的建造房子理解]
1) Product(产品角色)：一个具体的产品对象。
2) Builder(抽象建造者): 创建一个Product对象的各个部件指定的 接口/抽象类。
3) ConcreteBuilder(具体建造者): 实现接口，构建和装配各个部件。
4) Director(指挥者): 构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。
它主要有两个作用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。
4、举例：建造房子
需要建房子：这一过程为打桩、砌墙、封顶。不管是普通房子也好，别墅也好都 需要经历这些过程，下面我们使用建造者模式(Builder Pattern)来完成.
1、产品角色：Product-房子，定义了房子的属性
2、
抽象建造者：Builder-抽象的工人，定义了一些建造房子组件的方法和接口3、
具体建造者：ConcreteBuilder-具体的工人，实现了建造房子组件4、
指挥者：Director-房子的指挥设计者，：核心负责指挥构建一个工程，决定了工程如何构建，按照什么顺序构建
// 产品：房子[定义了房子的属性]
public class Product {private String buildA;private String buildB;private String buildC;private String buildD;public String getBuildA() {return buildA;}public void setBuildA(String buildA) {this.buildA = buildA;}public String getBuildB() {return buildB;}public void setBuildB(String buildB) {this.buildB = buildB;}public String getBuildC() {return buildC;}public void setBuildC(String buildC) {this.buildC = buildC;}public String getBuildD() {return buildD;}public void setBuildD(String buildD) {this.buildD = buildD;}@Overridepublic String toString() {return "Product{" +"buildA='" + buildA + '\'' +", buildB='" + buildB + '\'' +", buildC='" + buildC + '\'' +", buildD='" + buildD + '\'' +'}';}
}// 抽象的建造者[抽象的工人]：只是定义一些方法和接口
public abstract class Builder {abstract void buildA(); // 地基abstract void buildB(); // 钢筋工程abstract void buildC(); // 铺电线abstract void buildD(); // 粉刷// 完工：得到产品abstract Product getProduct();
}// 具体的建造者[工人]:
public class Worker extends Builder {private Product product;public Worker() {product = new Product();// 工人负责创建产品}@Overridevoid buildA() {product.setBuildA("地基");System.out.println("地基");}@Overridevoid buildB() {product.setBuildB("钢筋工程");System.out.println("钢筋工程");}@Overridevoid buildC() {product.setBuildC("铺电线");System.out.println("铺电线");}@Overridevoid buildD() {product.setBuildD("粉刷");System.out.println("粉刷");}@OverrideProduct getProduct() {return product;}
}// 指挥者：核心负责指挥构建一个工程，工程如何构建，按照什么顺序构建，由他决定
public class Director {// 指挥工人按照顺序建房子public Product build(Builder builder){builder.buildA();builder.buildB();builder.buildC();builder.buildD();return builder.getProduct();}
}public class Test {public static void main(String[] args) {// 指挥Director director = new Director();// 指挥 具体的工人 完成产品Product build = director.build(new Worker());System.out.println(build.toString());}
}
5、建造者模式在JDK的应用和源码分析 (java.lang.StringBuilder中的建造者模式)
■ 源码中建造者模式角色分析
Appendable接口，是抽象建造者, 定义了抽象方法，定义了多个append方法(抽象方法)
AbstractStringBuilder抽象类，实现了 Appendable接口方法，AbstractStringBuilder 是建造者，只是不能实例化
StringBuilder 继承了AbstractStringBuilder，即充当了指挥者角色，同时充当了具体的建造者，建造方法的实现是由 AbstractStringBuilder 完成, 而StringBuilder 继承了 AbstractStringBuilder
6、建造者模式的优缺点
优点：
- 产品的建造和表示分离，实现了解耦。使用建造者模式可以使客户端不必知道产品内部组成的细节
- 用户使用不同的具体建造者即可得到不同的产品对象
- 将复杂产品的创建步骤分解在不同的方法中，是得创建过程更加清晰
- 具体的建造者之间是相互独立的，这有利于系统的扩展。增加新的具体建造者无需修改原有类库代码，符合“开闭原则”
缺点：
建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制- 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变的很庞大
7、抽象工厂模式VS建造者模式
抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品 由什么工厂生产即可。
而建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。
参考内容来源：《尚硅谷Java设计模式（图解+框架源码剖析）》 https://www.bilibili.com/video/BV1G4411c7N4
《【狂神说Java】通俗易懂的23种设计模式教学（停更）》https://www.bilibili.com/video/BV1mc411h719?p=5
如果本文对你有帮助的话记得给一乐点个赞哦，感谢！
设计模式之---工厂模式、建造者模式相关推荐
- 北风设计模式课程---7、建造者模式
北风设计模式课程---7.建造者模式 一.总结 一句话总结: 设计模式都是对生活中好的做事方法的一些抽象,使得各司其职,减少出错. 建造者模式可以看做模仿的生活中:设计师,施工队做复杂房子交给客户的场 ...
- 一天一个设计模式之JS实现——建造者模式
参考文章: java设计模式之建造者模式 一.什么是建造者模式 建造者模式:是将一个复杂的对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. 工厂类模式提供的是创建单个类的模式,而建造者 ...
- 《设计模式详解》创建型模式 - 建造者模式
建造者模式 4.4 建造者模式 4.4.1 概述 4.4.2 结构 4.4.3 实例 4.4.4 优缺点 4.4.5 使用场景 4.4.6 扩展 - 构建对象 重构前 重构后 4.5 创建型模式对比 ...
- 设计模式（五）——建造者模式
设计模式(五)--建造者模式 一.建造者模式简介 1.建造者模式简介 建造者模式将一个复杂对象的构建与表示分离,使得同样的构建过程可以创建不同的表示. 建造者模式和抽象工厂模式在功能上很相似,都是用来 ...
- 【设计模式】（八）--创建型模式--建造者模式
[设计模式](八)–创建型模式–建造者模式 建造者模式 [设计模式](八)--创建型模式--建造者模式 建造者模式定义 构造者模式的优点 构造者模式的使用场景 构造者模式和工厂模式区别 构造者模式简单 ...
- 肝一肝设计模式【四】-- 建造者模式
系列文章目录 肝一肝设计模式[一]-- 单例模式 传送门 肝一肝设计模式[二]-- 工厂模式 传送门 肝一肝设计模式[三]-- 原型模式 传送门 肝一肝设计模式[四]-- 建造者模式 传送门 肝一肝设 ...
- 从王者荣耀看设计模式（十五.建造者模式）
从王者荣耀看设计模式(建造者模式) 一.简介 为了玩王者荣耀的游戏体验感,不少玩家都会选择花钱购买自己常用英雄的皮肤.一方面,购买的皮肤通常要比原画更加"炫酷".另一方面,购买的英 ...
- 设计模式（五）——建造者模式详解
设计模式(五)--建造者模式详解 概述 结构 代码案例 优缺点 使用场景 模式扩展 创建者模式对比 工厂方法模式和建造者模式 抽象工厂模式和建造者模式 概述 建造者模式就是说将一个复杂对象的构建和表示 ...
- 浅谈工厂和建造者模式
最近在写安卓项目,在引入rxJava和Retrofit发现大量引用的建造者模式.那在此就记录和简单介绍一下两者的区别和使用方法. 工厂模式和建造者模式都属于创建型模式,它对类的实例化进行了抽象. 1. ...
- 设计模式 — 创建型模式 — 建造者模式
目录 文章目录 目录 建造者模式 应用场景 代码示例 建造者模式 建造者模式,顾名思义类似于建筑工人,他们按照有条理的施工顺序(e.g. 打桩 => 浇筑框架 => 砌墙 => 装修 ...
最新文章
- 【Live555】live555源码详解（九）：ServerMediaSession、ServerMediaSubsession、live555MediaServer
- 图神经网络越深，表现就一定越好吗？
- 椭圆形中间一个大写的v_年轻人想要的出街姿态，新CR-V整的明明白白
- linux用户及权限操作
- 用fputc（）函数以字符串形式写入字符到磁盘文件
- vimdiff的简单使用
- 语音增强相关技术综述
- java.lang.reflect.InvocationTargetException 的惨痛教训
- 常见开源协议大白话说明
- 新词新意—The Sticks 乡下
- php中abs,php中的abs函数怎么用
- php 网络是否通,测试网络连通性的命令是什么？
- 公司新办公楼休息间能看到富士山了
- Java之常用函数笔记
- Labview软件开发—界面切换—选项卡的应用
- easyui datebox控件点击今天按钮不触发onSelect事件的解决方法
- 止汗 咒语_如何使用咒语制作诗歌机器人
- 护照、身份证识别阅读器
- 赋能 打造应对不确定性的敏捷团队 pdf_赋能，打造应对不确定性的敏捷团队读后感（一）...
- 论文——多指标与机器学习算法相结合的中国县级玉米产量早期预测