设计模式

半成品 1、部分设计模式未整理 2、概述等描述不完整

文章目录

设计模式1、策略模式概述代码实现 2、装饰模式概述代码实现 3、工厂模式综述1、简单工厂2、工厂方法3、抽象工厂方法4、终极工厂模式 4、代理模式概述代码实现 5、原型模式概述代码实现 6、模板方法模式概述代码实现 7、外观模式概述代码实现 8、建造者模式概述代码实现 9、观察者模式概述代码实现 10、状态模式概述代码实现 11、适配器模式概述代码实现 12、备忘录模式概述代码实现 13、组合模式概述代码实现 14、迭代器模式概述代码实现 15、桥接模式概述代码实现 16、命令模式概述代码实现 17、责任链模式概述代码实现 18、中介者模式概述代码实现 19、享元模式概述代码实现 20、解释器模式概述代码实现 21、访问者模式概述代码实现 22、单例模式综述1、懒汉模式2、饿汉模式3、双重检索4、静态内部类 23、生产者消费者概述代码实现

1、策略模式

概述

根据输入对象的不同调用同一个方法实现不同的功能

类中拥有战略接口的引用，根据接收到的对象不同，调用这些对象的同一个方法即可实现策略模式

代码实现

/** * 接口A定义了要实现的方法 */ public interface interfaceA { public void function(); } /** * 实现接口A,实现具体方法 */ public class ClassA implements interfaceA { @Override public void function() { System.out.println("ClassA"); } } /** * 功能调用类 */ public class Lei { public void FangFa(interfaceA interA) { interA.function(); } }

---

2、装饰模式

概述

利用多态接收子类，再重写对应方法来拓展功能

接口模板定下基本功能，被装饰类A与被装饰类B分别实现自己的逻辑，

装饰类模板中拥有接口模板的引用，并在功能方法中调用接口模板的功能方法。

拓展类A、拓展类B、拓展类C中在模板类的基础上拓展功能方法。

代码实现

/** * 接口模板，定义了要实现的方法 */ public interface JieKouMuBan { public void GongNeng(); } /** * 被装饰类，具体的功能实现类 */ public class BeiZhuangShiLeiA implements JieKouMuBan { @Override public void GongNeng() { System.out.println("被装饰类A"); } } /** * 装饰类模板 * 1、继承接口模板 * 2、使用构造方法接收被装饰类 * 3、在功能方法中调用接口模板功能方法 */ public class ZhuangShiLeiMuBan implements JieKouMuBan { JieKouMuBan jieKouMuBan; public ZhuangShiLeiMuBan(JieKouMuBan jieKouMuBan) { this.jieKouMuBan = jieKouMuBan; } @Override public void GongNeng() { if (jieKouMuBan != null) jieKouMuBan.GongNeng(); } } /** * 拓展类 * 1、调用装饰类方法 * 2、在此基础上拓展方法功能 */ public class TuoZhanLeiA extends ZhuangShiLeiMuBan { public TuoZhanLeiA(JieKouMuBan jieKouMuBan) { super(jieKouMuBan); System.out.println("拓展类A"); } }

---

3、工厂模式

综述

工厂模式目的是减少类加载的数量，适合处理并行的功能，如计算器。

1、简单工厂

概述： 通过传入工厂参数的不同返回不同的对象

并行类中实现了并行的功能

工厂内部使用switch根据输入的不同返回不同的对象

每添加一个类都要修改switch所在类

注意：增加并行功能实不仅要增加其实现类，还要修改工厂中的creatClass方法

代码实现

/** * 并行方法模板，定义了并行的方法 */ public interface BingXingFangFaMuBan { public void GongNeng(); } /** * 并行功能A */ public class BingXingLeiA implements BingXingFangFaMuBan { @Override public void GongNeng() { System.out.println("GongNengA"); } } /** * 并行功能B */ public class BingXingLeiB implements BingXingFangFaMuBan { @Override public void GongNeng() { System.out.println("GongNengB"); } } /** * 使用测试 */ public class MainTest { public static void main(String[] args) { // 创建工厂 GongChang gongChang = new GongChang(); // 根据参数获取并行类 BingXingFangFaMuBan bingXingFangFaMuBan = gongChang.creatClass("A"); // 调用并行类方法 bingXingFangFaMuBan.GongNeng(); } }

2、工厂方法

概述：在客户端中自主选择，满足开放-封闭原则，不需要修改switch所在类（就没有）。但是每次都会新建一个类

代码实现

/** * 并行方法模板，定义了并行的方法 */ public interface BingXingFangFaMuBan { public void GongNeng(); } /** * 并行功能A */ public class BingXingLeiA implements BingXingFangFaMuBan { @Override public void GongNeng() { System.out.println("GongNengA"); } } /** * 并行功能B */ public class BingXingLeiB implements BingXingFangFaMuBan { @Override public void GongNeng() { System.out.println("GongNengB"); } } /** * 工厂，定义创建方法接口 */ public interface GongChang { public BingXingFangFaMuBan creatClass(); } /** * 工厂类A，创建并行类A */ public class GongChangA implements GongChang { @Override public BingXingFangFaMuBan creatClass() { return new BingXingLeiA(); } } /** * 工厂类B，创建并行类B */ public class GongChangB implements GongChang { @Override public BingXingFangFaMuBan creatClass() { return new BingXingLeiB(); } } /** * 使用测试 */ public class MainTest { public static void main(String[] args) { // 首先确定要创建的并行方法 GongChang gongChang = new GongChangA(); // 根据工厂动态类型确定创建的并行类 BingXingFangFaMuBan bingXingFangFaMuBan = gongChang.creatClass(); // 调用并行方法 bingXingFangFaMuBan.GongNeng(); } }

3、抽象工厂方法

概述：多个产品

4、终极工厂模式

---

4、代理模式

概述

实现上类似于装饰模式，在代理类中持有实体类的引用，

区别在于装饰模式注重拓展，代理模式注重控制

其可以决定实体类的创建、删除等操作

代码实现

/** * 实体模板，提供方法接口 */ public interface ShiTiMuBan { public void GongNeng(); } /** * 实体类，具体的功能实现类 */ public class ShiTiLei implements ShiTiMuBan { @Override public void GongNeng() { System.out.println("实体类功能A"); } } /** * 代理类,代为处理实体类 */ public class DaiLiLei implements ShiTiMuBan { ShiTiMuBan shiTiMuBan = null;// 实体类引用 @Override public void GongNeng() { System.out.println("代理类"); if (shiTiMuBan == null) shiTiMuBan = new ShiTiLei();// 创建实体类对象 shiTiMuBan.GongNeng();// 调用实体类逻辑 } } public class Client { public static void main(String[] args) { ShiTiMuBan shiTiMuBan = new DaiLiLei(); shiTiMuBan.GongNeng(); } }

---

5、原型模式

概述

使用深克隆将对象进行辅助并提供修改方法，达到批量创建对象的目的

代码实现

// 原型接口，定义clone方法 // 原型实例，定义具体实现

---

6、模板方法模式

概述

将不变行为搬移到父类，将变化的逻辑放到子类。

代码实现

/** * 不变逻辑类,定下逻辑骨架，将不会发生变化的逻辑写在这里 */ public class BuBianLuoJI { public void LuoJi1() {}// 逻辑1 public void LuoJi2() {}// 逻辑2 public void LuoJi3() {}// 逻辑3 // 逻辑功能骨架 public void GongNeng() { LuoJi1(); System.out.println("不变逻辑1"); LuoJi2(); System.out.println("不变逻辑2"); LuoJi3(); } } /** * 易变逻辑类，将会发生变化的方法重写，完成特定逻辑 */ public class YiBianLuoJi extends BuBianLuoJI { @Override public void LuoJi1() { System.out.println("易变逻辑1"); } @Override public void LuoJi2() { System.out.println("易变逻辑2"); } @Override public void LuoJi3() { System.out.println("易变逻辑3"); } }

7、外观模式

概述

解耦，使用一个外观类（中间类）组合、完善我们需要的方法，使得使用者不必在客户端组合完善

代码实现

/** * 客户端,通过外观类调用系统资源 */ public class Client { public static void main(String[] args) { WaiGuanLei waiGuanLei = new WaiGuanLei(); waiGuanLei.SystemResourcesA(); waiGuanLei.SystemResourcesB(); waiGuanLei.SystemResourcesAB(); } } /** * 外观类,实现系统资源的整合 */ public class WaiGuanLei { private XiTongLeiA xiTongLeiA = null; private XiTongLeiB xiTongLeiB = null; // 获取系统资源 public WaiGuanLei() { this.xiTongLeiA = new XiTongLeiA(); this.xiTongLeiB = new XiTongLeiB(); } // 系统资源A public void SystemResourcesA() { xiTongLeiA.SystemResourcesA(); } // 系统资源B public void SystemResourcesB() { xiTongLeiB.SystemResourcesB(); } // 系统资源整合 public void SystemResourcesAB() { xiTongLeiA.SystemResourcesA(); xiTongLeiB.SystemResourcesB(); } } /** * 系统类A,提供系统资源 */ public class XiTongLeiA { public void SystemResourcesA() { System.out.println("系统资源A"); } } /** * 系统类B,提供系统资源 */ public class XiTongLeiB { public void SystemResourcesB() { System.out.println("系统资源B"); } }

---

8、建造者模式

概述

建造类模板抽象处产品的共性，建造类根据产品实现产品对象的创建，指挥者类根据传入的建造者类进行产品对象的创建

对于有大量共性的产品，且产品各有个的创建逻辑可以优先使用建造者模式

与模板方法模式不同，建造者自定义你创建逻辑，没有实现不变的逻辑

代码实现

/** * 建造者接口,提取产品共性提供建造者类模板 */ public interface JianZaoZheLei { public void DuiXiangBuJianA();// 对象创建部件A public void DuiXiangBuJianB();// 对象创建不见B } /** * 指挥者类,通过传入对象的不同创建不同的对象 */ public class ZhiHuiZheLei { JianZaoZheLei jianZaoZheLei = null; public ZhiHuiZheLei(JianZaoZheLei jianZaoZheLei) { this.jianZaoZheLei = jianZaoZheLei; } /** * 组件拼接，实现对象创建 */ public void getItem() { jianZaoZheLei.DuiXiangBuJianA(); jianZaoZheLei.DuiXiangBuJianB(); } /** * 返回建造者对象 * @return JianZaoZheLei */ public JianZaoZheLei getJianZaoZheLei() { return jianZaoZheLei; } } public class JianZaoZheLeiA implements JianZaoZheLei { @Override public void DuiXiangBuJianA() { System.out.println("建造者类A部件A"); } @Override public void DuiXiangBuJianB() { System.out.println("建造者类A部件B"); } } public class JianZaoZheLeiB implements JianZaoZheLei { @Override public void DuiXiangBuJianA() { System.out.println("建造者类B部件A"); } @Override public void DuiXiangBuJianB() { System.out.println("建造者类B部件B"); } } /** * 指挥者类,通过传入对象的不同创建不同的对象 */ public class ZhiHuiZheLei { JianZaoZheLei jianZaoZheLei = null; public ZhiHuiZheLei(JianZaoZheLei jianZaoZheLei) { this.jianZaoZheLei = jianZaoZheLei; } /** * 组件拼接，实现对象创建 */ public void getItem() { jianZaoZheLei.DuiXiangBuJianA(); jianZaoZheLei.DuiXiangBuJianB(); } /** * 返回建造者对象 * @return JianZaoZheLei */ public JianZaoZheLei getJianZaoZheLei() { return jianZaoZheLei; } } public class MainTest { public static void main(String[] args) { JianZaoZheLei jianZaoZheLeiA = new JianZaoZheLeiA();// 创建建造者类A JianZaoZheLei jianZaoZheLeiB = new JianZaoZheLeiB();// 创建建造者类B ZhiHuiZheLei zhiHuiZheLei = new ZhiHuiZheLei(jianZaoZheLeiA);// 创建指挥者 zhiHuiZheLei.getItem();// 创建建造者类A JianZaoZheLei out1 = zhiHuiZheLei.getJianZaoZheLei();// 获取创建结果 zhiHuiZheLei = new ZhiHuiZheLei(jianZaoZheLeiB);// 创建指挥者 zhiHuiZheLei.getItem();// 创建建造者类B JianZaoZheLei out2 = zhiHuiZheLei.getJianZaoZheLei();// 获取创建结果 } }

---

9、观察者模式

概述

主题+观察者，主题状态发生变化，通知观察者使其进行操作。

1、主题抽象类中一般来说维护了观察者容器、观察者添加方法、观察者删除方法、观察者事件触发方法

2、主题实例类可以根据需求对抽象方法进行修改。(也可以维护一个状态属性)

3、观察者抽象类一般定义好事件触发方法即可

4、观察者实例类实现事件触发方法。(当然也可以维护一个主题实力的引用记录其状态)

代码实现

/** * 观察者抽象类,提供事件触发方法，根据需求实现不同功能 */ abstract class GuanChaZheChouXiangLei { abstract void update();// 观察者抽象触发方法 } /** * 观察者实例类,完善事件触发方法 */ public class GuanChaZheShiLiLei extends GuanChaZheChouXiangLei { /** * 实体观察者，当主题发生变化时触发的方法 */ @Override void update() { System.out.println("我是观察者:" + this); } } /** * 主题抽象类 * 1、维护观察者容器。 * 2、提供通知方法 */ abstract class ZhuTiChouXiangLei { private List<GuanChaZheChouXiangLei> list = new LinkedList<>();// 观察者集合 /** * 添入链表 * @param guanChaZheChouXiangLei 观察者 */ public void add(GuanChaZheChouXiangLei guanChaZheChouXiangLei) { list.add(guanChaZheChouXiangLei); } /** * 移除链表 * @param guanChaZheChouXiangLei 观察者 */ public void remove(GuanChaZheChouXiangLei guanChaZheChouXiangLei) { list.remove(guanChaZheChouXiangLei); } /** * 通知方法，当主题发生变化时触发所有观察者update()方法 */ public void Notify() { for (GuanChaZheChouXiangLei guanChaZheChouXiangLei : list) { guanChaZheChouXiangLei.update(); } } } /** * 主题实例类,提供状态 */ public class ZhuTiShiLiLei extends ZhuTiChouXiangLei { String state = null;// 当前状态 // 可以根据需求修改抽象方法 } public class MainTest { public static void main(String[] args) { ZhuTiChouXiangLei zhuTiChouXiangLei = new ZhuTiShiLiLei();// 创建主题 GuanChaZheChouXiangLei guanChaZheChouXiangLei1 = new GuanChaZheShiLiLei();//观察者1 GuanChaZheChouXiangLei guanChaZheChouXiangLei2 = new GuanChaZheShiLiLei();//观察者2 zhuTiChouXiangLei.add(guanChaZheChouXiangLei1);// 观察者入队列 zhuTiChouXiangLei.add(guanChaZheChouXiangLei2);// 观察者入队列 zhuTiChouXiangLei.Notify();// 通知观察者状态改变 } }

---

10、状态模式

概述

类似于策略模式，都是利用多态。根据传入对象的不同，调用同一个方法，实现不同的功能。策略模式注重对象的选择，状态模式注重当前的状态。

状态模式中一半来说都会在状态切换类中维护一个状态，根据这个状态去判断我应该去操作哪一个对象。

代码实现

/** * 状态类模板，提供统一的方法 */ public interface ZhuangTaiLeiMuBan { public void GongNeng(); } /** * 实例状态A */ public class ShiLiZhuangTaiLeiA implements ZhuangTaiLeiMuBan { @Override public void GongNeng() { System.out.println("实例状态类A"); } } /** * 实例状态B */ public class ShiLiZhuangTaiLeiB implements ZhuangTaiLeiMuBan { @Override public void GongNeng() { System.out.println("实例状态类B"); } } /** * 状态切换类 * 1、维护状态 * 2、提供功能方法 */ public class ZhuangTaiQieHuanLei { // 初始状态， // 可以直接new一个初始状态出来 // 最好用private修饰，封装起来 public ZhuangTaiLeiMuBan zhuangTaiLeiMuBan = null; public void GongNeng() { if (zhuangTaiLeiMuBan == null) System.out.println("请设置状态"); else zhuangTaiLeiMuBan.GongNeng(); } } public class MainTest { public static void main(String[] args) { // 实例化状态切换类 ZhuangTaiQieHuanLei zhuangTaiQieHuanLei = new ZhuangTaiQieHuanLei(); // 设置状态为A zhuangTaiQieHuanLei.zhuangTaiLeiMuBan = new ShiLiZhuangTaiLeiA(); zhuangTaiQieHuanLei.GongNeng(); // 设置状态为B zhuangTaiQieHuanLei.zhuangTaiLeiMuBan = new ShiLiZhuangTaiLeiB(); zhuangTaiQieHuanLei.GongNeng(); } }

---

11、适配器模式

概述

处理一份数据，同一个接口（方法名相同）原先实现了功能A，现在想实现功能B但是代码量挺大，但是我有现成的实现那么就可以考虑使用适配器模式

1、客户端，对接口方法的调用

2、原接口(类也行)，这里定义了具体要实现的功能

3、适配类，将原实现替换为需求类的实现

4、需求类，我们需要的功能实现

代码实现

/** * 原类，原逻辑实现 */ public class YuanLei { public void GongNeng() { System.out.println("原功能"); } } /** * 需求类，我们功能真正的逻辑所在 */ public class XuQiuLei { public void GongNeng(){ System.out.println("真正的功能"); } } /** * 适配器类 */ public class ShiPeiQiLei extends YuanLei{ XuQiuLei xuQiuLei = new XuQiuLei(); @Override public void GongNeng(){ xuQiuLei.GongNeng(); } } /** * 代码调式 */ public class Client { public static void main(String[] args) { YuanLei yuanLei = new YuanLei(); yuanLei.GongNeng(); ShiPeiQiLei shiPeiQiLei = new ShiPeiQiLei(); shiPeiQiLei.GongNeng(); } }

---

12、备忘录模式

概述

使用一个对象缓存局部属性，同时提供一个控制类来维护缓存对象

代码实现

/** * 备忘录类，缓存部分数据 */ public class BeiWangLuLei { // 最好封装起来，这里如果封装的话代码长度过长故不再封装 public String propertyA; public String propertyB; public String propertyC; public BeiWangLuLei(String propertyA, String propertyB, String propertyC) { this.propertyA = propertyA; this.propertyB = propertyB; this.propertyC = propertyC; } } /** * 发起者类 * 1、维护所有属性 * 2、提供备忘录类实例生成方法 */ public class FaQiZheLei { public String propertyA; public String propertyB; public String propertyC; public String propertyD; /** * 备忘录生成 * * @return 备忘录类实例 */ public BeiWangLuLei CreatBeiWangLuLei() { return new BeiWangLuLei(this.propertyA, this.propertyB, this.propertyC); } /** * 备忘录还原 */ public void HuanYuan(BeiWangLuLei beiWangLuLei) { this.propertyA = beiWangLuLei.propertyA; this.propertyB = beiWangLuLei.propertyB; this.propertyC = beiWangLuLei.propertyC; } @Override public String toString() { return "FaQiZheLei{" + "propertyA='" + propertyA + '\'' + ", propertyB='" + propertyB + '\'' + ", propertyC='" + propertyC + '\'' + ", propertyD='" + propertyD + '\'' + '}'; } } /** * 备忘录控制类，维护备忘录类实例 */ public class BeiWangLuKongZhiLei { private BeiWangLuLei beiWangLuLei; // 备忘录类对象 /** * 存储备忘录类对象 */ public BeiWangLuKongZhiLei(BeiWangLuLei beiWangLuLei) { this.beiWangLuLei = beiWangLuLei; } /** * 获取备忘录类对象 */ public BeiWangLuLei getBeiWangLuLei() { return this.beiWangLuLei; } public void Show(){ System.out.println(this.beiWangLuLei); } } public class MainTest { public static void main(String[] args) { // 实例化对象并赋值 FaQiZheLei faQiZheLei = new FaQiZheLei(); faQiZheLei.propertyA = "A"; faQiZheLei.propertyB = "B"; faQiZheLei.propertyC = "C"; faQiZheLei.propertyD = "D"; BeiWangLuLei beiWangLuLei = faQiZheLei.CreatBeiWangLuLei();// 获取备忘录 // 维护备忘录 BeiWangLuKongZhiLei beiWangLuKongZhiLei = new BeiWangLuKongZhiLei(beiWangLuLei); // 状态改变 faQiZheLei.propertyA = "E"; faQiZheLei.propertyB = "E"; faQiZheLei.propertyC = "E"; faQiZheLei.propertyD = "E"; System.out.println(faQiZheLei);// 显示当前状态 faQiZheLei.HuanYuan(beiWangLuKongZhiLei.getBeiWangLuLei());// 状态还原 System.out.println(faQiZheLei);// 显示当前状态 } }

---

13、组合模式

概述

代码实现

---

14、迭代器模式

概述

代码实现

---

15、桥接模式

概述

代码实现

---

16、命令模式

概述

代码实现

---

17、责任链模式

概述

代码实现

---

18、中介者模式

概述

代码实现

---

19、享元模式

概述

代码实现

---

20、解释器模式

概述

代码实现

---

21、访问者模式

概述

代码实现

---

22、单例模式

综述

私有化对象使得此对象只被实例化一次，并公开get方法使得此对象可被获得。

1、懒汉模式

概述：只有我们需要获取该对象时，我们才会实例化此对象。

代码实现：

class LanHan { private static LanHan lanhan; private LanHan() { } public static LanHan getLanHan() { return lanhan == null ? lanhan = new LanHan() : lanhan; } }

2、饿汉模式

概述：无论我们是否获取此对象，我们立即实例化对象。

代码实现：

class EHan { private static EHan ehan = new EHan(); private EHan() { } public static EHan getEHan() { return ehan; } }

3、双重检索

概述： 两层嵌套中间穿插synchronized修饰的代码块。 当多个进程访问此方法时，仅有一个进程可以创建该对象。 双重检索相比synchronized修饰方法可以提高一定的效率。 （函数体过长会使得此对象长时间无法被获取）

代码实现：

class DoubleJianSuo { private static volatile DoubleJianSuo djs; private DoubleJianSuo() {} public static DoubleJianSuo getDoubleJianSuo() { if (djs == null) { synchronized (DoubleJianSuo.class) { if (djs == null) { djs = new DoubleJianSuo(); } } } return djs; } }

4、静态内部类

概述：静态内部类只在被调用时加载且仅加载一次。

代码实现：

class JingTaiNeiBuLei { private JingTaiNeiBuLei() {} public static JingTaiNeiBuLei getJingTaiNeiBuLei() { return jj.getJingTaiNeiBuLei1(); } static class jj { private static JingTaiNeiBuLei jtnbl = new JingTaiNeiBuLei();; public static JingTaiNeiBuLei getJingTaiNeiBuLei1() { return jtnbl; } } }

---

23、生产者消费者

概述

代码实现

生产者->缓存区->消费者 生产者：生产数据 缓存区：存储数据 消费者：使用数据