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建造者模式
- (三)、结构性模式(7种)
- 1.代理模式
- (1).概述
- (2).结构
- (3).静态代理
- (4).JDK动态代理
- (5).GCLIB动态代理
- (6).三种代理的对比
- (7).代理模式的优缺点
- (8).使用场景
- 2.适配器模式
- (1).概述
- (2).结构
- (3).类适配器模式实现
- (4).对象适配器模式
- (5).应用场景
- (6).JDK源码解析
- 3.桥接模式
- (1).概述
- (2).结构
- (3).案列
- (4).使用场景
- 4.装饰者模式
- (1).概述
- (2).结构
- (3).案列
- (4).使用场景
- (5).JDK源码解析
- (6).代理和装饰者的区别
- 5.外观模式
- (1).概述
- (2).结构
- (3).案例
- (4).使用场景
- (5).源码分析
- 6.享元模式
- (1).概述
- (2).结构
- (3).享元模式案列
- (6).优缺点和使用场景
- 7.组合模式
- (1).概述
- (2).结构
- (3).案列实现
- (4).组合模式的分类
- (5).使用场景
- (7).JDK源码分析
(一)、设计模式相关内容介绍
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建造者模式
抽象工厂模式实现对产品家族地创建，一个产品家族是这样地一系列产品;具有不同分类欸都地产品组合,采用抽象工厂模式是不需要关心构建过程，只关心什么产品由什么工厂生产即可。
建造者模式则是要求按照指定地蓝图建造产品，他的主要目的是通过组件装零配件而生产地一个新产品。
如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族地产品.那么建造者模式就是一个汽车组装工厂，通过对部件地组装可以返回一量完整的汽车。
(三)、结构性模式(7种)
结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构性模式和对象结构型模式，前者采用继承机制来组织接口和类，后者采用组合或聚合来组合对象。
由于组合关系或聚合关系比继承关系的耦合度低，满足合成复用原则，所以对象结构型模式比类结构型模式具有更大的灵活性。
1.代理模式
(1).概述
由于某些原因需要给某个对象(结婚对象)提供一个代理(婚介)以控制对该对象的访问(结婚仪式)。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。
eg: 结婚: 找婚介。
Java中的代理按照代理类生成时机不同分为静态代理和动态代理。静态代理类在编译期就生成，而动态代理类则是在Java运行时动态生成。动态代理又有JDK和GCLib代理两种。
(2).结构
代理模式分为三种角色:
- 抽象主题类: 通过
接口或抽象类声明真实主题和代理对象实现的业务方法(结婚)。 - 真实主题类:实现了抽象主题的
具体业务,是代理对象所代表的真实对象,是最终要引入的对象(新人)。 - 代理类: 提供了与真实主题相同的接口,其内部含有对真实主题的引用，他可以访问、控制或扩展真实主题的功能(婚介所)。
(3).静态代理
我们通过案列来感觉一下静态代理。
eg: 火车站买票
如果要买火车票的话,我们需要去火车站买票，排队等一系列的操作,显然比较麻烦。而火车站多个地方都有代售点,我们去代售点买火车票就方便很多了。这个列子其实就是典型的代理模式，火车站是目标对象，代售点是代理对象。
抽象主题类
package com.jsxs.structure.proxy.static_proxy;
/**
* @Author Jsxs
* @Date 2023/4/19 13:40
* @PackageName:com.jsxs.structure.proxy.static_proxy
* @ClassName: SellTickets
* @Description: TODO 卖火车票的接口
* @Version 1.0
*/
public interface SellTickets {
void sell();
}
真实主题类
package com.jsxs.structure.proxy.static_proxy;
/**
* @Author Jsxs
* @Date 2023/4/19 13:41
* @PackageName:com.jsxs.structure.proxy.static_proxy
* @ClassName: TrainStation
* @Description: TODO 火车站类
* @Version 1.0
*/
public class TrainStation implements SellTickets{
@Override
public void sell() {
System.out.println("在火车站进行卖票业务");
}
}
代理类
package com.jsxs.structure.proxy.static_proxy;
/**
* @Author Jsxs
* @Date 2023/4/19 13:42
* @PackageName:com.jsxs.structure.proxy.static_proxy
* @ClassName: ProxyPoint
* @Description: TODO 代售点
* @Version 1.0
*/
public class ProxyPoint implements SellTickets{
private TrainStation trainStation=new TrainStation();
@Override
public void sell() {
System.out.println("代售点收取服务费帮火车站卖票，票的来源是火车站");
trainStation.sell();
}
}
从上面的代码中我们可以看出测试类直接访问的是ProxyPoint类对象,也就是说ProxyPoint作为访问对象和目标对象的中介。同时也对sell方法进行了增强(代理点收取一些服务费用)
(4).JDK动态代理
我们使用上面的案例进行动态代理,先说说JDK提供的动态代理。Java中提供了一个动态代理类Proxy,Proxy并不是我们上述所说的代理对象的类,而是提供了一个创建代理对象的静态方法来获取对象。
抽象主题类
package com.jsxs.structure.proxy.jdk_proxy;
/**
* @Author Jsxs
* @Date 2023/4/19 13:40
* @PackageName:com.jsxs.structure.proxy.static_proxy
* @ClassName: SellTickets
* @Description: TODO 卖火车票的接口
* @Version 1.0
*/
public interface SellTickets {
void sell();
}
真实主题类
package com.jsxs.structure.proxy.jdk_proxy;
/**
* @Author Jsxs
* @Date 2023/4/19 13:41
* @PackageName:com.jsxs.structure.proxy.static_proxy
* @ClassName: TrainStation
* @Description: TODO 火车站类
* @Version 1.0
*/
public class TrainStation implements SellTickets {
@Override
public void sell() {
System.out.println("在火车站进行卖票业务");
}
}
JDK动态代理类
package com.jsxs.structure.proxy.jdk_proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @Author Jsxs
* @Date 2023/4/19 14:04
* @PackageName:com.jsxs.structure.proxy.jdk_proxy
* @ClassName: ProxyFactory
* @Description: TODO 获取代理对象的工厂类
* @Version 1.0
*/
public class ProxyFactory {
// 1.声明目标对象
private TrainStation trainStation=new TrainStation();
// 2.获取代理对象的方法
public SellTickets getProxyObject(){
// 返回代理对象即可
/**
* 1.类加载器: 用于加载代理类。可以通过目标对象获取类加载器
* 2.代理类实现的接口的字节码对象
* 3. 代理对象的调用处理程序:
*/
SellTickets proxyObject = (SellTickets)Proxy.newProxyInstance(trainStation.getClass().getClassLoader(), trainStation.getClass().getInterfaces(), new InvocationHandler() {
/**
*
* @param proxy 代理对象: 和proxyObject对象是同一个对象,在invoke方法中基本不用
* @param method 对接口中的方法进行封装的method对象
* @param args 调用方法的参数
* @return 方法的返回值
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代售点收取一定的服务费用(JDK动态代理)...");
Object invoke = method.invoke(trainStation, args);
return invoke;
}
});
return proxyObject;
}
}
客户端
package com.jsxs.structure.proxy.jdk_proxy;
/**
* @Author Jsxs
* @Date 2023/4/19 14:18
* @PackageName:com.jsxs.structure.proxy.jdk_proxy
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
// 1.创建代理类工厂
ProxyFactory proxyFactory = new ProxyFactory();
// 2.获取代理对象
SellTickets proxyObject = proxyFactory.getProxyObject();
// 3.调用售卖的方法
proxyObject.sell();
}
}
使用动态代理,我们思考下面问题
- Proxy是代理类嘛?
ProxyFactory不是代理模式中所说的代理类，而代理类是程序在运行过程中动态的在内存中生成的类。通过阿里巴巴开源的Java诊断工具(Arthas)查看代理类的结构。
(5).GCLIB动态代理
同样是上面的案列,我们再次使用GCLIB代理实现。
如果没有定义SellTickets接口，只定义了TrainStation(火车站)。很显然JDK代理是无法使用了,因为JDK动态代理要求必须定义接口，对接口进行代理。
GCLIB是一个功能强大，高i性能的代码生成包。它没有实现接口的类提供代理类，为JDK的动态代理做了很好的补充。
GCLIB是第三方提供的包,所以需要引入jar包的坐标。
<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
火车站售票业务
package com.jsxs.structure.proxy.cglib_proxy;
/**
* @Author Jsxs
* @Date 2023/4/19 13:41
* @PackageName:com.jsxs.structure.proxy.static_proxy
* @ClassName: TrainStation
* @Description: TODO 火车站类
* @Version 1.0
*/
public class TrainStation {
public void sell() {
System.out.println("在火车站进行卖票业务");
}
}
代理工厂
package com.jsxs.structure.proxy.cglib_proxy;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @Author Jsxs
* @Date 2023/4/19 15:08
* @PackageName:com.jsxs.structure.proxy.cglib_proxy
* @ClassName: ProxyFactory
* @Description: TODO
* @Version 1.0
*/
public class ProxyFactory implements MethodInterceptor {
// 1.声明目标对象
private TrainStation trainStation= new TrainStation();
// 2.获取代理类
public TrainStation getTrainStation(){
// 创建Enhancer对象,雷士与JDK中的Proxy类
Enhancer enhancer = new Enhancer();
// 设置父类的字节码对象
enhancer.setSuperclass(trainStation.getClass());
// 设置回调函数
enhancer.setCallback(this); //MethodInterceptor父类的子类也就是 ProxyFactory;
// 创建代理对象
TrainStation proxyObject =(TrainStation) enhancer.create();
return proxyObject;
}
/**
*
* @param o
* @param method 方法
* @param objects 参数
* @param methodProxy
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("代售点收取费用");
Object invoke = method.invoke(trainStation, objects);
return invoke;
}
}
客户端
package com.jsxs.structure.proxy.cglib_proxy;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @Author Jsxs
* @Date 2023/4/19 15:15
* @PackageName:com.jsxs.structure.proxy.cglib_proxy
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
// 创建代理工厂
ProxyFactory proxyFactory = new ProxyFactory();
// 获取代理对象
TrainStation proxyObject = proxyFactory.getTrainStation();
// 对象调离对象中的卖票方法
proxyObject.sell();
}
}
(6).三种代理的对比
- JDK代理和GCLIB代理
使用GCLIB实现动态代理，GCLIB底层采用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用Java反射效率要高。唯一需要注意的是,GCLIB不能对声明finnal的类或者方法进行动态代理，因为GCLIB原理是动态生成被代理类的子类。
在JDK1.6、JDK1.7、JDK1.8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于GCLIB代理效率，只有当进行大量调用的时候，JDK1.6和JDK1.7比GCLIB代理效率低一点，但是到JDK1.8的时候，JDK代理效率高于GCLIB代理，所以如果有接口使用JDK动态代理，如果没有接口使用GCLIB代理。
- 动态代理和静态代理
动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转义到调用处理器一个几种的方法中处理。这样,在接口方法数量比较多的时候，我们可以更加灵活处理，而不需要像静态代理那样每一个方法都需要中转，
如果接口增加一个方法，静态代理模式除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。而动态代理不会出现这个问题。
(7).代理模式的优缺点
优点:
- 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用。
- 代理对象可以扩展目标对象的功能
- 代理模式能将客户端与目标对象分离,在一定程度上降低了系统的耦合度。
缺点:
- 增加了系统的复杂度
(8).使用场景
- 远程代理
本地服务通过网络请求远程服务。为了实现本地到远程的通信,我们需要实现网络通信,处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程服务的功能，而不必过多关系通信的细节。 - 防护墙代理(VPN)
当你将浏览器配置成功使用代理功能时，防火墙就将我们的浏览器的请求转发给互联网;当互联网返回响应时，代理服务器再把它转给你的浏览器。 - 保护代理
控制对一个对象的访问，如果需要可以给不同的用户提供不同级别的使用权限。
2.适配器模式
(1).概述
如果去欧洲国家去旅游的话,它们的插座如下图最左边，是欧洲的标准。为我们使用的插头如下图最右边的。因此我们的笔记本电脑，收集在当地不能直接充电的，所以需要一个插座转换器，转换器第一面插入地面的插座，第二面供我们充电，这样使得我们的插头就能在当地使用。生活中这样的列子很多，收集充电器(将220v转换为5v的电压)，读卡器等，其实就是使用到了适配器模式。
定义:将一个类的接口转换为客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能够一起工作。适配器模式分为类适配器模式和对象适配器模式,前者类之间的耦合度比后者高,且要求程序员了解 现有组件库中的相关组件的内部结构，所以应用相对较少。
(2).结构
适配器模式包含以下主要角色:
目标接口: 当前系统业务所期待的接口，它可以是抽象类或者接口(中国接口)适配者类: 它是被访问和适配的现存组件库中的组件接口(欧洲接口)适配器类: 他是一个转换器，通过继承或引用适配者的对象，把适配者接口转换为目标接口，让客户按照目标接口的格式访问适配者。(转换器)
(3).类适配器模式实现
实现方式: 定义一个适配器类(转换器)来实现当前系统的业务接口(中国)，同时又继承现有组件库中已经存在的组件(欧洲)。
eg: 读卡器
现在已经有一台电脑只能读取SD卡(目标接口)，而要读取TE卡中的内容就需要使用到适配器模式。创建一个读卡器，将TE卡中的内容读取出来。
目标接口(中国)
package com.jsxs.structure.adapter.class_adapter;
/**
* @Author Jsxs
* @Date 2023/4/20 18:47
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: SDScard
* @Description: TODO 目标接口 (SD卡)
* @Version 1.0
*/
public interface SDCard {
// 从SD卡中读取数据
String readSD();
//往SD卡中写数据
void writeSD(String msg);
}
package com.jsxs.structure.adapter.class_adapter;
/**
* @Author Jsxs
* @Date 2023/4/20 18:49
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: SDCardIml
* @Description: TODO
* @Version 1.0
*/
public class SDCardIml implements SDCard{
@Override
public String readSD() {
String msg="SDCard red msg : hello word";
return msg;
}
@Override
public void writeSD(String msg) {
System.out.println("SDCard write msg:"+msg);
}
}
适配者类()欧洲
package com.jsxs.structure.adapter.class_adapter;
/**
* @Author Jsxs
* @Date 2023/4/20 18:42
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: TFCard
* @Description: TODO 适配者类的接口
* @Version 1.0
*/
public interface TFCard {
// 从TF卡中读取数据
String readTF();
// 网TF卡中写数据
void writeTF(String msg);
}
package com.jsxs.structure.adapter.class_adapter;
/**
* @Author Jsxs
* @Date 2023/4/20 18:44
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: TFCardImi
* @Description: TODO 适配者类
* @Version 1.0
*/
public class TFCardImi implements TFCard{
@Override
public String readTF() {
String msg="TFCARD READ MSG: HELLO WORLD";
return msg;
}
@Override
public void writeTF(String msg) {
System.out.println("TFCARD WRITE MSG:"+msg);
}
}
计算机类
package com.jsxs.structure.adapter.class_adapter;
/**
* @Author Jsxs
* @Date 2023/4/20 18:54
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: Computer
* @Description: TODO 计算机类
* @Version 1.0
*/
public class Computer {
// 从SD卡中读取数据
public String readSD(SDCard sdCard){
if (sdCard==null){
throw new RuntimeException("SDCard is not null");
}
return sdCard.readSD();
}
}
适配器类()转换器
package com.jsxs.structure.adapter.class_adapter;
/**
* @Author Jsxs
* @Date 2023/4/20 18:59
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: SDAdapterTF
* @Description: TODO 适配器类 (转换器)
* @Version 1.0
*/
public class SDAdapterTF extends TFCardImi implements SDCard{ //实现当前业务的接口、同时继承已经存在的的组件。
@Override
public String readSD() {
return this.readTF();
}
@Override
public void writeSD(String msg) {
this.writeTF(msg);
}
}
测试类
package com.jsxs.structure.adapter.class_adapter;
/**
* @Author Jsxs
* @Date 2023/4/20 18:56
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
// 创建计算机对象
Computer computer = new Computer();
//读取SD卡中的数据
String s = computer.readSD(new SDCardIml());
System.out.println(s);
System.out.println("--------------------------");
// 使用该计算机读取TF卡中的数据
// 定义适配器类
SDAdapterTF sdAdapterTF = new SDAdapterTF();
// 适配器可以访问TF卡
String s1 = sdAdapterTF.readTF();
System.out.println(s1);
}
}
类适配器模式违背了合成复用原则。类适配器是客户类有一个接口规范的情况下可以，反之不可
(4).对象适配器模式
实现方式: 对象适配器模式可采用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口。
目标接口(中国)
package com.jsxs.structure.adapter.class_adapter;
/**
* @Author Jsxs
* @Date 2023/4/20 18:47
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: SDScard
* @Description: TODO 目标接口 (SD卡)
* @Version 1.0
*/
public interface SDCard {
// 从SD卡中读取数据
String readSD();
//往SD卡中写数据
void writeSD(String msg);
}
package com.jsxs.structure.adapter.class_adapter;
/**
* @Author Jsxs
* @Date 2023/4/20 18:49
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: SDCardIml
* @Description: TODO
* @Version 1.0
*/
public class SDCardIml implements SDCard{
@Override
public String readSD() {
String msg="SDCard red msg : hello word";
return msg;
}
@Override
public void writeSD(String msg) {
System.out.println("SDCard write msg:"+msg);
}
}
适配者类()欧洲
package com.jsxs.structure.adapter.class_adapter;
/**
* @Author Jsxs
* @Date 2023/4/20 18:42
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: TFCard
* @Description: TODO 适配者类的接口
* @Version 1.0
*/
public interface TFCard {
// 从TF卡中读取数据
String readTF();
// 网TF卡中写数据
void writeTF(String msg);
}
package com.jsxs.structure.adapter.class_adapter;
/**
* @Author Jsxs
* @Date 2023/4/20 18:44
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: TFCardImi
* @Description: TODO 适配者类
* @Version 1.0
*/
public class TFCardImi implements TFCard{
@Override
public String readTF() {
String msg="TFCARD READ MSG: HELLO WORLD";
return msg;
}
@Override
public void writeTF(String msg) {
System.out.println("TFCARD WRITE MSG:"+msg);
}
}
计算机类
package com.jsxs.structure.adapter.class_adapter;
/**
* @Author Jsxs
* @Date 2023/4/20 18:54
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: Computer
* @Description: TODO 计算机类
* @Version 1.0
*/
public class Computer {
// 从SD卡中读取数据
public String readSD(SDCard sdCard){
if (sdCard==null){
throw new RuntimeException("SDCard is not null");
}
return sdCard.readSD();
}
}
这里修改成聚合
package com.jsxs.structure.adapter.object_adpater;
/**
* @Author Jsxs
* @Date 2023/4/20 18:59
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: SDAdapterTF
* @Description: TODO 适配器类 (转换器)
* @Version 1.0
*/
public class SDAdapterTF implements SDCard { //实现当前业务的接口、同时继承已经存在的的组件。
// 聚合适配者类
private TFCard tfCard;
// 设置有参构造方法,目的是使用哪个实现类
public SDAdapterTF(TFCard tfCard) {
this.tfCard = tfCard;
}
@Override
public String readSD() {
return tfCard.readTF();
}
@Override
public void writeSD(String msg) {
tfCard.writeTF(msg);
}
}
package com.jsxs.structure.adapter.object_adpater;
/**
* @Author Jsxs
* @Date 2023/4/20 18:56
* @PackageName:com.jsxs.structure.adapter.class_adapter
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
// 创建计算机对象
Computer computer = new Computer();
//读取SD卡中的数据
String s = computer.readSD(new SDCardIml());
System.out.println(s);
System.out.println("--------------------------");
// 使用该计算机读取TF卡中的数据
// 定义适配器类
SDAdapterTF sdAdapterTF = new SDAdapterTF(new TFCardImi());
String s1 = sdAdapterTF.readSD();
System.out.println(s1);
}
}
以上的方法实现了接口复用。聚合
注意: 还有一个适配器模式是接口适配器模式。当不希望实现一个接口中的所有方法，可以抽像一个Adapter，实现所有方法。而我们只需要继承该抽象类即可。
(5).应用场景
- 以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致
- 使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同
(6).JDK源码解析
Reader(字符流)、InputStream(字节流)的适配使用的是InputStreamReader。
InputStreamReader继承自Java.io包中的Reader,对其中的抽象方法给出了实践。
3.桥接模式
(1).概述
现在有一个需求，需要创建不同的图形，并且每个图形都有可能会有不同的颜色。我们可以利用继承的方式来设计类的关系。
我们可以发现有很多的类，假如我们再增加一种颜色或一个形状，就需要创建更多的类。
试想,在一个多种可能会变化的维度的系统中,用继承方式会造成类爆炸，扩展起来不灵活。每次在一个维度上新增一个具体实现都要增加多个子类，为了更加灵活的设计系统，我们此时可以考虑使用桥接模式。
定义：
将抽象与实现分离,使他们可以独立变化。他是用组合关系代理继承关系来实现，从而降低了抽象和实现这两个可唯独的耦合度。
(2).结构
桥接模式包含以下角色:
抽象化角色: 定义抽象类，并包含一个对实现话对象的引用扩展抽象化角色: 是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法。实现化角色: 定义实现化角色的接口，供扩展抽象化角色调用具体实现化角色: 给出实现化角色接口的具体实现。
(3).案列
eg: 视频播放器
需要开发一个跨平台视频播放器，可以在不同操作系统平台(如windows,mac,Linux等)上播放多种格式的视频文件，常见的视频格式包括RMVB、AVI、WMV等。该播放器包含两个维度，适合使用桥接模式。
实现化角色
package com.jsxs.structure.Bride;
/**
* @Author Jsxs
* @Date 2023/4/21 20:43
* @PackageName:com.jsxs.structure
* @ClassName: Bride
* @Description: TODO 实现化角色
* @Version 1.0
*/
public interface VideoFile {
// 解码
void decode(String fileName);
}
具体的实现化角色
package com.jsxs.structure.Bride;
/**
* @Author Jsxs
* @Date 2023/4/21 20:44
* @PackageName:com.jsxs.structure.Bride
* @ClassName: AVI
* @Description: TODO 具体的实现化角色
* @Version 1.0
*/
public class AVI implements VideoFile{
@Override
public void decode(String fileName) {
System.out.println("AVI视频文件:"+fileName);
}
}
package com.jsxs.structure.Bride;
/**
* @Author Jsxs
* @Date 2023/4/21 20:45
* @PackageName:com.jsxs.structure.Bride
* @ClassName: MP4
* @Description: TODO 具体的实现化角色
* @Version 1.0
*/
public class MP4 implements VideoFile{
@Override
public void decode(String fileName) {
System.out.println("MP4:"+fileName);
}
}
抽象化角色
package com.jsxs.structure.Bride;
/**
* @Author Jsxs
* @Date 2023/4/21 20:46
* @PackageName:com.jsxs.structure.Bride
* @ClassName: OS
* @Description: TODO 抽象化角色
* @Version 1.0
*/
public abstract class OS {
// 聚合: 设置的类型为保护类型目的是为了让子类访问。
protected VideoFile videoFile;
// 因为我们设置有参构造函数，所以子类必须要赋值
public OS(VideoFile videoFile) {
this.videoFile = videoFile;
}
public abstract void play(String fileName);
}
扩展抽象化角色
package com.jsxs.structure.Bride;
/**
* @Author Jsxs
* @Date 2023/4/21 21:00
* @PackageName:com.jsxs.structure.Bride
* @ClassName: Windows
* @Description: TODO 扩展抽象化角色
* @Version 1.0
*/
public class Windows extends OS{
public Windows(VideoFile videoFile) {
super(videoFile);
}
@Override
public void play(String fileName) {
videoFile.decode(fileName);
}
}
package com.jsxs.structure.Bride;
/**
* @Author Jsxs
* @Date 2023/4/21 21:03
* @PackageName:com.jsxs.structure.Bride
* @ClassName: Mac
* @Description: TODO 扩展抽象化角色
* @Version 1.0
*/
public class Mac extends OS{
public Mac(VideoFile videoFile) {
super(videoFile);
}
@Override
public void play(String fileName) {
videoFile.decode(fileName);
}
}
package com.jsxs.structure.Bride;
/**
* @Author Jsxs
* @Date 2023/4/21 21:04
* @PackageName:com.jsxs.structure.Bride
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
// 创建Mac系统对象
OS mac = new Mac(new AVI());
// 使用操作系统播放文件
mac.play("战狼4");
}
}
好处:
- 桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要改变原有维度。如:“如果现在有一种视频wmv，我们只需要再定以一个类实现VideoFile接口即可，其他类不需要在变化”
- 实现细节对客户透明
(4).使用场景
- 当一个类存在两个独立的维度的时候,且这两个维度都需要进行扩展时。
- 当一个系统不希望使用继承或因为多层次导致系统类的个数急剧增加。
- 当一个系统需要在构建的抽象化角色和具体化角色之间增加更多的灵活性时，避免在两个层次之间建立静态的继承连接，通过桥接模式可以使他门在抽象层建立一个关联关系。
4.装饰者模式
(1).概述
我们先来看一个快餐店的例子。
快餐店有炒面、炒饭这些快餐。可以额外的附加加鸡蛋、火腿、培根这些配菜，当然加配菜需要额外的加钱，每个配菜的价钱通常不太一样，那么计算总价就会显得比较麻烦。
使用继承的方式去
使用继承的方式存在的问题:
- 扩展性不好
如果要再一种配料(培根)，我们就会发现需要给炒米和炒面条分别定义一个子类。如果要新增一个快餐品类(炒河粉)的话，就需要定义更更多的子类。 - 产生过多的子类
(2).结构
定义: 旨在不该现有对象结构的情况下，动态的给该对象增加一些职责(即增加其他额外的功能)的模式。
装饰模式的角色:
- 抽象构建角色: 定义一个
抽象接口以规范准备接受附加责任的对象。 - 具体构建角色:
实现抽象构建，通过装饰角色为其添加一些职责。 - 抽象装饰角色:
继承或实现抽象构建，并包含具体构建的实列，可以通过其子类扩展具体构建的功能。 - 具体装饰角色:
实现抽象装饰的相关方法，并给具体构建对象添加附加的责任。
(3).案列
我们使用装饰者模式对快餐店案列进行改进，体会装饰者模式的精髓。
类图如下:
抽象构建角色
package com.jsxs.structure.decorator;
/**
* @Author Jsxs
* @Date 2023/4/21 17:52
* @PackageName:com.jsxs.structure.decorator
* @ClassName: FastFood
* @Description: TODO 抽象构建角色
* @Version 1.0
*/
public abstract class FastFood {
private float price;
private String desc;
public FastFood(float price, String desc) {
this.price = price;
this.desc = desc;
}
public FastFood() {
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public abstract float cost();
}
具体构建角色
package com.jsxs.structure.decorator;
/**
* @Author Jsxs
* @Date 2023/4/21 17:57
* @PackageName:com.jsxs.structure.decorator
* @ClassName: rice
* @Description: TODO 炒饭具体构建
* @Version 1.0
*/
public class rice extends FastFood{
public rice(){ //无参创建对象
super(10,"炒饭"); // 设定继承父类的参数
}
@Override
public float cost() {
return this.getPrice();
}
}
package com.jsxs.structure.decorator;
/**
* @Author Jsxs
* @Date 2023/4/21 18:01
* @PackageName:com.jsxs.structure.decorator
* @ClassName: noddles
* @Description: TODO
* @Version 1.0
*/
public class noddles extends FastFood{
public noddles(){
super(20,"面条");
}
@Override
public float cost() {
return this.getPrice();
}
}
抽象装饰者类
package com.jsxs.structure.decorator;
/**
* @Author Jsxs
* @Date 2023/4/21 18:02
* @PackageName:com.jsxs.structure.decorator
* @ClassName: Granish
* @Description: TODO 抽象装饰者类
* @Version 1.0
*/
public abstract class Granish extends FastFood{
// 聚合快餐
private FastFood fastFood;
public Granish(float price, String desc, FastFood fastFood) {
super(price, desc);
this.fastFood = fastFood;
}
public FastFood getFastFood() {
return fastFood;
}
public void setFastFood(FastFood fastFood) {
this.fastFood = fastFood;
}
}
具体装饰角色
package com.jsxs.structure.decorator;
/**
* @Author Jsxs
* @Date 2023/4/21 18:06
* @PackageName:com.jsxs.structure.decorator
* @ClassName: egg
* @Description: TODO
* @Version 1.0
*/
public class egg extends Granish{
public egg(FastFood fastFood){
super(1,"鸡蛋",fastFood); //定义鸡蛋
}
@Override
public float cost() {
return this.getPrice()+this.getFastFood().cost(); //鸡蛋价格+快餐价格
}
@Override
public String getDesc() {
return super.getDesc()+getFastFood().getDesc(); // 鸡蛋描述+米饭描述
}
}
package com.jsxs.structure.decorator;
/**
* @Author Jsxs
* @Date 2023/4/21 18:20
* @PackageName:com.jsxs.structure.decorator
* @ClassName: Bacon
* @Description: TODO
* @Version 1.0
*/
public class Bacon extends Granish{
public Bacon(FastFood fastFood){
super(1,"培根",fastFood); //定义鸡蛋
}
@Override
public float cost() {
return this.getPrice()+this.getFastFood().cost(); //鸡蛋价格+快餐价格
}
@Override
public String getDesc() {
return super.getDesc()+getFastFood().getDesc(); // 鸡蛋描述+米饭描述
}
}
客户端
package com.jsxs.structure.decorator;
/**
* @Author Jsxs
* @Date 2023/4/21 18:22
* @PackageName:com.jsxs.structure.decorator
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
// 点一份炒饭
FastFood rice = new rice();
System.out.println(rice.getDesc()+rice.getPrice());
// 炒饭中加一个鸡蛋
rice = new egg(rice);
System.out.println(rice.getDesc()+" "+rice.cost());
rice=new Bacon(rice);
System.out.println(rice.getDesc()+" "+rice.cost());
}
}
好处:
- 装饰者模式可以带来比较更加灵活性的扩展功能，使用更加方便，可以通过组合不同的装饰者对象来获取不同行为状态的多样化的结构。装饰者模式比继承更具备灵活的扩展性，
完美的遵循开闭原则，继承是静态的附加责任，装饰者则是动态的附加责任。 装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。
(4).使用场景
- 当
不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。 -
- 不能次啊用继承的情况主要有两类:
-(1).第一类是系统中存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。
-(2).第二类是因为类定义不能继承(如 final)
- 不能次啊用继承的情况主要有两类:
- 在不影响其他对象的情况下，以
动态、透明的方式给单个对象添加职责 - 当对象的功能要求可以
动态地添加，也可以再动态的撤销时。
(5).JDK源码解析
IO流中的包装类使用到了装饰模式。BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter。
(6).代理和装饰者的区别
静态代理和装饰者模式的区别:
- 相同点:
-
- 都要实现与目标类相同的业务接口
-
- 在两个类中都要声明目标对象
-
- 都可以在不修改目标类的前提下增强目标方法
- 不同点
-
- 目的不同: “装饰者是为了增强目标对象,静态代理是为了保护和隐藏目标对象”
-
- 获取目标对象构建的地方不同:“装饰者是由
外界传递进来的，可以通过构造方法传递，静态代理时在代理内部创建，以此来隐藏目标对象”
- 获取目标对象构建的地方不同:“装饰者是由
5.外观模式
(1).概述
有些人可能超过股票，但是其实大部分人都不懂，这种没有足够了解证券知识的情况下做股票是很容易亏钱的，刚开始炒股肯定都会想，如果有个懂行的帮帮手，支付宝里面有很多基金，它将投资者分散的资金集中起来，交由专业的经理人进行管理，投资于股票、债卷、外汇等领域，而基金投资的收益归持有者所有，管理机构收取一定比列的托管管理费用。
定义:
又名门面模式，是一种通过多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一的接口，外部应用程序不用关心内部子系统的具体细节，这样会大大降低应用程序的复杂度，提高了程序的可维护性。
迪米特法则的典型应用
(2).结构
外感模式包含以下主要角色:
- 外观角色: 为多个子系统对外提供一个共同的接口。
- 子系统角色: 实现系统的部分功能，客户可以通过外观角色访问它。
(3).案例
eg:智能家电控制
小明的爷爷已经60岁了，一个人在家生活；每次都需要打开灯、打开电视、打开空调；睡觉时关闭灯、关闭电视、关闭空调；操作起来都比较麻烦。所以小明给爷爷买了智能音箱，可以通过语言直接控制这些智能家电的开启和关闭。类图如下:
子类系统角色
package com.jsxs.structure.facade;
/**
* @Author Jsxs
* @Date 2023/4/22 9:58
* @PackageName:com.jsxs.structure.facade
* @ClassName: Light
* @Description: TODO 子系统角色
* @Version 1.0
*/
public class Light {
public void on(){
System.out.println("开灯");
}
public void off(){
System.out.println("关灯");
}
}
package com.jsxs.structure.facade;
/**
* @Author Jsxs
* @Date 2023/4/22 9:59
* @PackageName:com.jsxs.structure.facade
* @ClassName: TV
* @Description: TODO 子角色
* @Version 1.0
*/
public class TV {
public void on(){
System.out.println("开电视");
}
public void off(){
System.out.println("关电视");
}
}
package com.jsxs.structure.facade;
/**
* @Author Jsxs
* @Date 2023/4/22 9:59
* @PackageName:com.jsxs.structure.facade
* @ClassName: airContition
* @Description: TODO 子类角色
* @Version 1.0
*/
public class airContition {
public void on(){
System.out.println("开灯空调");
}
public void off(){
System.out.println("关空调");
}
}
外观角色
package com.jsxs.structure.facade;
/**
* @Author Jsxs
* @Date 2023/4/22 10:02
* @PackageName:com.jsxs.structure.facade
* @ClassName: SmartFacade
* @Description: TODO 外观角色
* @Version 1.0
*/
public class SmartFacade {
// 聚合
private Light light;
private TV tv;
private airContition airContition;
// 实列化
public SmartFacade() {
light=new Light();
tv=new TV();
airContition=new airContition();
}
// 语音控制
public void say(String message){
if (message.contains("打开")){
on();
}else if (message.contains("关闭")){
off();
}else {
System.out.println("我不知道你在说什么...");
}
}
// 一键打开
public void on(){
light.on();
tv.on();
airContition.on();
}
// 一键关闭
public void off(){
light.off();
tv.off();
airContition.off();
}
}
测试
package com.jsxs.structure.facade;
/**
* @Author Jsxs
* @Date 2023/4/22 10:16
* @PackageName:com.jsxs.structure.facade
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
SmartFacade smartFacade = new SmartFacade();
smartFacade.say("关闭");
smartFacade.say("打开");
}
}
好处:
降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调用它的客户类。- 对客户屏蔽了子系统的组件，减少了客户处理的对象数目，
并使得子系统使用起来更加容易。
缺点:
- 不符合
开闭原则，修改很麻烦。
(4).使用场景
- 对分层结构系统构建时，使用外观模式定义子系统中每层的入口可以简化子系统之间的依赖关系。
当一个复杂系统的子系统很多时，外观模式可以位系统设计一个简单的接口供外界访问。当客户端与多个子系统之间存在很大的联系时，引入外观模式可以将他们分离，从而提高自行的独立性和可移植性。
(5).源码分析
使用tomcat作为web容器时，接受浏览器发送过来的而请求，tomcat会将请求信息封装成ServletRequest对象，但是大家想想ServletRequest是一个接口，它还有一个子接口HttpServletRequest,而我们都知道request对象肯定是一个ServletRequest对象的子实现类对象，到底是哪个类的对象呢,可以通过暑促和request对象，我们就会发现是一个名为RequestFacade的类的对象。
public class Personnel_visit_informationServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
为什么在这里使用外观模式?
定义RequestFacade类，分别实现ServletRequest,同时定义私有成员变量Request,并且方法的实现调用Request的实现。然后将RequestFacade上传位ServletRequest传给Servlet的service方法，这样即使在servlet中被下转为RequestFacade,也不能访问保护成员变量对象中的方法。即用了Request,又能放置其中方法不合理的访问。
6.享元模式
(1).概述
定义:
运用共享技术来有效的支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似对象的开销，从而提高系统资源的利用率(共享单车)。
(2).结构
享元模式中存在以下两种状态:
- 内部状态: 既不会随着环境的改变而改变的可共享部分，
- 外部状态: 指随环境改变而改变的不可以共享的部分。享元模式实现就是区分应用中的这两种状态，并将外部状态外部化。
享元模式的主要角色:
- 抽象享元角色: 通常是一个
接口或者抽象类，在抽象享元类中声明了具体享元对象的内部数据(内部状态)，同时也可以通过这些方法来设置外部数据(外部状态) - 具体享元角色:
它实现了抽象享元类，称为享元对象;在具体享元类中为内部状态提供了存储空间。通常我们可以结合单列模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。 - 非享元对象角色: 并不是所有的抽象享元类的子类都需要被共享,
不能被共享的子类可以设计为非共享具体享元类;当需要一个非共享享元类的对象时可以直接通过实列化创建。 - 享元工厂角色:
负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检查系统中是否存在符合要求的享元对象，如果存在则提供给客户;如果不存在的话，则创建一个新的享元对象。
(3).享元模式案列
eg： 俄罗斯方块
下面的图片就是总所周知的俄罗斯方块，如果在俄罗斯方块这个游戏中，每个不同的方块就是一个实列对象，这些对象就要占用很多的内存空间，下面利用享元模式进行实现。
类图:
代码如下:
俄罗斯方块有不同的形状，我们可以对这些形状向上抽象出AbstractBox,用来定义共性的属性和行为。
抽象享元角色
package com.jsxs.structure.flyweight;
/**
* @Author Jsxs
* @Date 2023/4/22 14:47
* @PackageName:com.jsxs.structure.flyweight
* @ClassName: AbstractBox
* @Description: TODO 抽象享元角色
* @Version 1.0
*/
public abstract class AbstractBox {
// 获取图形的方法
public abstract String getShape();
// 显示图形及颜色
public void display(String color){
System.out.println("方块形状是: "+getShape()+" 颜色: "+color);
}
}
具体享元角色
package com.jsxs.structure.flyweight;
/**
* @Author Jsxs
* @Date 2023/4/22 14:49
* @PackageName:com.jsxs.structure.flyweight
* @ClassName: IBox
* @Description: TODO 具体享元角色
* @Version 1.0
*/
public class IBox extends AbstractBox{
@Override
public String getShape() {
return "I";
}
}
package com.jsxs.structure.flyweight;
/**
* @Author Jsxs
* @Date 2023/4/22 14:50
* @PackageName:com.jsxs.structure.flyweight
* @ClassName: RBox
* @Description: TODO
* @Version 1.0
*/
public class RBox extends AbstractBox{
@Override
public String getShape() {
return "R";
}
}
package com.jsxs.structure.flyweight;
/**
* @Author Jsxs
* @Date 2023/4/22 14:50
* @PackageName:com.jsxs.structure.flyweight
* @ClassName: OBox
* @Description: TODO
* @Version 1.0
*/
public class OBox extends AbstractBox{
@Override
public String getShape() {
return "O";
}
}
享元工厂
package com.jsxs.structure.flyweight;
import java.util.HashMap;
/**
* @Author Jsxs
* @Date 2023/4/22 14:51
* @PackageName:com.jsxs.structure.flyweight
* @ClassName: BoxFactory
* @Description: TODO 享元工厂模式
* @Version 1.0
*/
public class BoxFactory {
private HashMap<String,AbstractBox> map;
// 构造函数初始化且设置单列模式
private BoxFactory(){
map=new HashMap<String,AbstractBox>();
// 添加图像
map.put("I",new IBox());
map.put("R",new RBox());
map.put("O",new OBox());
}
// 饿汉模式创建
private static BoxFactory factory=new BoxFactory();
// 提供一个方法获取该工厂类对象
public static BoxFactory getInstance(){
return factory;
}
// 根据名称获取图像对象
public AbstractBox getShape(String name){
return map.get(name);
}
}
测试
package com.jsxs.structure.flyweight;
/**
* @Author Jsxs
* @Date 2023/4/22 15:00
* @PackageName:com.jsxs.structure.flyweight
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
// 获取工厂对象
BoxFactory factory = BoxFactory.getInstance();
// 获取指定图形
AbstractBox i = factory.getShape("I");
// 打印指定颜色图形
i.display("红色");
// 获取工厂对象
BoxFactory factory1 = BoxFactory.getInstance();
// 获取指定图形
AbstractBox i1 = factory1.getShape("I");
// 打印指定颜色图形
i1.display("蓝色");
System.out.println(i==i1);
}
}
(6).优缺点和使用场景
优点:
极大的减少内存中像是或相同对象数量，节约系统资源，提供系统性能。享元模式中的外部状态相对独立，且不影响内部状态。
缺点:
为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，是程序逻辑复杂。
使用场景:
- 一个系统有大量相同或者相似的对象，造成内存的大量耗费
- 对象的大部分状态可以外部化，可以将这些外部状态传入对象中。
- 在使用享元模式时需要维护一个存储享元对象的享元池(HashMap)，而这些需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。
7.组合模式
(1).概述
上面是一个文件系统，也就是目录结构。对于这种的结构我们称之为数型构。在树结构中可以通过调用某一个方法来遍历整个树，当我们找到某一个叶子节点后，就可以对叶子节点进行相关操作。可以将这课树比喻成一个大的容器，容器里面包含很多的成员对象，这些成员对象既可以是容器对象也可以是叶子对象。但是由于容器和叶子对象在功能上面的区别，使得我们在使用的过程中必须要区分容器对象和叶子对象，但是这样就会给客户带来不必要的麻烦，作为客户而已，它始终希望能够一致的对待容器对象(文件夹)和叶子对象(文件)。
定义:
又名部分整体模式，是用于把一组相似的对象当作一个的单一的对象，组合模式依据属性结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，他创建了对象组的树形结构。
(2).结构
组合模式主要包含三种角色:
- 抽象根节点: 定义系统各层次对象的公有方法和属性，可以预先定义一些默认行为和属性
- 树枝结点(文件夹): 定义树枝节点的行为，存储子节点，组合树子结点形成一个树形结构
- 叶子节点(文件): 叶子节点对象，其下再无分支，是系统层次遍历的最小单位。
(3).案列实现
eg: 软件菜单
我们在访问别的一些管理系统时，经常可以看到类似的菜单，一个菜单可以包含菜单项(菜单项是指不在包含其他内容的菜单条目)，也可以包含带有其他菜单项的菜单，因此使用组合模式描述菜单就很恰当，当我们的需求是针对一个菜单，打印出其包含的所有菜单以及菜单项的名称。
不管是菜单还是菜单项，都应该继承自统一的接口，这里姑且将这个统一的接口称为菜单组件。
抽象根节点
package com.jsxs.structure.combination;
/**
* @Author Jsxs
* @Date 2023/4/22 12:56
* @PackageName:com.jsxs.structure.combination
* @ClassName: MenuComponent
* @Description: TODO 抽象根节点
* @Version 1.0
*/
public abstract class MenuComponent {
// 菜单组件的名称
protected String name;
// 菜单组件的层级
protected int level;
// 添加子菜单
public void add(MenuComponent menuComponent){
throw new UnsupportedOperationException();
}
// 移除子菜单
public void remove(MenuComponent menuComponent){
throw new UnsupportedOperationException();
}
// 获取指定的子菜单
public MenuComponent getChild(int index){
throw new UnsupportedOperationException();
}
// 获取菜单或者菜单项的名称
public String getName(){
return name;
}
// 打印菜单名称的方法
public abstract void print();
}
树枝节点
package com.jsxs.structure.combination;
import java.util.ArrayList;
import java.util.List;
/**
* @Author Jsxs
* @Date 2023/4/22 13:17
* @PackageName:com.jsxs.structure.combination
* @ClassName: Menu
* @Description: TODO 菜单栏、属于树子结点
* @Version 1.0
*/
public class Menu extends MenuComponent{
// 菜单可以有多个子菜单或者子菜单项
private List<MenuComponent> menuComponentList=new ArrayList<>();
// 构造方法
public Menu(String name,int leve){
this.name=name;
this.level=leve;
}
@Override
public void add(MenuComponent menuComponent) {
menuComponentList.add(menuComponent);
}
@Override
public void remove(MenuComponent menuComponent) {
menuComponentList.remove(menuComponent);
}
@Override
public MenuComponent getChild(int index) {
return menuComponentList.get(index);
}
@Override
public void print() {
// 打印菜单名称
for (int i = 0; i < level; i++) {
System.out.print("-");
}
System.out.println(name);
// 打印子菜单名称
for (MenuComponent menuComponent : menuComponentList) {
menuComponent.print();
}
}
}
叶子节点
package com.jsxs.structure.combination;
/**
* @Author Jsxs
* @Date 2023/4/22 13:24
* @PackageName:com.jsxs.structure.combination
* @ClassName: MenuUtem 菜单项： 叶子节点
* @Description: TODO
* @Version 1.0
*/
public class MenuItem extends MenuComponent{
public MenuItem(String name,int level){
this.name=name;
this.level=level;
}
@Override
public void print() {
// 打印菜单项的名称
for (int i = 0; i < level; i++) {
System.out.print("-");
}
System.out.println(name);
}
}
测试:
package com.jsxs.structure.combination;
/**
* @Author Jsxs
* @Date 2023/4/22 13:26
* @PackageName:com.jsxs.structure.combination
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
// 创建菜单树
MenuComponent menu1 = new Menu("菜单管理", 2);
menu1.add(new MenuItem("页面访问",3));
menu1.add(new MenuItem("展开菜单",3));
menu1.add(new MenuItem("编辑菜单",3));
menu1.add(new MenuItem("删除菜单",3));
menu1.add(new MenuItem("新增菜单",3));
MenuComponent menu2 = new Menu("权限管理", 2);
menu2.add(new MenuItem("提交保存",3));
menu2.add(new MenuItem("展开菜单",3));
MenuComponent menu3 = new Menu("角色管理", 2);
menu3.add(new MenuItem("页面访问",3));
menu3.add(new MenuItem("新增角色",3));
// 创建一级菜单
MenuComponent RootMenu = new Menu("windows系统",1);
// 将二级系统添加到一级菜单中
RootMenu.add(menu1);
RootMenu.add(menu2);
RootMenu.add(menu3);
// 打印菜单名称(如果有子菜单一起打印)
RootMenu.print();
}
}
(4).组合模式的分类
在使用组合模式时,根据抽象构建类的定义形式，我们可以将组合模式分为透明组合和安全组合模式两种形式。
透明组合模式:
透明组和模式中,抽象根节点角色声明了所有用于管理成员对象的方法，比如在实列中:MenuComponent声明了add、remove、getChild方法，这样做的好处是确保所有的构建类都有相同的接口。透明组合模式也是组合模式的标准形式。
透明组合模式的缺点是不够安全，因为叶子对象和容器对象不可能有下一个层次的对象，既不可能包含成员对象，因此为其提高add()、remove()、等方法时没有意义的,这在编译阶段不会出错，但在运行阶段，如果调用这些方法可能会出错。安全组合模式
在安全组合模式中,在抽象构建角色中没有声明任何用于管理成员对象的方法，而是树枝节点Menu类中声明并实现这些方法。安全组合模式的缺点是不够透明，因为叶子构建和容器构建具有不同的放啊，且容器构件中那些用于管理成员对象饿方法没有在抽象构建类中定义，因此客户端不能完全针对抽象编程，必须有区别地对待叶子构建和容器构建。
(5).使用场景
优点:
- 组合模式可以清除地定义分层次地复杂对象，表示对象地全部或部分层次，
它让客户端忽略了层次地差异，方便对整个层次结构进行控制 - 客户端可以一致地使用一个组合结构或其中单个对象,不必关于处理地是单个对象还是整个组合结构,
简化客户端代码。 - 在组合模式中增加新地树枝节点和叶子节点都很方便，无需对现有类库进行任何修改，
符合"开闭原则"。 - 组合模式为
树形结构地面向对象实现提供了一种灵活地解决方案，通过叶子节点和树枝节点地递归组合，可以形成复杂地树形结构，但对属性结构地控制却非常简单。
组合模式正是因为树形结构而生，所以组合模式地使用场景就是出现属性结构的地方。比如: 文件目录显示，多级目录呈现等树形结构数据的操作。
(7).JDK源码分析
Integer类使用了享元模式。
package com.jsxs.structure.flyweight;
/**
* @Author Jsxs
* @Date 2023/4/22 15:00
* @PackageName:com.jsxs.structure.flyweight
* @ClassName: Client
* @Description: TODO
* @Version 1.0
*/
public class Client {
public static void main(String[] args) {
Integer i1=127;
Integer i2=127;
System.out.println(i1==i2);
Integer i3=128;
Integer i4=128;
System.out.println(i3==i4);
}
}
结论: -128~127 是一个对象。否则创建一个新的对象。
