设计模式_未完成

设计模式

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

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、生产者消费者

概述

代码实现

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