Java 23种设计模式
- (一)、设计模式相关内容介绍
- 1.软件设计模式概述
- (1).软件设计模式的产生背景
- (2).软件设计模式的概念
- (3).学习设计模式的重要性
- (4).设计模式分类
- 2.UML图
- (1).类图概述
- (2).类图的作用
- (3).类图表示法
- 3.软件设计原则
- (1).开闭原则 (重写不修改)
- (2).里氏代换原则 (添加不重写)
- (3).依赖倒转原则 (找接口不找具体类)
- (4).接口隔离原则 (接口最小化)
- (5).迪米特法则 (直接与间接)
- (6).合成复用原则
- (二)、创建者模式(5种)
- 1.单列模式
- (1).单列模式的结构
- (2).单列模式的实现
- (3).饿汉式的两种方式
- (4).懒汉式的七种方式
- (5).存在问题-> 破坏单列模式2种
- (6).解决问题-> 解决单列模式2种
- (7).JDK源码解析-Runtime类
- 2.原型模式
- (1).概述
- (2).结构
- (3).实现
- (4).案列
- (5).使用场景
- (6).扩展(深克隆)
- 3.工厂方法模式 (单点咖啡和甜点)
- (1).概述
- (2).简单工厂模式
- (3).工厂方法模式
- 4.抽象工厂模式 (咖啡-套餐)
- (1).概述
- (2).结构
- (3).实现
- (4).优缺点
- (5).使用场景
- (6).JDK源码解析- Collection.iterator方法
- 5.工厂模式的扩展💔 -(这个不属于23种)
- 6.建造者模式
- (1).概述
- (2).结构
- (3).实列
- (4).优缺点
- (5).使用场景
- (6).模式扩展
- 7.创建者模式对比
- (1).工厂方法模式VS建造者模式
- (2).抽象工厂模式VS建造者模式
(一)、设计模式相关内容介绍
1.软件设计模式概述
(1).软件设计模式的产生背景
"设计模式"最初并不是出现在软件设计领域种的,而是被用于建筑领域的设计中。
1977年 克里斯托弗-亚历山大 提出了253种建筑领域的基本模式。
1990年 软件工程领域开始讨论设计模式的话题。
1995年 四个人出版了《设计模式-可复用面向对象软件的基础》一书收录了23种设计模式。
(2).软件设计模式的概念
软件设计模式,又被称作设计模式，是一般被反复使用、多数人知晓的、经过分类编目的。代码设计经验总结的。它描述了在软件设计种遇到的常用问题的解决方案。
(3).学习设计模式的重要性
设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承和多态性以及类的关联关系和组合关系的充分理解。
- 可以提高程序员的思维能力、编程能力和设计能力。
- 使程序设计更加标准化、代码编制更加工程化、是软件开发效率大大提高、从而缩短软件的开发周期。
- 使设计的代码可重用性高、可读取性强、可靠性高、灵活性好、可维护性强。
(4).设计模式分类
1.创建型模式:
-
用于描述"怎么创建对象"，他的特点是"将对象的创建与使用分离"。GOF 书种 提供了单列、原型、工厂方法、抽象工厂、建造者等5种创建型模式。
- 结构型模式:
-
用于描述如何将类或对象按某种布局组成更强大的结构,GOF书中提供了代理、适配器、桥接、装饰、外观、享元、组合等7种结构型模式
- 行为型模式:
-
用于描述类或对象之间怎么样相互协作共同完成单个对象无法单独完成的任务，以及怎么样分配职责。GOF书中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、爹嗲气、访问者、备忘录、解释器等11种行为型模式。
2.UML图
统一建模语言、是用来设计软件的可视化建模语言。它的特点使简单、统一、图形化、能表达软件设计种的动态与静态信息。
UML 从目标系统的不同角度触发，定义了用例图、类图、对象图、状态图、活动图、时序图、协作图、构件图、部署图等9种图。
(1).类图概述
类图是显示了模型的静态结构，特别是模型种存在的类、类的内部结构以及它们与其他类的关系等。类图不显示暂时性地信息。类图是面向对象建模地主要组成部分。
(2).类图的作用
- 在软件工程中，类图是一种静态的结构图，描述了系统的类的集合，类的属性和类之间的关系，可以简化了人们对系统的理解。
- 类图是系统分析和设计阶段的重要产物,是系统编码和测试的重要模型。
(3).类图表示法
1. 类的表示方法
在UML类图中，类使用包含类名、属性和方法且带有分割线的矩形来表示.
表示有三个私有属性: name的类型为string。sex的类型为int。age的类型为int。一个公有的方法student的返回类型是void、参数列表为null。
属性/方法名称前加号和减号表示了这个属性/方法的可见性，UML类图中表示可见性的符号有三种:
- +: 表示public
- -: 表示private
- #:表示protected
中括号中的内容表示是: 可选的。 也有将类型放在变量名前面的,返回值放在方法名的前面
属性的完整表示方式: 可见性符号 属性名称:属性名称类型 [=初始化值(可有可无)]
属性的完整表示方式: 可见性 名称(参数列表) [: 返回类型]
2. 类与类之间关系的表示方法
1. 关联关系🖤
关联关系是对象之间的一种索引关系，用于表示一类对象与另一类对象之间的联系。列如师生、师徒、夫妻等等。关联关系是类与类之间最常用的一种关系，分为一般关联关系、聚合关系和组合关系。
关联又可以分为单向关联、双向关联、自关联。
(1).单向关联:
在UML图中单向关联用一个带箭头的实现表示。上图表示每一个顾客都有一个地址，这通过Customer类持有一个类型为Address的成员变量类实现。
(2).双向关联:
在UML类图中,双向关联用一个不带箭头的直线表示。上图中在Customer类中维护一个List表示一个顾客可以购买多个商品,在Product类中维护一个Customer类型的成员变量表示这个产品被哪个顾客所购买。
(3).自关联:
自关联在UML类图中用一个带有箭头且指向自身的实线表示,上图的意思就是Node类包含类型Node的成员变量,也就是自己包含自己。
2. 聚合关系🖤
聚合关系是关联关系的一种,是强关联关系,是整体部分之间的关系。
聚合关系样式通过成员对象来实现的,其中成员对象是整体对象的一部分，但成员对象可以脱离整个对象而独立存在。列如： 学校与老师的关系，学校包含老师，但如果学校停办了，老师依然存在。
在UML类图中,聚合关系可以用带空心菱形的实现来表示,菱形指向整体.下图所示是大学和教师的关系图。
3. 组合关系🖤
组合表示类之间的整体与部分的关系,但它是一种更强烈的聚合关系。
在组合关系中,整体对象可以控制部分对象的生命周期,一旦整体对象不存在了,部分对象也将不存在,部分对象不能脱离整体对象的存在,列如头和嘴的关系，头不在了嘴也就不在了。
在UML类图中,组合关系用带实心的菱形来表示,菱形指向整体。
4. 依赖关系🖤
依赖关系是一种使用关系,它是随想之间耦合度最弱的一种关联方式,是临时性的关联。在代码中,某一个类的方法通过局部变量、方法的参数或者静态方法的调用来访问另一个类(被依赖类)中的某些方法来完成一些职责。
在UML类图中，依赖关系使用带箭头的虚线来表示,箭头从使用类指向被依赖的类。下图所示是司机和汽车的关系图,司机驾驶汽车。
5. 继承关系🖤
继承关系是对象之间耦合度最大的一种关系,表示一般与特殊的关系,是父类与子类之间的关系,是一种继承关系。
在UML类图中,泛化关系用带空心的三角箭头的实现来表示,箭头从子类指向父类。在代码实现时,使用面向对象的继承机制来实现泛化关系。列如: Student类和Teacher类都是Person的子类。
6.实现关系🖤
实现关系是接口与实现类之间的关系。在这种关系中,类实现了接口,类中的操作实现了接口中所声明的所有的抽象操作。
在UML类图中,实现关系使用带空心三角箭头的虚线来表示,箭头从实现类指向接口。列如: 汽车和船实现了交通工具。
3.软件设计原则
在软件开发中,为了提高软件系统的可维护性和可复用性,增加软件的可扩展性和灵活性,使程序员尽量根据6条原则来开发程序,从而提高软件开发效率、节约软件开发成本和维护成本。
(1).开闭原则 (重写不修改)
对扩展开放，对修改关闭。 在程序需要扩展的时候,不能去修改原有的代码，实现一个热插拔的效果。简言之，就是为了使程序的扩展性好,易于维护和升级。
想要达到这样的效果,我们需要使用接口和抽象类。
因为抽象灵活性好,适应性广，只要抽象的合理，可以基本保持软件架构的稳定。而软件中容易变化的细节可以从抽象派生来的实现类来进行扩展,当软键需要发生变化时,只需要根据需求重新派生一个实现类来扩展就可以了。
eg: 鼠标和键盘的USB。插上即用，拔掉即失。还有搜狗输入法的换肤操作，实际上就是定义一个抽象类，然后有不同的子类对其实现。用户窗体可以根据需要选择或者增加信的主题,而不需要修改原有的代码。所以它是满足开闭原则的。
抽象皮肤类
package com.jsxs.principles.demo1;
/**
* @Author Jsxs
* @Date 2023/4/15 19:38
* @PackageName:com.jsxs.principles.demo1
* @ClassName: AbstractSkin
* @Description: TODO 抽象皮肤类
* @Version 1.0
*/
public abstract class AbstractSkin {
// 抽象方法时一定要被继承的子类实现的。
public abstract void display();
}
默认皮肤
package com.jsxs.principles.demo1;
/**
* @Author Jsxs
* @Date 2023/4/15 19:40
* @PackageName:com.jsxs.principles.demo1
* @ClassName: DefaltSkin
* @Description: TODO 默认皮肤类
* @Version 1.0
*/
public class DefaultSkin extends AbstractSkin{ //1. 我么需要继承一个抽象皮肤类
@Override
public void display() { //2. 抽象方法我们必须要实现
System.out.println("恭喜你,成功切换为默认的皮肤!");
}
}
jsxs皮肤
package com.jsxs.principles.demo1;
/**
* @Author Jsxs
* @Date 2023/4/15 19:42
* @PackageName:com.jsxs.principles.demo1
* @ClassName: JsxsSkin
* @Description: TODO 吉士先生皮肤
* @Version 1.0
*/
public class JsxsSkin extends AbstractSkin{ //1. 继承抽象类
@Override
public void display() { //2. 必须重写抽象方法
System.out.println("恭喜您,成功切换为吉士先生皮肤!!");
}
}
搜狗输入法
package com.jsxs.principles.demo1;
/**
* @Author Jsxs
* @Date 2023/4/15 19:44
* @PackageName:com.jsxs.principles.demo1
* @ClassName: SougouInpt
* @Description: TODO 聚合关系: 也就是强关联 "部分可以离开整体"
* @Version 1.0
*/
public class SougouInpt {
private AbstractSkin abstractSkin;
public void setKin(AbstractSkin abstractSkin) { //alt+insert
this.abstractSkin = abstractSkin;
}
public void display(){
abstractSkin.display(); // 调用方法
}
}
模拟客户
package com.jsxs.principles.demo1;
/**
* @Author Jsxs
* @Date 2023/4/15 19:56
* @PackageName:com.jsxs.principles.demo1
* @ClassName: Client
* @Description: TODO 实现类-客户端
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
// 1.创建搜狗输入法对象
SougouInpt sougouInpt = new SougouInpt();
// 2.创建皮肤对象
DefaultSkin defaultSkin = new DefaultSkin();
// 3.将皮肤设置到输入法中
sougouInpt.setKin(defaultSkin);
// 4.显示皮肤
sougouInpt.display();
}
}
以上的代码就是实现了: 开闭原则。我们对增加业务是开放的对修改是关闭的。一个抽象方法、多个实现类、一个聚合关系(部分可以脱离整体)。
(2).里氏代换原则 (添加不重写)
里氏代换原则是面向对象设计的基本原则之一。
里氏代换原则: 任何基类可以出现的地方，子类一定可以出现。通俗的理解: 子类可以扩展父类的功能,但不能改变原有的功能。换句话说,子类继承父类时,除了**添加新的方法完成新增功能外,尽量不要重写父类的方法**。
如果通过重写父类的方法来完成新的功能,这样写起来虽然简单，但整个继承体系的可复用性会比较差，特别是运用多态比较频繁时,程序运行出错的概率非常大。
经典列子:
eg: 正方形不是长方形
在数学领域里,正方形为一体是长方形，他是一个长度相等的长方形。所以，我们开发的一个与集合图形相关的软件系统，就可以顺利成章的让正方形继承自长方形。
反列
长方形类
package com.jsxs.principles.demo2;
/**
* @Author Jsxs
* @Date 2023/4/15 21:35
* @PackageName:com.jsxs.principles.demo2
* @ClassName: Rectangle
* @Description: TODO 长方形
* @Version 1.0
*/
public class Rectangle {
private double length;
private double width;
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
}
正方形类
package com.jsxs.principles.demo2;
/**
* @Author Jsxs
* @Date 2023/4/15 21:36
* @PackageName:com.jsxs.principles.demo2
* @ClassName: Square
* @Description: TODO 正方形: “继承长方形”
* @Version 1.0
*/
public class Square extends Rectangle{ //1. 继承长方形
@Override
public void setLength(double length) { //2.重写长方形的长
super.setLength(length);
super.setWidth(length);
}
@Override
public void setWidth(double width) { // 3.重写长方形的宽
super.setWidth(width);
super.setLength(width);
}
}
测试类
package com.jsxs.principles.demo2;
/**
* @Author Jsxs
* @Date 2023/4/15 21:40
* @PackageName:com.jsxs.principles.demo2
* @ClassName: RectangleTest
* @Description: TODO
* @Version 1.0
*/
public class RectangleTest {
public static void main(String[] args) {
Rectangle rectangle = new Rectangle();
rectangle.setWidth(10);
rectangle.setLength(20);
// 进行扩宽的操作
resize(rectangle);
printLengthAndWidth(rectangle);
// 尝试传递子类而不是不基类
System.out.println("---------------------");
Square square = new Square();
square.setLength(10);
square.setWidth(10);
resize(square);
printLengthAndWidth(square);
}
// 扩展方法
public static void resize(Rectangle rectangle){
// 判断宽如果比长小,那么就进行扩宽的操作
while (rectangle.getWidth()<=rectangle.getLength()){
rectangle.setWidth(rectangle.getWidth()+1);
}
}
// 打印长和宽
public static void printLengthAndWidth(Rectangle rectangle){
System.out.println(rectangle.getWidth());
System.out.println(rectangle.getLength());
}
}
我们运行这段代码就会发现:“假如是长方形传入，那么就会输出长和宽,但是当我们正方形传入,我们就会发现程序会一直处于循环状态，并不会输出任何的日志信息。得出结论:“长方形适合这个代码、正方形不适合这个代码。基类能出现的地方，子类一定可以出现，假如基类能出现的地方，子类不能出现，那么就违反了里氏代换原则。””
正列
接口
package com.jsxs.principles.demo2.after;
/**
* @Author Jsxs
* @Date 2023/4/16 7:52
* @PackageName:com.jsxs.principles.demo2.after
* @ClassName: Quadrilateral
* @Description: TODO 四边形接口
* @Version 1.0
*/
public interface Quadrilateral {
double getLength(); //获取长
double getWidth(); //获取宽
}
长方形
package com.jsxs.principles.demo2.after;
/**
* @Author Jsxs
* @Date 2023/4/16 7:55
* @PackageName:com.jsxs.principles.demo2.after
* @ClassName: Rectangle
* @Description: TODO 长方形实现接口
* @Version 1.0
*/
public class Rectangle implements Quadrilateral{
private double length;
private double width;
@Override
public double getLength() {
return length;
}
@Override
public double getWidth() {
return width;
}
public void setLength(double length) {
this.length = length;
}
public void setWidth(double width) {
this.width = width;
}
}
正方形
package com.jsxs.principles.demo2.after;
/**
* @Author Jsxs
* @Date 2023/4/16 7:53
* @PackageName:com.jsxs.principles.demo2.after
* @ClassName: Square
* @Description: TODO 正方形实现四边形的接口
* @Version 1.0
*/
public class Square implements Quadrilateral{
private double side; //1.定义变量边长
@Override
public double getLength() {
return side;
}
@Override
public double getWidth() {
return side;
}
public void setSide(double side) {
this.side = side;
}
}
测试实现类
package com.jsxs.principles.demo2.after;
/**
* @Author Jsxs
* @Date 2023/4/16 7:56
* @PackageName:com.jsxs.principles.demo2.after
* @ClassName: RectangleTest
* @Description: TODO
* @Version 1.0
*/
public class RectangleTest {
public static void main(String[] args) {
// 1. 创建长方形的对象
com.jsxs.principles.demo2.after.Rectangle rectangle = new com.jsxs.principles.demo2.after.Rectangle(); // 创建一个对象
rectangle.setLength(20);
rectangle.setWidth(10);
// 2.调用方法进行扩宽的操作
resize(rectangle);
printLengthAndWidth(rectangle);
}
// 扩展方法
public static void resize(Rectangle rectangle){ // 这个参数是: after的。这里我们传入的是长方形，因为长方形和正方形没有了父子关系，所以这里只能进行传输正正方形。
// 判断宽如果比长小,那么就进行扩宽的操作
while (rectangle.getWidth()<=rectangle.getLength()){
rectangle.setWidth(rectangle.getWidth()+1);
}
}
// 打印长和宽
public static void printLengthAndWidth(Quadrilateral quadrilateral){
System.out.println(quadrilateral.getWidth());
System.out.println(quadrilateral.getLength());
}
}
(3).依赖倒转原则 (找接口不找具体类)
高层模块不应该依赖底层模块,两者都应该依赖其抽象;抽象不应该依赖细节,细节应该依赖抽象。简单地说: 就是要求对抽象进行编程,不要对实现进行编程,这样就降低了客户与实现魔窟啊的耦合。
高层模块不应该依赖于底层模块
细节应该依赖于抽象
eg: 组装电脑
现要组装一台电脑，需要陪考吗CPU、硬盘、内存条。只有这些配置都有了，计算机次啊能正常的运行。选择CPU有很多选择,如Inter、AMD等，硬盘可以选择希捷，西数等，内存条可以选择金士顿、海盗船等。
组合关系
硬盘
package com.jsxs.principles.demo3.before;
/**
* @Author Jsxs
* @Date 2023/4/16 8:54
* @PackageName:com.jsxs.principles.demo3.before
* @ClassName: yingpan
* @Description: TODO 硬盘
* @Version 1.0
*/
public class yingpan {
// 1.存储数据的方法
public void save(String date){
System.out.println("硬盘存储数据: "+date);
}
// 2.获取数据的方法
public String get(){
System.out.println("获取硬盘存储数据: ");
return "数据";
}
}
处理器
package com.jsxs.principles.demo3.before;
/**
* @Author Jsxs
* @Date 2023/4/16 8:56
* @PackageName:com.jsxs.principles.demo3.before
* @ClassName: CPU
* @Description: TODO CPU中央处理器
* @Version 1.0
*/
public class CPU {
public void run(){
System.out.println("使用CPU处理器");
}
}
内存条
package com.jsxs.principles.demo3.before;
/**
* @Author Jsxs
* @Date 2023/4/16 8:57
* @PackageName:com.jsxs.principles.demo3.before
* @ClassName: neicun
* @Description: TODO
* @Version 1.0
*/
public class neicun {
public void save(){
System.out.println("使用内存条的数据");
}
}
计算机整体
package com.jsxs.principles.demo3.before;
/**
* @Author Jsxs
* @Date 2023/4/16 8:58
* @PackageName:com.jsxs.principles.demo3.before
* @ClassName: Computer
* @Description: TODO 组合关系
* @Version 1.0
*/
public class Computer { // 电脑统一
private CPU cpu;
private neicun neicun;
private yingpan yingpan;
public CPU getCpu() {
return cpu;
}
public void setCpu(CPU cpu) {
this.cpu = cpu;
}
public com.jsxs.principles.demo3.before.neicun getNeicun() {
return neicun;
}
public void setNeicun(com.jsxs.principles.demo3.before.neicun neicun) {
this.neicun = neicun;
}
public com.jsxs.principles.demo3.before.yingpan getYingpan() {
return yingpan;
}
public void setYingpan(com.jsxs.principles.demo3.before.yingpan yingpan) {
this.yingpan = yingpan;
}
public void run(){
System.out.println("计算机开始开机操作");
String s = yingpan.get();
System.out.println("从硬盘上获取的数据是:"+s);
cpu.run();
neicun.save();
}
}
客户端实现类
package com.jsxs.principles.demo3.before;
/**
* @Author Jsxs
* @Date 2023/4/16 9:01
* @PackageName:com.jsxs.principles.demo3.before
* @ClassName: ComputerTest
* @Description: TODO
* @Version 1.0
*/
public class ComputerTest {
public static void main(String[] args) {
// 1.创建计算机对象
Computer computer = new Computer();
yingpan yingpan = new yingpan();
CPU cpu = new CPU();
neicun neicun = new neicun();
computer.setCpu(cpu);
computer.setYingpan(yingpan);
computer.setNeicun(neicun);
computer.run();
}
}
上面的代码可以看到已经组装了一台电脑，但是视乎组装的电脑只能是Inter的，内存条值能使金士顿的、硬盘只能是希捷的。这对用户来说肯定不是友好的，因为用户很喜欢自定义机箱。如果我们想要更改CPU肯定要修改Computer所以违反了开闭原则。
正列
CPU接口
package com.jsxs.principles.demo3.after;
/**
* @Author Jsxs
* @Date 2023/4/16 9:23
* @PackageName:com.jsxs.principles.demo3.after
* @ClassName: CPUInterface
* @Description: TODO CPU接口
* @Version 1.0
*/
public interface CPUInterface {
public void run();
}
CPU实现类
package com.jsxs.principles.demo3.after;
/**
* @Author Jsxs
* @Date 2023/4/16 9:24
* @PackageName:com.jsxs.principles.demo3.after
* @ClassName: CpuImp
* @Description: TODO
* @Version 1.0
*/
public class CpuImp implements CPUInterface{
@Override
public void run() {
System.out.println("自定义的CPU");
}
}
内存条接口
package com.jsxs.principles.demo3.after;
/**
* @Author Jsxs
* @Date 2023/4/16 9:24
* @PackageName:com.jsxs.principles.demo3.after
* @ClassName: NeicunInterface
* @Description: TODO
* @Version 1.0
*/
public interface NeicunInterface {
public void save();
}
内存条实现类
package com.jsxs.principles.demo3.after;
/**
* @Author Jsxs
* @Date 2023/4/16 9:25
* @PackageName:com.jsxs.principles.demo3.after
* @ClassName: NeicunImp
* @Description: TODO
* @Version 1.0
*/
public class NeicunImp implements NeicunInterface{
@Override
public void save() {
System.out.println("自定义的内存条存取数据");
}
}
硬盘接口
package com.jsxs.principles.demo3.after;
/**
* @Author Jsxs
* @Date 2023/4/16 9:21
* @PackageName:com.jsxs.principles.demo3.after
* @ClassName: HardCode
* @Description: TODO 硬盘接口
* @Version 1.0
*/
public interface HardCode {
public void save(String date); //存储数据
public String get(); //返回数据
}
硬盘实现类
package com.jsxs.principles.demo3.after;
/**
* @Author Jsxs
* @Date 2023/4/16 9:25
* @PackageName:com.jsxs.principles.demo3.after
* @ClassName: HardCodeImp
* @Description: TODO
* @Version 1.0
*/
public class HardCodeImp implements HardCode{
@Override
public void save(String date) {
System.out.println("自定义硬盘存取的数据是: "+date);
}
@Override
public String get() {
System.out.println("自定义的硬盘数据");
return "自定的硬盘数据";
}
}
Computer组合类
package com.jsxs.principles.demo3.after;
/**
* @Author Jsxs
* @Date 2023/4/16 9:26
* @PackageName:com.jsxs.principles.demo3.after
* @ClassName: ComputerImp
* @Description: TODO
* @Version 1.0
*/
public class ComputerImp {
private CPUInterface cpuInterface;
private HardCode hardCode;
private NeicunInterface neicunInterface;
public CPUInterface getCpuInterface() {
return cpuInterface;
}
public void setCpuInterface(CPUInterface cpuInterface) {
this.cpuInterface = cpuInterface;
}
public HardCode getHardCode() {
return hardCode;
}
public void setHardCode(HardCode hardCode) {
this.hardCode = hardCode;
}
public NeicunInterface getNeicunInterface() {
return neicunInterface;
}
public void setNeicunInterface(NeicunInterface neicunInterface) {
this.neicunInterface = neicunInterface;
}
public void run(){
System.out.println("自定义的计算机开始工作!!");
cpuInterface.run();
String s = hardCode.get();
hardCode.save(s);
neicunInterface.save();
}
}
测试类
package com.jsxs.principles.demo3.after;
/**
* @Author Jsxs
* @Date 2023/4/16 9:30
* @PackageName:com.jsxs.principles.demo3.after
* @ClassName: ComputerTest
* @Description: TODO
* @Version 1.0
*/
public class ComputerTest {
public static void main(String[] args) {
// 1.定义三个实现类
CpuImp cpuImp = new CpuImp();
HardCodeImp hardCodeImp = new HardCodeImp();
NeicunImp neicunImp = new NeicunImp();
// 2. 定义一个计算机
ComputerImp computerImp = new ComputerImp();
computerImp.setCpuInterface(cpuImp);
computerImp.setHardCode(hardCodeImp);
computerImp.setNeicunInterface(neicunImp);
computerImp.run();
}
}
(4).接口隔离原则 (接口最小化)
客户端不应该被迫依赖于它不适用的方法;一个类对另一个类的依赖应该建立在最小的接口上。
接口不应该被迫依赖它不适用的方法
一个类对另一个类的依赖应该建立在最小的接口上
eg : 安全门案列
我们需要一个 黑马 品牌的安全门,该安全门具有防火、防水、防盗的功能提取成一个接口,形成一套规范。类图如下:
接口
package com.jsxs.principles.demo4.befor;
/**
* @Author Jsxs
* @Date 2023/4/16 10:13
* @PackageName:com.jsxs.principles.demo4.befor
* @ClassName: SafeDoor
* @Description: TODO 安全门接口
* @Version 1.0
*/
public interface SafeDoor {
void antiTheft(); //防盗
void fireProof(); //防火
void waterProof(); //防水
}
实现类
package com.jsxs.principles.demo4.befor;
/**
* @Author Jsxs
* @Date 2023/4/16 10:15
* @PackageName:com.jsxs.principles.demo4.befor
* @ClassName: HeimaSaferDoor
* @Description: TODO 实现类
* @Version 1.0
*/
public class HeimaSaferDoor implements SafeDoor{
@Override
public void antiTheft() {
System.out.println("防盗");
}
@Override
public void fireProof() {
System.out.println("防火");
}
@Override
public void waterProof() {
System.out.println("防水");
}
}
测试类
package com.jsxs.principles.demo4.befor;
/**
* @Author Jsxs
* @Date 2023/4/16 10:17
* @PackageName:com.jsxs.principles.demo4.befor
* @ClassName: SafeDoorTest
* @Description: TODO
* @Version 1.0
*/
public class SafeDoorTest {
public static void main(String[] args) {
HeimaSaferDoor heimaSaferDoor = new HeimaSaferDoor();
heimaSaferDoor.antiTheft();
heimaSaferDoor.fireProof();
heimaSaferDoor.waterProof();
}
}
上面的设计我们发现问题: 黑马品牌的安全门具有防盗、防火、防水的功能。现在如果我们还需要再创建一个传智品牌的安全们，而它只具有防盗、防水的功能。很显然我们这里设计的接口就违反了接口隔离原则，那么我们如何进行修改呢?
正列:
接口1
package com.jsxs.principles.demo4.after;
/**
* @Author Jsxs
* @Date 2023/4/16 10:29
* @PackageName:com.jsxs.principles.demo4.after
* @ClassName: fireProof
* @Description: TODO
* @Version 1.0
*/
public interface fireProof {
void fire();
}
接口2
package com.jsxs.principles.demo4.after;
/**
* @Author Jsxs
* @Date 2023/4/16 10:29
* @PackageName:com.jsxs.principles.demo4.after
* @ClassName: waterProof
* @Description: TODO 防水
* @Version 1.0
*/
public interface waterProof {
void water();
}
接口三
package com.jsxs.principles.demo4.after;
/**
* @Author Jsxs
* @Date 2023/4/16 10:30
* @PackageName:com.jsxs.principles.demo4.after
* @ClassName: theafProof
* @Description: TODO
* @Version 1.0
*/
public interface theafProof {
void thymef();
}
黑马门
package com.jsxs.principles.demo4.after;
/**
* @Author Jsxs
* @Date 2023/4/16 10:30
* @PackageName:com.jsxs.principles.demo4.after
* @ClassName: HeimaDoor
* @Description: TODO
* @Version 1.0
*/
public class HeimaDoor implements fireProof,waterProof{
@Override
public void fire() {
System.out.println("防火");
}
@Override
public void water() {
System.out.println("防水");
}
}
测试实验
package com.jsxs.principles.demo4.after;
/**
* @Author Jsxs
* @Date 2023/4/16 10:31
* @PackageName:com.jsxs.principles.demo4.after
* @ClassName: DoorTest
* @Description: TODO
* @Version 1.0
*/
public class DoorTest {
public static void main(String[] args) {
HeimaDoor heimaDoor = new HeimaDoor();
heimaDoor.fire();
heimaDoor.water();
}
}
(5).迪米特法则 (直接与间接)
迪米特法则又叫最少知识原则。
只和你的直接朋友交谈，不跟陌生人说话。 其含义是: 如果两个软件实体无需直接通信,那么就不应当发生直接的相互调用,可以通过第三方转发调用。其目的是降低类之间的耦合度，提高模块的相对独立开发。
迪米特法则中的 "朋友"是指: 当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等。这些兑现同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。
eg: 明星和经纪人的关系实列
明星由于全身心的投入艺术、所以很多的日常事务都是由经纪人负责处理的，比如粉丝的见面会和媒体公司的业务洽谈等。这里的经纪人是明星的朋友，而粉丝和媒体公司是明星的陌生人，所以适合使用迪米特法则。
明星
package com.jsxs.principles.demo5;
/**
* @Author Jsxs
* @Date 2023/4/16 11:00
* @PackageName:com.jsxs.principles.demo5
* @ClassName: Star
* @Description: TODO
* @Version 1.0
*/
public class Star {
private String name;
public Star(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
粉丝
package com.jsxs.principles.demo5;
/**
* @Author Jsxs
* @Date 2023/4/16 11:01
* @PackageName:com.jsxs.principles.demo5
* @ClassName: Fans
* @Description: TODO 粉丝类
* @Version 1.0
*/
public class Fans {
private String name;
public Fans(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
公司
package com.jsxs.principles.demo5;
/**
* @Author Jsxs
* @Date 2023/4/16 11:02
* @PackageName:com.jsxs.principles.demo5
* @ClassName: Bussiness
* @Description: TODO 媒体公司类
* @Version 1.0
*/
public class Company {
private String name;
public Company(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
经纪人
package com.jsxs.principles.demo5;
/**
* @Author Jsxs
* @Date 2023/4/16 11:03
* @PackageName:com.jsxs.principles.demo5
* @ClassName: Agent
* @Description: TODO 经纪人类
* @Version 1.0
*/
public class Agent {
private Star star;
private Fans fans;
private Company company;
public void setStar(Star star) {
this.star = star;
}
public void setFans(Fans fans) {
this.fans = fans;
}
public void setCompany(Company company) {
this.company = company;
}
// 1.和粉丝见面
public void meeting(){
System.out.println(star.getName()+"见面粉丝"+fans.getName());
}
//2.和媒体公司洽谈
public void business(){
System.out.println(star.getName()+"洽谈公司"+company.getName());
}
}
测试
package com.jsxs.principles.demo5;
/**
* @Author Jsxs
* @Date 2023/4/16 11:06
* @PackageName:com.jsxs.principles.demo5
* @ClassName: StarTest
* @Description: TODO
* @Version 1.0
*/
public class StarTest {
public static void main(String[] args) {
Fans fans = new Fans("李明");
Company company = new Company("CKQN");
Star star = new Star("及你太美");
Agent agent = new Agent();
agent.setStar(star);
agent.setCompany(company);
agent.setFans(fans);
agent.business();
agent.meeting();
}
}
(6).合成复用原则
合成复用原则是指: 尽量先使用组合或则和聚合等关系来实现，其次再开率使用继承关系来实现。
通常类的复用分为继承复用和合成复用两种。
继承复用虽然有简单和容易实现的优点,但它也存在以下缺点:
继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为"白箱"复用子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化，这不利于类的扩展和维护。它限制了复用的灵活性。从子类继承而来的实现是静态的，在编译时已经定义，所以再运行时不可能发生变化。
采用组合或聚合复用时，可以将已有对象纳入新的对象中，使之称为对象的一部分，新对象可以调用已有对象的功能，它有以下的优点:
它维持了类的封装性。因为成分对象的内部细节时新对象看不见的，所以这种服用又称为"黑箱"复用。对象的耦合度低。可以在类的成员位置声明抽象。复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。
汽车按动力源划分可分为汽油汽车、电动汽车;按"颜色"划分为白色汽车、黑色汽车和红色汽车等。如果同时看i哦率这两种分类，其组合就很多。类图如下:
继承复用: 假如新增填一个汽车动力、会牵扯到很多的子类
将继承复用更改为集合复用
(二)、创建者模式(5种)
创建者模式的主要关注点: “怎么创建对象”,它的主要特点是:“将对象的创建和使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。
1.单列模式
单列模式 是Java中最简单的设计模式之一。这种类型的设计属于创建型模式,他提供了一种创建对象的最佳方式。
这种模式会涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其他唯一的方式，可以直接访问，不需要实列化该类的对象。
(1).单列模式的结构
单列模式饿主要有以下角色:
- 单列模式。只能创建一个实列的类
- 访问类。使用单列类
(2).单列模式的实现
单列设计模式分类两种:
- 饿汉式:
类加载就会导致该单实列对象被创建(加载的时候就创建) - 懒汉式: 类加载不会导致该单列对象被创建,而是
首次使用该对象时才会创建。
(3).饿汉式的两种方式
- 饿汉式-方式一 (静态变量方式)
单列模式
package com.jsxs.pattern.singletion.demo1;
/**
* @Author Jsxs
* @Date 2023/4/16 14:11
* @PackageName:com.jsxs.pattern.singletion.demo1
* @ClassName: Singletion
* @Description: TODO 静态成员变量
* @Version 1.0
*/
public class Singletion {
// 1.私有构造方法: 外界不能创建这个对象也就是->new
private Singletion() {
}
//2.在本类中创建该类的对象: private->外界不能直接访问。 static->设置为静态的变量，目的是为了让静态方法获取。
private static Singletion singletion=new Singletion();
//3.提供一个公共的访问方式,让外界获取该对象
public static Singletion getInstance(){
return singletion;
}
}
访问类
package com.jsxs.pattern.singletion.demo1;
/**
* @Author Jsxs
* @Date 2023/4/16 14:21
* @PackageName:com.jsxs.pattern.singletion.demo1
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
//1.创建Singletion类的对象
Singletion instance = Singletion.getInstance();
Singletion instance1 = Singletion.getInstance();
// 2.判断创建得到这两个对象是否是一个对象
System.out.println(instance==instance1); // == 判断的时地址
}
}
- 饿汉式-方式二 (静态代码块)
package com.jsxs.pattern.singletion.demo2;
/**
* @Author Jsxs
* @Date 2023/4/16 14:30
* @PackageName:com.jsxs.pattern.singletion.demo2
* @ClassName: Singleton
* @Description: TODO 饿汉式2- 静态代码块---- 静态变量和静态代码块谁先声明谁先执行。
* @Version 1.0
*/
public class Singleton {
// 1.私有构造方法
private Singleton(){}
//2.声明Singleton类型的变量
private static Singleton instance; // 并未初始化
//3.静态代码块中进行赋值
static {
instance=new Singleton();
}
//4.对外提供该类对象的方法
public static Singleton getInstance(){
return instance;
}
}
package com.jsxs.pattern.singletion.demo2;
/**
* @Author Jsxs
* @Date 2023/4/16 14:34
* @PackageName:com.jsxs.pattern.singletion.demo2
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
Singleton instance1 = Singleton.getInstance();
System.out.println(instance==instance1);
}
}
说明: 该方式在成员位置声明Singleton类型的静态变量，而对象的创建时在静态代码块中,也是对着类的加载而创建。所以和饿汉式的方式1基本一样，当然该方式也存在内存浪费的问题。
(4).懒汉式的七种方式
- 饿汉式-方式1 (静态方式-线程不安全)
package com.jsxs.pattern.singletion.demo3;
/**
* @Author Jsxs
* @Date 2023/4/16 14:43
* @PackageName:com.jsxs.pattern.singletion.demo3
* @ClassName: Singleton
* @Description: TODO 懒汉式-1
* @Version 1.0
*/
public class Singleton {
// 1.私有构造方法
private Singleton(){}
// 2.声明Singleton类型的变量---*******并没有赋值的操作
private static Singleton instace;
//3.对外提供访问方式
public static Singleton getInstance(){
if (instace==null){ //1.如果以前没有创建对象,那么就创建一个对象。如果创建过，那么就直接返回我们第一次创建的对象。
instace=new Singleton();
}
return instace;
}
}
package com.jsxs.pattern.singletion.demo3;
/**
* @Author Jsxs
* @Date 2023/4/16 14:50
* @PackageName:com.jsxs.pattern.singletion.demo3
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
System.out.println( Singleton.getInstance().hashCode());
Singleton instance1 = Singleton.getInstance();
System.out.println(instance1.hashCode());
}
}
我们发现在单线程的情况下: 哈希值是一样的也就是对象是一样的
问题: 多线程的情况下: 会出现哈希值的不一致->对象不一致。
package com.jsxs.pattern.singletion.demo3;
/**
* @Author Jsxs
* @Date 2023/4/16 14:43
* @PackageName:com.jsxs.pattern.singletion.demo3
* @ClassName: Singleton
* @Description: TODO 懒汉式-1
* @Version 1.0
*/
public class Singleton {
// 1.私有构造方法
private Singleton(){}
// 2.声明Singleton类型的变量---*******并没有赋值的操作
private static Singleton instace;
//3.对外提供访问方式
public static Singleton getInstance(){
if (instace==null){ //1.如果以前没有创建对象,那么就创建一个对象。如果创建过，那么就直接返回我们第一次创建的对象。
try {
Thread.sleep(2000); //等待2秒
} catch (InterruptedException e) {
e.printStackTrace();
}
instace=new Singleton();
}
return instace;
}
}
package com.jsxs.pattern.singletion.demo3;
/**
* @Author Jsxs
* @Date 2023/4/16 14:50
* @PackageName:com.jsxs.pattern.singletion.demo3
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
new Thread(()->{
System.out.println( Singleton.getInstance().hashCode());
}).start();
Singleton instance1 = Singleton.getInstance();
System.out.println(instance1.hashCode());
}
}
- 懒汉式-2 (线程安全)
这里我们在创建对象的时候只是添加了 同步锁Synchronized
package com.jsxs.pattern.singletion.demo3;
/**
* @Author Jsxs
* @Date 2023/4/16 14:43
* @PackageName:com.jsxs.pattern.singletion.demo3
* @ClassName: Singleton
* @Description: TODO 懒汉式-2 (线程安全)
* @Version 1.0
*/
public class Singleton {
// 1.私有构造方法
private Singleton(){}
// 2.声明Singleton类型的变量---*******并没有赋值的操作
private static Singleton instace;
//3.对外提供访问方式
public static synchronized Singleton getInstance(){ // -**********添加了同步锁: "没有执行完毕，不释放资源"
if (instace==null){ //1.如果以前没有创建对象,那么就创建一个对象。如果创建过，那么就直接返回我们第一次创建的对象。
try {
Thread.sleep(2000); //等待2秒
} catch (InterruptedException e) {
e.printStackTrace();
}
instace=new Singleton();
}
return instace;
}
}
package com.jsxs.pattern.singletion.demo3;
/**
* @Author Jsxs
* @Date 2023/4/16 14:50
* @PackageName:com.jsxs.pattern.singletion.demo3
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
new Thread(()->{
System.out.println( Singleton.getInstance().hashCode());
}).start();
Singleton instance1 = Singleton.getInstance();
System.out.println(instance1.hashCode());
}
}
说明: 该方式实现了懒加载的效果，同时又解决了线程安全问题。但是在GetInstance()方法上添加Synchronized关键字，导致该方法的执行效率特别低。从上面的代码我们可以看出，其实就是在初始化inatance的时候才会出现线程安全问题,一旦初始化完成就不存在了。
- 懒汉式-方式3 (双重检查锁)
再来讨论以下懒汉模式中加锁的问题,对于 getInstace()方法来说,绝大部分的操作时读的操作,读操作是线程安全的,所以我们没必要让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。由此也产生了一种新的模式: 双层检查锁模式 (提升效率)
类对象加锁
package com.jsxs.pattern.singletion.demo4;
/**
* @Author Jsxs
* @Date 2023/4/16 15:29
* @PackageName:com.jsxs.pattern.singletion.demo4
* @ClassName: Singleton
* @Description: TODO 懒汉式3 - 双层检查锁: 目的是为了提升性能
* @Version 1.0
*/
public class Singleton {
// 1.私有构造方法
private Singleton(){}
//2.声明Singleton变量
private static Singleton instance;
//3.对外提供公共的访问方式
public static Singleton getInstance(){
//1. 第一次判断
if (instance==null){ //2. 假如为空就进入，否则直接返回。
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//3.类对象加锁...
synchronized (Singleton.class){
//4.第二次判断
if (instance==null){
instance=new Singleton();
}
}
}
return instance;
}
}
package com.jsxs.pattern.singletion.demo4;
/**
* @Author Jsxs
* @Date 2023/4/16 15:41
* @PackageName:com.jsxs.pattern.singletion.demo4
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
new Thread(()->{
System.out.println(Singleton.getInstance().hashCode());
}).start();
Singleton instance1 = Singleton.getInstance();
System.out.println(instance1.hashCode());
}
}
双重检查锁模式是一种非常好的单列实现模式,解决了单列、性能、线程安全问题，上面的双重检查锁模式看上去完美无缺，其实是存在问题的，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实列化对象的时候会进行优化和指令重排序操作。要解决双重检查锁模式带来的空指针异常问题，只需要使用Volatile关键字，Volatile关键字可以保证可见性和有序性。
在变量上添加关键字Volatile
package com.jsxs.pattern.singletion.demo4;
/**
* @Author Jsxs
* @Date 2023/4/16 15:29
* @PackageName:com.jsxs.pattern.singletion.demo4
* @ClassName: Singleton
* @Description: TODO 懒汉式3 - 双层检查锁: 目的是为了提升性能
* @Version 1.0
*/
public class Singleton {
// 1.私有构造方法
private Singleton(){}
//2.声明Singleton变量
private static volatile Singleton instance; //*******************在变量上添加关键字
//3.对外提供公共的访问方式
public static Singleton getInstance(){
//1. 第一次判断
if (instance==null){ //2. 假如为空就进入，否则直接返回。
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//3.类对象加锁...
synchronized (Singleton.class){
//4.第二次判断
if (instance==null){
instance=new Singleton();
}
}
}
return instance;
}
}
package com.jsxs.pattern.singletion.demo4;
/**
* @Author Jsxs
* @Date 2023/4/16 15:41
* @PackageName:com.jsxs.pattern.singletion.demo4
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
new Thread(()->{
System.out.println(Singleton.getInstance().hashCode());
}).start();
Singleton instance1 = Singleton.getInstance();
System.out.println(instance1.hashCode());
}
}
小结: 添加Volatile 关键字之后双重检查锁模式是一种比较好的单列模式实现模式,能够保证在多线程的情况下安全且性能的问题。
- 懒汉式-方式4 (静态内部类方式)
静态内部类单列模式中实列由内部类创建，由于JVM在加载外部类的过程中，是不会加载静态内部类的，只有内部类的属性/方法被调用时才会被加载，并初始化其静态属性。静态属性由于被static修饰，保证只被实列化一次，并且严格保证实列化顺序。
package com.jsxs.pattern.singletion.demo5;
/**
* @Author Jsxs
* @Date 2023/4/16 16:02
* @PackageName:com.jsxs.pattern.singletion.demo5
* @ClassName: Singleton
* @Description: TODO 静态内部类的方式
* @Version 1.0
*/
public class Singleton {
// 1.私有构造方法
private Singleton(){}
// 2.定义一个静态内部类
private static class SingletonHolder{ //为了防止外部对其进行修改,我们添加一个 final 的关键字
//在内部类中声明并初始化外部类的对象
private final static Singleton instance=new Singleton();
}
// 3.提供公共的访问方式
public static Singleton getInstance(){
return SingletonHolder.instance;
}
}
package com.jsxs.pattern.singletion.demo5;
/**
* @Author Jsxs
* @Date 2023/4/16 16:10
* @PackageName:com.jsxs.pattern.singletion.demo5
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
Singleton instance1 = Singleton.getInstance();
System.out.println(instance1==instance);
}
}
这里不存在线程安全问题，因为JVM在加载外部类的同时,不会加载静态内部类，只要当静态内部类的属性或者方法被调用的时候才会加载静态内部类。因为是静态变量只能被实列化一次...
说明: 第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用getInstance()，虚拟机加载SingletonHolder并初始化INSTANCE，这样不仅能确保线程安全，也能保证 Singleton类的唯一性。
小结： 静态内部类单列模式是一种优秀的单列模式,是开源项目中比较常用的一种单列模式。在没有任何加锁的情况下，保证了多线程的安全，并且没有任何影星性能影响和空间的浪费。
- 枚举方式
枚举类实现单列模式是极力推荐的单列模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用枚举的这个特性来实现单列模式，枚举的写法非常简单，而且枚举类型是所用单列实现中唯一一种不会被破坏的单列实现模式。
package com.jsxs.pattern.singletion.demo6;
/**
* @Author Jsxs
* @Date 2023/4/16 17:39
* @PackageName:com.jsxs.pattern.singletion.demo6
* @ClassName: Singleton
* @Description: TODO 枚举实现方式
* @Version 1.0
*/
public enum Singleton {
INSTANCE;
}
package com.jsxs.pattern.singletion.demo6;
/**
* @Author Jsxs
* @Date 2023/4/16 17:40
* @PackageName:com.jsxs.pattern.singletion.demo6
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
Singleton instance=Singleton.INSTANCE;
Singleton instance1=Singleton.INSTANCE;
System.out.println(instance1==instance);
}
}
枚举方式属于饿汉式方式 -> 如果不考虑内存首选枚举
(5).存在问题-> 破坏单列模式2种
破坏单列模式:
使上面定义的单列类可以创建多个对象,枚举方式除外。有两种方式，分别是序列化和反射。
- 序列化反序列化
设置一个静态内部类并且: 实现序列化
package com.jsxs.pattern.singletion.demo7;
import java.io.Serializable;
/**
* @Author Jsxs
* @Date 2023/4/16 17:47
* @PackageName:com.jsxs.pattern.singletion.demo7
* @ClassName: Singleton
* @Description: TODO
* @Version 1.0
*/
public class Singleton implements Serializable {
// 1.私有构造函数
private Singleton(){}
// 2.静态内部类
private static class SingletonHard{
private static final Singleton instance=new Singleton();
}
// 3.提供公共的对象
public static Singleton getInstance(){
return SingletonHard.instance;
}
}
我们首先先写一个数据、然后读取两次
package com.jsxs.pattern.singletion.demo7;
import java.io.*;
/**
* @Author Jsxs
* @Date 2023/4/16 17:55
* @PackageName:com.jsxs.pattern.singletion.demo7
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) throws Exception {
// writeObject2File();
ReadObjectFromFile();
ReadObjectFromFile();
}
// 从文件读取数据(对象)
public static void ReadObjectFromFile() throws Exception {
//1. 创建对象输入流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\加速器\\a.txt"));
//2. 读取对象
Singleton singleton = (Singleton) ois.readObject();
System.out.println(singleton);
//3. 释放资源
ois.close();
}
// 向文件中写数据 (对象)
public static void writeObject2File() throws Exception {
//1. 获取Singleton对象
Singleton instance = Singleton.getInstance();
// 2.创建对象输出流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\加速器\\a.txt"));
// 3.写对象
oos.writeObject(instance);
//4.释放资源
oos.close();
}
}
小结: 我们发现对象地址不一致-> 也就是破坏了单列模式。
- 反射 (破坏单列模式)
静态内部类
package com.jsxs.pattern.singletion.demo8;
/**
* @Author Jsxs
* @Date 2023/4/16 18:22
* @PackageName:com.jsxs.pattern.singletion.demo8
* @ClassName: Singleton
* @Description: TODO 反射破坏单列模式
* @Version 1.0
*/
public class Singleton {
// 1.定义私有化构造函数: 不让外部类创建对象
private Singleton(){}
// 2.定义静态内部类
private static class SingletonHard{
private static final Singleton instance=new Singleton();
}
// 3.开发端口
public static Singleton getInstance(){
return SingletonHard.instance;
}
}
客户端
package com.jsxs.pattern.singletion.demo8;
import java.lang.reflect.Constructor;
/**
* @Author Jsxs
* @Date 2023/4/16 18:25
* @PackageName:com.jsxs.pattern.singletion.demo8
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) throws Exception {
// 1.获取字节码对象
Class clazz = Singleton.class;
// 2.获取无参构造方法对象
Constructor cons = clazz.getDeclaredConstructor();
// 3.取消访问检查
cons.setAccessible(true);
//4. 创建Singleton对象
Singleton o = (Singleton)cons.newInstance();
Singleton o2 = (Singleton)cons.newInstance();
System.out.println(o==o2);
}
}
破坏了单列模式
(6).解决问题-> 解决单列模式2种
1. 序列化、反序列方式破坏单列模式的解决办法
在Singleton类中添加readResolve()方法,在序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义,则返回新new出来的对象。
这个名字是一个固定的变量名~。假如实体类被序列化了，那么会自动地实现这个代码。
// 4. 当进行反序列化时，会自动调用该方法，将该方法的返回值直接返回
public Object readResolve() {
return SingletonHard.instance;
}
}
序列化
package com.jsxs.pattern.singletion.demo7;
import java.io.Serializable;
/**
* @Author Jsxs
* @Date 2023/4/16 17:47
* @PackageName:com.jsxs.pattern.singletion.demo7
* @ClassName: Singleton
* @Description: TODO
* @Version 1.0
*/
public class Singleton implements Serializable {
// 1.私有构造函数
private Singleton() {
}
// 2.静态内部类
private static class SingletonHard {
private static final Singleton instance = new Singleton();
}
// 3.提供公共的对象
public static Singleton getInstance() {
return SingletonHard.instance;
}
// 4. 当金星反序列化时，会自动调用该方法，将该方法的返回值直接返回
public Object readResolve() {
return SingletonHard.instance;
}
}
实现类
package com.jsxs.pattern.singletion.demo7;
import java.io.*;
/**
* @Author Jsxs
* @Date 2023/4/16 17:55
* @PackageName:com.jsxs.pattern.singletion.demo7
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) throws Exception {
// writeObject2File();
ReadObjectFromFile();
ReadObjectFromFile();
}
// 从文件读取数据(对象)
public static void ReadObjectFromFile() throws Exception {
//1. 创建对象输入流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\加速器\\a.txt"));
//2. 读取对象
Singleton singleton = (Singleton) ois.readObject();
System.out.println(singleton);
//3. 释放资源
ois.close();
}
// 向文件中写数据 (对象)
public static void writeObject2File() throws Exception {
//1. 获取Singleton对象
Singleton instance = Singleton.getInstance();
// 2.创建对象输出流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\加速器\\a.txt"));
// 3.写对象
oos.writeObject(instance);
//4.释放资源
oos.close();
}
}
我们先进行写入数据、然后再读取数据~
- 反射方式破解单列地解决办法
private static boolean flag=false;
// 1.定义私有化构造函数: 不让外部类创建对象
private Singleton(){
synchronized (Singleton.class){
// 判断flag地值是否是true,如果是true，说明非第一次访问，直接跑一个异常即可。如果是false的话，说明第一次创建对象
if (flag){
throw new RuntimeException("不能创建多个对象");
}
// 将flag的值设置为true
flag=true;
}
}
反射实现
package com.jsxs.pattern.singletion.demo8;
/**
* @Author Jsxs
* @Date 2023/4/16 18:22
* @PackageName:com.jsxs.pattern.singletion.demo8
* @ClassName: Singleton
* @Description: TODO 反射破坏单列模式
* @Version 1.0
*/
public class Singleton {
private static boolean flag=false;
// 1.定义私有化构造函数: 不让外部类创建对象
private Singleton(){
synchronized (Singleton.class){
// 判断flag地值是否是true,如果是true，说明非第一次访问，直接跑一个异常即可。如果是false的话，说明第一次创建对象
if (flag){
throw new RuntimeException("不能创建多个对象");
}
// 将flag的值设置为true
flag=true;
}
}
// 2.定义静态内部类
private static class SingletonHard{
private static final Singleton instance=new Singleton();
}
// 3.开发端口
public static Singleton getInstance(){
return SingletonHard.instance;
}
}
实现类
package com.jsxs.pattern.singletion.demo8;
import java.lang.reflect.Constructor;
/**
* @Author Jsxs
* @Date 2023/4/16 18:25
* @PackageName:com.jsxs.pattern.singletion.demo8
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) throws Exception {
// 1.获取字节码对象
Class clazz = Singleton.class;
// 2.获取无参构造方法对象
Constructor cons = clazz.getDeclaredConstructor();
// 3.取消访问检查
cons.setAccessible(true);
//4. 创建Singleton对象
Singleton o = (Singleton)cons.newInstance();
Singleton o2 = (Singleton)cons.newInstance();
System.out.println(o==o2);
}
}
(7).JDK源码解析-Runtime类
Runtime类就是i使用的单列设计模式的饿汉模式
package com.jsxs.pattern.singletion.demo9;
import java.io.IOException;
import java.io.InputStream;
/**
* @Author Jsxs
* @Date 2023/4/16 21:12
* @PackageName:com.jsxs.pattern.singletion.demo9
* @ClassName: RuntomeDemo
* @Description: TODO
* @Version 1.0
*/
public class RuntimeDemo {
public static void main(String[] args) throws IOException {
// 获取Runtime类的对象
Runtime runtime = Runtime.getRuntime();
// 调用runtime的方法exec
Process exec = runtime.exec("ipconfig");
// 调用process对象的获取输入流的方法
InputStream inputStream = exec.getInputStream();
byte[] bytes = new byte[1024 * 1024];
int count=0;
while ((count=inputStream.read())!=-1){
System.out.println(new String(bytes,0,count,"utf-8"));
}
System.out.println("你好");
}
}
2.原型模式
(1).概述
用一个创建的实列作为原型，通过复制该原型对象来创建一个和原型都相同的新对象。
(2).结构
原型模式包含如下角色:
- 抽象原型类: 规定了具体原型对象必须实现的Clone()方法。
JDK帮我们做了。 - 具体原型类: 实现抽象原型类的cone()方法，它是可以被复制的对象
- 访问类: 使用具体原型类中的clone()方法来复制新的对象。
(3).实现
原型模式的克隆分为浅克隆和深克隆
浅克隆: 浅克隆:对当前对象进行克隆,并克隆该对象所包含的8种基本数据类型和String类型属性（拷贝一份该对象并重新分配内存，即产生了新的对象）；但如果被克隆的对象中包含除8中数据类型和String类型外的其他类型的属性,浅克隆并不会克隆这些属性（即不会为这些属性分配内存，而是引用原来对象中的属性,而不拷贝对象包含的引用指向的对象。）会指向原有对象的地址,内存地址一样
深克隆: 深克隆:深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。不再指向原有对象的地址。
Java中的Object类中提供了 clone() 方法来实现浅克隆。Cloneable接口是上面的类图中的抽象原型类，而实现了cloneable接口的子实现类就是具体的原型类。
具体原型类: 这里我们继承coneable接口重写clone()方法实现克隆
package com.jsxs.pattern.prototype.demo;
/**
* @Author Jsxs
* @Date 2023/4/18 13:23
* @PackageName:com.jsxs.pattern.prototype.demo
* @ClassName: Realizetype
* @Description: TODO
* @Version 1.0
*/
public class Realizetype implements Cloneable{
public Realizetype(){
System.out.println("具体的原型对象被创建了");
}
// 1.重写方法
@Override
public Realizetype clone() throws CloneNotSupportedException {
System.out.println("具体原型复制成功!!!");
return (Realizetype)super.clone();
}
}
访问类
package com.jsxs.pattern.prototype.demo;
/**
* @Author Jsxs
* @Date 2023/4/18 13:33
* @PackageName:com.jsxs.pattern.prototype.demo
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
// 1.创建一个原型类对象
Realizetype realizetype = new Realizetype(); // ->利用无参的构造方法去创建对象
//2.调用Realizetype类中我们重写的clone()方法进行对象的克隆
Realizetype clone = realizetype.clone();
System.out.println("原型对象和克隆的对象是否是同一个对象 "+(realizetype==clone));
}
}
(4).案列
用原型模式生成 "三好学生"奖状
同一学校的"三号学生"奖状除了获奖人姓名不同，其他都相同，可以使用原型模式复制多个:"三好学生"奖状出来，然后再修改奖状上的名字即可。
具体原型类: 这里我们继承coneable接口重写clone()方法实现克隆
package com.jsxs.pattern.prototype.demo2;
/**
* @Author Jsxs
* @Date 2023/4/18 13:52
* @PackageName:com.jsxs.pattern.prototype.demo2
* @ClassName: Citation
* @Description: TODO
* @Version 1.0
*/
public class Citation implements Cloneable{
// 基本属性
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// 重写clone方法
@Override
public Citation clone() throws CloneNotSupportedException {
return (Citation)super.clone();
}
public void show(){
System.out.println(name+"获得奖状一张!!");
}
}
访问类
package com.jsxs.pattern.prototype.demo2;
/**
* @Author Jsxs
* @Date 2023/4/18 13:54
* @PackageName:com.jsxs.pattern.prototype.demo2
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
// 1.原型对象的创建
Citation citation = new Citation();
citation.setName("李明-原型对象");
// 2.克隆对象
Citation clone = citation.clone();
clone.setName("吉士-克隆对象");
citation.show();
clone.show();
System.out.println(citation==clone);
}
}
(5).使用场景
- 对象的创建非常复杂,可以使用原型模式快捷的创建对象
- 性能和安全要求比较高
(6).扩展(深克隆)
将上面的"三好学生"奖状的案列中的name属性更改为Student类型的属性。
浅克隆
引用对象类
package com.jsxs.pattern.prototype.demo2;
/**
* @Author Jsxs
* @Date 2023/4/18 14:22
* @PackageName:com.jsxs.pattern.prototype.demo2
* @ClassName: Student
* @Description: TODO
* @Version 1.0
*/
public class Student {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}
具体原型类
package com.jsxs.pattern.prototype.demo2;
/**
* @Author Jsxs
* @Date 2023/4/18 13:52
* @PackageName:com.jsxs.pattern.prototype.demo2
* @ClassName: Citation
* @Description: TODO
* @Version 1.0
*/
public class Citation implements Cloneable{
// 基本属性
private Student student;
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
// 重写clone方法
@Override
public Citation clone() throws CloneNotSupportedException {
return (Citation)super.clone();
}
public void show(){
System.out.println(student.getName()+"获得奖状一张!!");
}
}
访问类
package com.jsxs.pattern.prototype.demo2;
/**
* @Author Jsxs
* @Date 2023/4/18 13:54
* @PackageName:com.jsxs.pattern.prototype.demo2
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
// 1.原型对象的创建
Citation citation = new Citation();
Student student = new Student();
student.setName("原型对象-张三");
citation.setStudent(student);
// 2.克隆对象
Citation clone = citation.clone();
Student student1 = citation.getStudent();
student1.setName("克隆对象-李四");
clone.show();
citation.show();
System.out.println(student==student1);
}
}
说明: student和student1的对象是一个对象，就会产生studen1对象的属性会覆盖student的属性的效果。对具体原型类中的引用类型的属性进行引用的复制。这种情况需要使用深克隆，而进行深克隆需要使用对象流。
序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程
Student引用类-> 序列化
package com.jsxs.pattern.prototype.demo3;
import java.io.Serializable;
/**
* @Author Jsxs
* @Date 2023/4/18 14:22
* @PackageName:com.jsxs.pattern.prototype.demo2
* @ClassName: Student
* @Description: TODO
* @Version 1.0
*/
public class Student implements Serializable { //序列化
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}
具体克隆类 -> 序列化
package com.jsxs.pattern.prototype.demo3;
import java.io.Serializable;
/**
* @Author Jsxs
* @Date 2023/4/18 13:52
* @PackageName:com.jsxs.pattern.prototype.demo2
* @ClassName: Citation
* @Description: TODO
* @Version 1.0
*/
public class Citation implements Serializable {
// 基本属性
private Student student;
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public void show(){
System.out.println(student.getName()+"获得奖状一张!!");
}
}
访问类
package com.jsxs.pattern.prototype.demo3;
import java.io.*;
/**
* @Author Jsxs
* @Date 2023/4/18 13:54
* @PackageName:com.jsxs.pattern.prototype.demo2
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client{
public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException {
// 1.原型对象的创建
Citation citation = new Citation();
Student student = new Student();
student.setName("原型对象-张三");
citation.setStudent(student);
// 2.创建对象输出流对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("E:\\加速器\\a.txt"));
out.writeObject(citation); //将原型对象写入文件中
out.close(); //关闭资源
ObjectInputStream ipt = new ObjectInputStream(new FileInputStream("E:\\加速器\\a.txt"));
Citation citation1 = (Citation)ipt.readObject();
ipt.close(); //关闭资源
Student student1 = citation1.getStudent();
student.setName("克隆对象-李四");
citation.show();
citation1.show();
System.out.println(student==student1);
}
}
3.工厂方法模式 (单点咖啡和甜点)
(1).概述
需求: 设计一个咖啡点餐系统。
设计1个咖啡类，并定义两个子类(美式咖啡)和拿铁咖啡;再设计一个咖啡店类,咖啡店具有点咖啡的功能。
- 反列
咖啡类
package com.jsxs.pattern.factory.before;
/**
* @Author Jsxs
* @Date 2023/4/17 12:47
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: Coffe
* @Description: TODO 咖啡类
* @Version 1.0
*/
public abstract class Coffee {
// 0. 子类必须要实现抽象方法
public abstract String getName();
// 1.加糖
public void addSuger() {
System.out.println("加糖");
}
// 2.加奶
public void addMilk() {
System.out.println("加奶");
}
}
咖啡类型
package com.jsxs.pattern.factory.before;
/**
* @Author Jsxs
* @Date 2023/4/17 12:51
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: LatteCoffe
* @Description: TODO 拿铁咖啡
* @Version 1.0
*/
public class LatteCoffee extends Coffee{
@Override
public String getName() {
return "拿铁咖啡";
}
}
package com.jsxs.pattern.factory.before;
/**
* @Author Jsxs
* @Date 2023/4/17 12:50
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: AmericanCoffee
* @Description: TODO 美式咖啡
* @Version 1.0
*/
public class AmericanCoffee extends Coffee{
@Override
public String getName() {
return "美式咖啡";
}
}
咖啡商店
package com.jsxs.pattern.factory.before;
/**
* @Author Jsxs
* @Date 2023/4/17 12:52
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: CoffeeStore
* @Description: TODO 咖啡店
* @Version 1.0
*/
public class CoffeeStore {
public Coffee orderCoffee(String type){
// /声明Coffee类型的变量,根据不同类型创建不同的coffee子类对象
Coffee coffee=null;
if ("american".equals(type)){
coffee=new AmericanCoffee(); // 1. 创建一个美食咖啡
}else if ("latte".equals(type)){
coffee=new LatteCoffee(); //2. 创建一个拿铁咖啡
}else {
throw new RuntimeException("对不起,你点的咖啡没有");
}
// 添加配料
coffee.addMilk();
coffee.addSuger();
return coffee;
}
}
package com.jsxs.pattern.factory.before;
/**
* @Author Jsxs
* @Date 2023/4/17 12:57
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
CoffeeStore coffeeStore = new CoffeeStore();
Coffee coffee = coffeeStore.orderCoffee("american");
System.out.println(coffee.getName());
}
}
假如需要新增产品，那么我们就迫不得已需要修改数据
在Java种，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重。假如我们要更换对象，所有new对象的地方需要修改一遍，这显然违背了软件设计的开闭原则。如果使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦。如果要更换对象，直接在工厂里更换该对象即可,达到了对象解耦的目的，所以说: “工厂模式最大的优点是: 解耦”。
(2).简单工厂模式
简单工厂模式不是一种设计模式，反而更像一种编程习惯。
- 结构
简单工厂包含以下的角色
- 抽象产品: 定义了产品的规范、
描述了产品的主要特性和功能。 - 具体产品:
实现或者继承抽象产品的子类 - 具体工厂: 提供了创建产品的方法，调用者通过方法来获取产品。
抽象产品
package com.jsxs.pattern.factory.Single_Factory;
/**
* @Author Jsxs
* @Date 2023/4/17 13:54
* @PackageName:com.jsxs.pattern.factory.Single_Factory
* @ClassName: Coffee
* @Description: TODO
* @Version 1.0
*/
public abstract class Coffee {
// 0. 子类必须要实现抽象方法
public abstract String getName();
// 1.加糖
public void addSuger() {
System.out.println("加糖");
}
// 2.加奶
public void addMilk() {
System.out.println("加奶");
}
}
具体产品
package com.jsxs.pattern.factory.Single_Factory;
/**
* @Author Jsxs
* @Date 2023/4/17 12:51
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: LatteCoffe
* @Description: TODO 拿铁咖啡
* @Version 1.0
*/
public class LatteCoffee extends Coffee {
@Override
public String getName() {
return "拿铁咖啡";
}
}
package com.jsxs.pattern.factory.Single_Factory;
/**
* @Author Jsxs
* @Date 2023/4/17 12:50
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: AmericanCoffee
* @Description: TODO 美式咖啡
* @Version 1.0
*/
public class AmericanCoffee extends Coffee {
@Override
public String getName() {
return "美式咖啡";
}
}
简单工厂
package com.jsxs.pattern.factory.Single_Factory;
/**
* @Author Jsxs
* @Date 2023/4/17 13:56
* @PackageName:com.jsxs.pattern.factory.Single_Factory
* @ClassName: SimleCoffeeFactory
* @Description: TODO 简单工厂
* @Version 1.0
*/
public class SimpleCoffeeFactory {
public Coffee createCoffee(String type){
Coffee coffee=null;
if ("american".equals(type)){
coffee=new AmericanCoffee(); // 1. 创建一个美食咖啡
}else if ("latte".equals(type)){
coffee=new LatteCoffee(); //2. 创建一个拿铁咖啡
}else {
throw new RuntimeException("对不起,你点的咖啡没有");
}
return coffee;
}
}
咖啡店
package com.jsxs.pattern.factory.Single_Factory;
/**
* @Author Jsxs
* @Date 2023/4/17 13:55
* @PackageName:com.jsxs.pattern.factory.Single_Factory
* @ClassName: CoffeeStore
* @Description: TODO
* @Version 1.0
*/
public class CoffeeStore {
// 1.创建点餐业务
public Coffee orderCoffee(String type) {
// 2.具体商品我们去工厂获取
SimpleCoffeeFactory simpleCoffeeFactory = new SimpleCoffeeFactory();
Coffee coffee = simpleCoffeeFactory.createCoffee(type);
// 3.加配料
coffee.addMilk();
coffee.addSuger();
return coffee;
}
}
客户端
package com.jsxs.pattern.factory.Single_Factory;
/**
* @Author Jsxs
* @Date 2023/4/17 14:02
* @PackageName:com.jsxs.pattern.factory.Single_Factory
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
CoffeeStore coffeeStore = new CoffeeStore();
Coffee coffee = coffeeStore.orderCoffee("american");
System.out.println(coffee.getName());
}
}
简单工厂的优缺点
工厂处理创建对象的细节，一旦有了简单工厂类、咖啡店类中的订单方法就变成此对象的客户，后期如果需要咖啡对象直接从该工厂种获取即可，这样也就接触了和Coffee实现类的耦合;同时又产生了新的耦合，咖啡店对象和简单工厂类对象的耦合，工厂对象和商品对象的耦合。
后期如果再加新产品的咖啡，我们势必需要简单工厂类的代码，违反了开闭原则。工厂类的客户端可能有很多，比如创建美团外卖等，这样只要修改该工厂类的代码，省去其他的修改操作。
优点: 封装了创建对象的过程，可以通过参数直接获取对象,把对象的创建和业务逻辑分开，这样以后就避免了修改客户端代码，如果要实现新产品直接修改工厂类，而不要在源代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展
缺点:增加新产品的时候，依然需要修改工厂类，违反了开闭原则
- 简单工厂的扩展
静态工厂:
在开发过程中: 一部分人将工厂类创建对象的功能定义为静态的，这个就是静态工厂模式,也不是23种设计模式之一。
将这个方法更改成: 静态方法
package com.jsxs.pattern.factory.Single_Factory;
/**
* @Author Jsxs
* @Date 2023/4/17 13:56
* @PackageName:com.jsxs.pattern.factory.Single_Factory
* @ClassName: SimleCoffeeFactory
* @Description: TODO 简单工厂
* @Version 1.0
*/
public class SimpleCoffeeFactory {
public static Coffee createCoffee(String type){
Coffee coffee=null;
if ("american".equals(type)){
coffee=new AmericanCoffee(); // 1. 创建一个美食咖啡
}else if ("latte".equals(type)){
coffee=new LatteCoffee(); //2. 创建一个拿铁咖啡
}else {
throw new RuntimeException("对不起,你点的咖啡没有");
}
return coffee;
}
}
利用类名去创建对象
package com.jsxs.pattern.factory.Single_Factory;
/**
* @Author Jsxs
* @Date 2023/4/17 13:55
* @PackageName:com.jsxs.pattern.factory.Single_Factory
* @ClassName: CoffeeStore
* @Description: TODO
* @Version 1.0
*/
public class CoffeeStore {
// 1.创建点餐业务
public Coffee orderCoffee(String type) {
// 2.具体商品我们去工厂获取
Coffee coffee = SimpleCoffeeFactory.createCoffee(type);
// 3.加配料
coffee.addMilk();
coffee.addSuger();
return coffee;
}
}
(3).工厂方法模式
针对上面的优缺点: 使用工厂方法模式就可以完美的解决，完全遵循开闭原则。
定义一个用于创建对象的接口，让子类决定实列化哪个产品对象。工厂方法使一个产品类的实列化延迟到了其他工厂的子类。
- 结构
工厂方法模式的主要角色
- 抽象工厂:
提供一个创建产品的接口,调用者通过它访问具体工厂的工厂方法来创建产品。 - 具体工厂: 主要是实现抽象工厂的抽象方法，完成具体产品的创建
- 抽象产品:
定义了产品的规范,描述了产品的主要特性和功能。 - 具体产品:
实现了产品所定义的接口，由具体的工厂来创建，它同具体工厂之间一一对应。
- 实现
抽象产品
package com.jsxs.pattern.factory.factory_method;
/**
* @Author Jsxs
* @Date 2023/4/17 13:54
* @PackageName:com.jsxs.pattern.factory.Single_Factory
* @ClassName: Coffee
* @Description: TODO
* @Version 1.0
*/
public abstract class Coffee {
// 0. 子类必须要实现抽象方法
public abstract String getName();
// 1.加糖
public void addSuger() {
System.out.println("加糖");
}
// 2.加奶
public void addMilk() {
System.out.println("加奶");
}
}
具体产品
package com.jsxs.pattern.factory.factory_method;
/**
* @Author Jsxs`在这里插入代码片`
* @Date 2023/4/17 12:51
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: LatteCoffe
* @Description: TODO 拿铁咖啡
* @Version 1.0
*/
public class LatteCoffee extends Coffee {
@Override
public String getName() {
return "拿铁咖啡";
}
}
package com.jsxs.pattern.factory.factory_method;
/**
* @Author Jsxs
* @Date 2023/4/17 12:50
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: AmericanCoffee
* @Description: TODO 美式咖啡
* @Version 1.0
*/
public class AmericanCoffee extends Coffee {
@Override
public String getName() {
return "美式咖啡";
}
}
抽象工厂
package com.jsxs.pattern.factory.factory_method;
/**
* @Author Jsxs
* @Date 2023/4/17 14:52
* @PackageName:com.jsxs.pattern.factory.factory_method
* @ClassName: CoffeeFactory
* @Description: TODO 工厂接口
* @Version 1.0
*/
public interface CoffeeFactory {
Coffee createCoffee();
}
具体工厂
package com.jsxs.pattern.factory.factory_method;
/**
* @Author Jsxs
* @Date 2023/4/17 14:53
* @PackageName:com.jsxs.pattern.factory.factory_method
* @ClassName: AmericanCoffeeFactoryImp
* @Description: TODO 实现美式咖啡
* @Version 1.0
*/
public class AmericanCoffeeFactoryImp implements CoffeeFactory{
@Override
public Coffee createCoffee() {
return new AmericanCoffee();
}
}
package com.jsxs.pattern.factory.factory_method;
/**
* @Author Jsxs
* @Date 2023/4/17 14:54
* @PackageName:com.jsxs.pattern.factory.factory_method
* @ClassName: LatteCoffeeFactoryImp
* @Description: TODO 拿铁咖啡实现
* @Version 1.0
*/
public class LatteCoffeeFactoryImp implements CoffeeFactory{
@Override
public Coffee createCoffee() {
return new LatteCoffee();
}
}
咖啡商店
package com.jsxs.pattern.factory.factory_method;
/**
* @Author Jsxs
* @Date 2023/4/17 14:50
* @PackageName:com.jsxs.pattern.factory.factory_method
* @ClassName: CoffeeStore
* @Description: TODO 咖啡店
* @Version 1.0
*/
public class CoffeeStore {
private CoffeeFactory coffeeFactory;
public void setCoffeeFactory(CoffeeFactory coffeeFactory) {
this.coffeeFactory = coffeeFactory;
}
// 点咖啡的功能
public Coffee orderCoffee() {
Coffee coffee = coffeeFactory.createCoffee();
coffee.addMilk();
coffee.addSuger();
return coffee;
}
}
测试类
package com.jsxs.pattern.factory.factory_method;
/**
* @Author Jsxs
* @Date 2023/4/17 14:57
* @PackageName:com.jsxs.pattern.factory.factory_method
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
CoffeeStore coffeeStore = new CoffeeStore();
// 点一杯美式咖啡
coffeeStore.setCoffeeFactory(new AmericanCoffeeFactoryImp());
// 订餐...
Coffee coffee = coffeeStore.orderCoffee();
System.out.println(coffee.getName());
}
}
- 优缺点
优点:
- 用户只需要知道具体工厂的名称就可以得到所要的产品，无须知道产品的具体创建过程。
- 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂，无需对原工厂进行任何修改，满足开闭原则。
缺点:
- 每增加一个产品就需要
增加一个具体产品类和一个对应的具体工厂，增加了系统的复杂性。
4.抽象工厂模式 (咖啡-套餐)
前面介绍的工厂方法模式考虑的是一类产品的生产,如畜牧场只养动物、电视机厂只生产电视。
这些工厂只生产同种类产品,同种类产品称为同等级产品.也就是说:“工厂方法模式只考虑生产同等级的产品,凡是现实生活中许多工厂是综合性的工厂，能生产多等级(种类)的产品，如电器厂及生产电视又生产洗衣机或空调，大学既有软件专业也有生物专业等。”
本节要介绍的抽象工厂模式将考虑多等级产品的生产,将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族。下图所示X轴是产品等级，也就是同一类产品(华为手机 苹果手机)。Y轴是产品族，也就是同一品牌的不同产品(华为手机 华为电脑)，同一品牌的产品产自同一个工厂。
(1).概述
抽象工厂模式:是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所需产品的具体类就能得到同族的不同等级的产品模式结构。
抽象工厂模式是 工厂方法模式的升级版本，工厂方法模式只生产同一个等级的产品，而抽象工厂模式可以生产多个等级的产品。
(2).结构
抽象工厂模式的主要角色:
- 抽象工厂:
提供一个创建产品的接口,它包含了多个创建产品的方法，可以创建多个不同等级的产品 - 具体工厂: 主要是
实现抽象工厂中的多个抽象方法，完成具体产品的创建 - 抽象产品:
定义了产品的规范,描述了产品的主要特性和功能。 - 具体产品:
实现了产品所定义的接口，由具体的工厂来创建，它同具体工厂之间一一对应。
(3).实现
现咖啡店业务发生改变,不仅要生产咖啡还要生产甜点，如提拉米苏、抹茶慕斯等，钥匙按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生类爆炸。其中拿铁咖啡、没事咖啡是一个产品等级，都是咖啡；提拉米苏、抹茶慕斯是一个产品等级；拿铁咖啡和提拉米苏是同一产族(都是意大利风格)，美式咖啡和抹茶慕斯是同一产族(美式风格)。
抽象咖啡
package com.jsxs.pattern.factory.abstract_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 12:47
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: Coffe
* @Description: TODO 咖啡类
* @Version 1.0
*/
public abstract class Coffee {
// 0. 子类必须要实现抽象方法
public abstract String getName();
// 1.加糖
public void addSuger() {
System.out.println("加糖");
}
// 2.加奶
public void addMilk() {
System.out.println("加奶");
}
}
抽象甜品
package com.jsxs.pattern.factory.abstract_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 16:20
* @PackageName:com.jsxs.pattern.factory.abstract_factory
* @ClassName: Dessert
* @Description: TODO 甜品-抽象类
* @Version 1.0
*/
public abstract class Dessert {
public abstract void show();
}
具体咖啡
package com.jsxs.pattern.factory.abstract_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 12:51
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: LatteCoffe
* @Description: TODO 拿铁咖啡
* @Version 1.0
*/
public class LatteCoffee extends Coffee {
@Override
public String getName() {
return "拿铁咖啡";
}
}
package com.jsxs.pattern.factory.abstract_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 12:50
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: AmericanCoffee
* @Description: TODO 美式咖啡
* @Version 1.0
*/
public class AmericanCoffee extends Coffee {
@Override
public String getName() {
return "美式咖啡";
}
}
具体甜品
package com.jsxs.pattern.factory.abstract_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 16:21
* @PackageName:com.jsxs.pattern.factory.abstract_factory
* @ClassName: Trmisu
* @Description: TODO 提拉米苏类
* @Version 1.0
*/
public class Tiramisu extends Dessert{
@Override
public void show() {
System.out.println("提拉米苏-意大利风格");
}
}
package com.jsxs.pattern.factory.abstract_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 16:23
* @PackageName:com.jsxs.pattern.factory.abstract_factory
* @ClassName: MatchaMousee
* @Description: TODO 抹茶慕斯类
* @Version 1.0
*/
public class MatchaMousee extends Dessert{
@Override
public void show() {
System.out.println("抹茶慕斯-美式风格");
}
}
抽象大工厂
package com.jsxs.pattern.factory.abstract_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 16:24
* @PackageName:com.jsxs.pattern.factory.abstract_factory
* @ClassName: DessertFactory
* @Description: TODO
* @Version 1.0
*/
public interface DessertFactory {
// 1.生产咖啡
Coffee createCoffee();
// 2.生产甜品
Dessert createDessert();
}
美式套餐
package com.jsxs.pattern.factory.abstract_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 16:25
* @PackageName:com.jsxs.pattern.factory.abstract_factory
* @ClassName: AmericanFactoryImp
* @Description: TODO 美式风格工厂
* @Version 1.0
*/
public class AmericanFactoryImp implements DessertFactory{
@Override
public Coffee createCoffee() {
return new AmericanCoffee(); // 美式咖啡
}
@Override
public Dessert createDessert() {
return new MatchaMousee(); //抹茶慕斯
}
}
意大利套餐
package com.jsxs.pattern.factory.abstract_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 16:27
* @PackageName:com.jsxs.pattern.factory.abstract_factory
* @ClassName: LatteFactoryImp
* @Description: TODO
* @Version 1.0
*/
public class LatteFactoryImp implements DessertFactory{
@Override
public Coffee createCoffee() {
return new LatteCoffee();
}
@Override
public Dessert createDessert() {
return new Tiramisu(); //提拉米苏
}
}
咖啡店
package com.jsxs.pattern.factory.abstract_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 16:28
* @PackageName:com.jsxs.pattern.factory.abstract_factory
* @ClassName: CofeStore
* @Description: TODO
* @Version 1.0
*/
public class CoffeeStore {
private DessertFactory dessertFactory;
public void setDessertFactory(DessertFactory dessertFactory) {
this.dessertFactory = dessertFactory;
}
public void Order(){
Coffee coffee = dessertFactory.createCoffee();
Dessert dessert = dessertFactory.createDessert();
System.out.println(coffee.getName());
coffee.addMilk();
coffee.addSuger();
dessert.show();
}
}
客户
package com.jsxs.pattern.factory.abstract_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 16:28
* @PackageName:com.jsxs.pattern.factory.abstract_factory
* @ClassName: CofeStore
* @Description: TODO
* @Version 1.0
*/
public class CoffeeStore {
private DessertFactory dessertFactory;
public void setDessertFactory(DessertFactory dessertFactory) {
this.dessertFactory = dessertFactory;
}
public void Order(){
Coffee coffee = dessertFactory.createCoffee();
Dessert dessert = dessertFactory.createDessert();
System.out.println(coffee.getName());
coffee.addMilk();
coffee.addSuger();
dessert.show();
}
}
如果我们需要再添加套餐(产品族)的话，只需要再加一个对应的工厂类即可，不需要再修改其他的类。
(4).优缺点
优点:
当一个产品族(套餐)中的多个对象被设计成一起工作的时候,它能保证客户端始终只使用同一个产品族中的对象 (套餐的对象必定一定)。
缺点:
当产品族中需要增加一个新的产品时,所有的工厂类都需要进行修改。eg:美式套餐中我们赠送一个意大利风格的甜品。(不能赠送或新增单个产品，可以新增一整个套餐)
(5).使用场景
- 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视、洗衣机、空调等。
- 系统中有多个产品族。但每次只使用其中的某一族产品。如有人只喜欢穿一个指定的套餐(固定的产品族)
- 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实列的创建细节和内部结构。如: 输入法换皮肤，一整套一整套的换。生成不同的操作系统程序。
(6).JDK源码解析- Collection.iterator方法
使用迭代器遍历集合，获取集合中的元素。而单列集合获取迭代器的方法就使用到了工厂方法模式。
5.工厂模式的扩展💔 -(这个不属于23种)
简单工厂+配置文件解除耦合
可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合。在工厂中加载配置文件中的全类名，并创建对象和存储，客户端如果需要对象对象，直接进行获取即可。
beans.properties: 配置文件
american=com.jsxs.pattern.factory.config_factory.AmericanCoffee
latte=com.jsxs.pattern.factory.config_factory.LatteCoffee
咖啡抽象类
package com.jsxs.pattern.factory.config_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 13:54
* @PackageName:com.jsxs.pattern.factory.Single_Factory
* @ClassName: Coffee
* @Description: TODO
* @Version 1.0
*/
public abstract class Coffee {
// 0. 子类必须要实现抽象方法
public abstract String getName();
// 1.加糖
public void addSuger() {
System.out.println("加糖");
}
// 2.加奶
public void addMilk() {
System.out.println("加奶");
}
}
具体实现
package com.jsxs.pattern.factory.config_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 12:50
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: AmericanCoffee
* @Description: TODO 美式咖啡
* @Version 1.0
*/
public class AmericanCoffee extends Coffee {
@Override
public String getName() {
return "美式咖啡";
}
}
package com.jsxs.pattern.factory.config_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 12:51
* @PackageName:com.jsxs.pattern.factory.before
* @ClassName: LatteCoffe
* @Description: TODO 拿铁咖啡
* @Version 1.0
*/
public class LatteCoffee extends Coffee {
@Override
public String getName() {
return "拿铁咖啡";
}
}
咖啡工厂类
package com.jsxs.pattern.factory.config_factory;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Properties;
import java.util.Set;
/**
* @Author Jsxs
* @Date 2023/4/17 17:50
* @PackageName:com.jsxs.pattern.factory.config_factory
* @ClassName: CoffeeFactory
* @Description: TODO 咖啡工厂类
* @Version 1.0
*/
public class CoffeeFactory {
// 1. 加载配置文件，获取配置文件中配置的全类名，并创建该类的对象进行存储
//2.定义容器对象存储咖啡对象
private static HashMap<String,Coffee> map=new HashMap<String,Coffee>();
//3.加载配置文件,只需要加载一次
static {
//3.1创建Properties对象
Properties properties = new Properties();
//3.2调用load方法进行加载
InputStream in = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties"); //获取输入流、读取哪个文件
try {
properties.load(in); //这个参数是: 输入流。加载完毕之后，这个properties就已经存在数据了。
//3.3从properties集合中获取全类名创建对象
Set<Object> keys = properties.keySet(); // 获取配置文件中全部的键
for (Object key : keys) {
String ClassName = properties.getProperty((String) key); // 通过获取到配置文件中的键，我们得到值。
//3.4 通过反射去创建对象
Class aClass = Class.forName(ClassName); // 通过加载类全民获取字节码对象
Coffee coffee = (Coffee) aClass.newInstance(); //通过无参构造创建对象
// 将名称和对象那个存储到我们自定义的容器中
map.put((String) key,coffee);
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
// 根据名称获取对象
public static Coffee createCoffee(String type){
return map.get(type);
}
}
package com.jsxs.pattern.factory.config_factory;
/**
* @Author Jsxs
* @Date 2023/4/17 18:09
* @PackageName:com.jsxs.pattern.factory.config_factory
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
Coffee coffee = CoffeeFactory.createCoffee("latte");
System.out.println(coffee.getName());
}
}
静态成员变量用来存储创建的对象(键存储的是名称、值存储的是对应的对象)，而读取配置文件以及创建对象写在静态代码块中，目的就是只需执行一次。
6.建造者模式
(1).概述
将一个复杂对象的构建与便是分离，使得同样的构建过程可以创建不同的表示。
将主机拆开就是分离，将分离的主机合起来就是构建。在一样的构建方法中我们更换掉不同品牌的相同组件就是创建了不同的主机
- 分离了部件的构造(由Builder来负责)和装配(由Director负责)。从而可以构建出复杂的对象。这个模式适用于:
某个对象的构建过程复杂的情况。 - 由于实现了构建和装配的解耦。
不同的构建器，相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法。装配算法的解耦，实现了更好的复用。 建造者模式可以将部件和其组装过程分开，一步步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。
(2).结构
建造者(Builder)模式包含如下角色
- 抽象建造者类(Builder): 这个接口要实现复杂对象的那些部分的创建，并不涉及具体的对象部件的创建。
- 具体建造者类(ConCreteBuilder): 实现Builder接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实列。
- 产品类(Product): 要创建的复杂对象。
- 指挥者类(Director):调用具体建造者来创建复杂对象的各个部分，在知道者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
(3).实列
创建共享单车
生产自行车是一个复杂的过程，它包含了车架，车座等组件的生产。而车架又有碳纤维，铝合金等材质的，车座有橡胶，真皮等材质。对于自行车的生产就可以使用建造者模式。
这里的Bike是产品，包含车架，车座等组件；Builder是抽象建造者，摩拜单车公司和ofo公司是具体的创建者;Direct是指挥者。
protected:访问权限->本类以及本类的子类。创建对象的i两种方式->有参创造和无参创造。无参创造会回溯到祖宗类Object类，所以不管用哪种方式->我们尽量带上无参构造
- 指挥者和抽象类分离
产品
package com.jsxs.pattern.build.demo1;
/**
* @Author Jsxs
* @Date 2023/4/18 15:40
* @PackageName:com.jsxs.pattern.build.demo1
* @ClassName: Bike
* @Description: TODO 具体的产品对象
* @Version 1.0
*/
public class Bike {
private String frame; //车架
private String seat; //车座
public String getFrame() {
return frame;
}
public void setFrame(String frame) {
this.frame = frame;
}
public String getSeat() {
return seat;
}
public void setSeat(String seat) {
this.seat = seat;
}
}
建造者接口
package com.jsxs.pattern.build.demo1;
/**
* @Author Jsxs
* @Date 2023/4/18 15:42
* @PackageName:com.jsxs.pattern.build.demo1
* @ClassName: Builder
* @Description: TODO
* @Version 1.0
*/
public abstract class Builder {
// 1.声明Bike类型的变量
protected Bike bike=new Bike(); // 设计图或者概念-还没组装
public abstract void buildFame(); //车架
public abstract void buildSeat(); //车座
public abstract Bike createBike(); //构建具体自行车的方法
}
具体建造者
package com.jsxs.pattern.build.demo1;
/**
* @Author Jsxs
* @Date 2023/4/18 15:50
* @PackageName:com.jsxs.pattern.build.demo1
* @ClassName: MobileCompany
* @Description: TODO 摩拜公司
* @Version 1.0
*/
public class MobileCompany extends Builder{
@Override
public void buildFame() {
bike.setFrame("摩拜-车架");
}
@Override
public void buildSeat() {
bike.setFrame("摩拜-车座");
}
@Override
public Bike createBike() {
return bike;
}
}
package com.jsxs.pattern.build.demo1;
/**
* @Author Jsxs
* @Date 2023/4/18 15:52
* @PackageName:com.jsxs.pattern.build.demo1
* @ClassName: OfoCompany
* @Description: TODO
* @Version 1.0
*/
public class OfoCompany extends Builder{
@Override
public void buildFame() {
bike.setFrame("off-车架");
}
@Override
public void buildSeat() {
bike.setSeat("off-车座");
}
@Override
public Bike createBike() {
return bike;
}
}
指挥者
package com.jsxs.pattern.build.demo1;
/**
* @Author Jsxs
* @Date 2023/4/18 15:55
* @PackageName:com.jsxs.pattern.build.demo1
* @ClassName: Director
* @Description: TODO 总工程师-指挥者
* @Version 1.0
*/
public class Director {
// 声明Builder类型的变量
private Builder builder;
// 声明有参构造创建对象
public Director(Builder builder) {
this.builder = builder;
}
// 组装自行车的功能
public Bike construct(){ //构造自行车
this.builder.buildFame();
this.builder.buildSeat();
return builder.createBike();
}
}
客户端
package com.jsxs.pattern.build.demo1;
/**
* @Author Jsxs
* @Date 2023/4/18 16:32
* @PackageName:com.jsxs.pattern.build.demo1
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
Director director = new Director(new MobileCompany());
// 指挥者组装对象
Bike bike = director.construct();
System.out.println(bike.getFrame());
}
}
指挥者类Director在建造者模式中很重要，它用于知道具体构建这如何构建产品，控制调用先后次序，并向调用者返回完整的产品类，但是有一些情况需要简化系统结构，可以把指挥者类和抽象类建造者进行结合
- 抽象类和建造者不分离
自行车产品
package com.jsxs.pattern.build.demo1;
/**
* @Author Jsxs
* @Date 2023/4/18 15:40
* @PackageName:com.jsxs.pattern.build.demo1
* @ClassName: Bike
* @Description: TODO 具体的产品对象
* @Version 1.0
*/
public class Bike {
private String frame; //车架
private String seat; //车座
public String getFrame() {
return frame;
}
public void setFrame(String frame) {
this.frame = frame;
}
public String getSeat() {
return seat;
}
public void setSeat(String seat) {
this.seat = seat;
}
}
抽象创建者--- 结合
package com.jsxs.pattern.build.demo1;
/**
* @Author Jsxs
* @Date 2023/4/18 15:42
* @PackageName:com.jsxs.pattern.build.demo1
* @ClassName: Builder
* @Description: TODO
* @Version 1.0
*/
public abstract class Builder {
// 1.声明Bike类型的变量
protected Bike bike=new Bike(); // 设计图或者概念-还没组装
public abstract void buildFame(); //车架
public abstract void buildSeat(); //车座
public abstract Bike createBike(); //构建具体自行车的方法
// 组装自行车的功能
public Bike construct(){ //构造自行车
this.buildFame();
this.buildSeat();
return this.createBike();
}
}
具体建造者
package com.jsxs.pattern.build.demo1;
/**
* @Author Jsxs
* @Date 2023/4/18 15:50
* @PackageName:com.jsxs.pattern.build.demo1
* @ClassName: MobileCompany
* @Description: TODO 摩拜公司
* @Version 1.0
*/
public class MobileCompany extends Builder{
@Override
public void buildFame() {
bike.setFrame("摩拜-车架");
}
@Override
public void buildSeat() {
bike.setFrame("摩拜-车座");
}
@Override
public Bike createBike() {
return bike;
}
@Override
public Bike construct() {
return super.construct();
}
}
package com.jsxs.pattern.build.demo1;
/**
* @Author Jsxs
* @Date 2023/4/18 15:52
* @PackageName:com.jsxs.pattern.build.demo1
* @ClassName: OfoCompany
* @Description: TODO
* @Version 1.0
*/
public class OfoCompany extends Builder{
@Override
public void buildFame() {
bike.setFrame("off-车架");
}
@Override
public void buildSeat() {
bike.setSeat("off-车座");
}
@Override
public Bike createBike() {
return bike;
}
@Override
public Bike construct() {
return super.construct();
}
}
客户端
package com.jsxs.pattern.build.demo1;
/**
* @Author Jsxs
* @Date 2023/4/18 16:32
* @PackageName:com.jsxs.pattern.build.demo1
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
MobileCompany mobileCompany = new MobileCompany();
Bike bike = mobileCompany.construct();
System.out.println(bike.getFrame());
}
}
说明: 这样做确实简化了系统结构，让生产者来构建自行车，但同时也加重了抽象建造者类的职责，也不是太符合单一职责的原则。如果构建自行车contrstuct()这个方法过于复杂，建议还是封装到指挥者中。
(4).优缺点
优点:
-
建造者模式的封装性很好。使用建造者模式可以有效地封装变化，在使用建造者模式的场景中，一般产品类和建造这类是比较稳定的，因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。 -
在建造者模式中，客户端不必知道产品内部组成的细节，
将产品与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。 -
可以更加精密地控制产品地创建过程。将复杂产品地创建步骤分解在不同地方法中，使得创建过程更加清晰，也是更方便使用程序来控制创建过程。 -
建造者模式很容易进行扩展，通过一个新的建造者类就可以完成，基本上不用修改之前已经测试通过地代码，因此也就不会对原有功能引入风险，符合开闭原则。
缺点:
建造者模式所创建地产品一般具有较多地共同点，其组成部分很相似，如果产品之间地差异性很大，则不适用建造者模式，因此其实用范围收到一定限制。
(5).使用场景
建造者模式创建地是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在一下场合使用:
- 创建的对象比较复杂，有多个部件构成，
各部件面临着复杂的变化，但构件间的建造顺序是稳定的。 - 常见复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。
(6).模式扩展
建造者模式除了上面的用途外，在开发中还有一个常用的使用方式，就是当一个类构造器需要传入很多参数时，如果创建这个类的实列，代码可读性会非常差，而且很容易引入错误，此时就应该利用建造者模式进行重构。
package com.jsxs.pattern.build.demo2;
/**
* @Author Jsxs
* @Date 2023/4/18 17:18
* @PackageName:com.jsxs.pattern.build.demo2
* @ClassName: Phone
* @Description: TODO
* @Version 1.0
*/
public class Phone {
private String cpu;
private String Screen;
private String money;
private String mainBoard;
// 私有构造方法
private Phone(Builder builder) {
this.cpu = builder.cpu;
this.Screen = builder.Screen;
this.money = builder.money;
this.mainBoard = builder.mainBoard;
}
// 静态内部类
public static final class Builder{
private String cpu;
private String Screen;
private String money;
private String mainBoard;
public Builder cpu(String cpu) {
this.cpu = cpu;
return this;
}
public Builder screen(String screen) {
this.Screen = screen;
return this;
}
public Builder money(String money) {
this.money = money;
return this;
}
public Builder mainBoard(String mainBoard) {
this.mainBoard = mainBoard;
return this;
}
public Phone build(){
return new Phone(this); // 传递这个内部类
}
@Override
public String toString() {
return "Builder{" +
"cpu='" + cpu + '\'' +
", Screen='" + Screen + '\'' +
", money='" + money + '\'' +
", mainBoard='" + mainBoard + '\'' +
'}';
}
}
@Override
public String toString() {
return "Phone{" +
"cpu='" + cpu + '\'' +
", Screen='" + Screen + '\'' +
", money='" + money + '\'' +
", mainBoard='" + mainBoard + '\'' +
'}';
}
}
package com.jsxs.pattern.build.demo2;
/**
* @Author Jsxs
* @Date 2023/4/18 17:26
* @PackageName:com.jsxs.pattern.build.demo2
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
// 利用建造者创建对象 ---- 因为这些方法的返回值对象都是当前对象，所以可以使用链式编程
Phone.Builder builder = new Phone.Builder()
.cpu("inter")
.screen("三星")
.mainBoard("苹果")
.money("1200");
Phone phone = builder.build();
System.out.println(phone);
}
}
重构后的代码在使用起来更方便，某种程度上可以提高开发效率。从软件设计，对程序员的要求比较高。
7.创建者模式对比
(1).工厂方法模式VS建造者模式
工厂方法模式注重的是整体对象的创建方式(结果);而建造者模式注重的是部件构建的过程(过程)，意在通过一步步地精确构造出一个复杂地对象。
我们举个简单的列子来说明两者地差异: 如要制造一个超人，如果使用工厂方法模式，直接生产出来地就是一个力大无穷、能够飞翔、内裤外穿地超人；而如果使用建造者模式，则需要组装收、头、脚、驱赶，然后再把内裤外穿，于是一个超人就诞生了。
(2).抽象工厂模式VS建造者模式
抽象工厂模式实现对产品家族地创建，一个产品家族是这样地一系列产品;具有不同分类欸都地产品组合,采用抽象工厂模式是不需要关心构建过程，只关心什么产品由什么工厂生产即可。
建造者模式则是要求按照指定地蓝图建造产品，他的主要目的是通过组件装零配件而生产地一个新产品。
如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族地产品.那么建造者模式就是一个汽车组装工厂，通过对部件地组装可以返回一量完整的汽车。
