1.2.1 创建型设计模式

最新推荐文章于 2024-10-08 18:09:56 发布
最新推荐文章于 2024-10-08 18:09:56 发布
阅读量159 收藏
点赞数
文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41927576/article/details/120857025
版权

设计模式学习笔记

1、知识点

  • 基础
  • 设计原则
  • 模板方法
  • 观察者模式
  • 策略模式

2、推荐书籍

  • 《设计模式-可复用面向对象软件的基础》
  • 《重构与模式》

3、基础

  • 设计模式
    设计模式是指在软件开发中，经过验证的，用于解决在特定环境下，重复出现的，特定问题的解决方案

  • 类模型
    图片1

  • 类关系
    图片2
    对图片2做简单描述

  • Stranger只能访问TonyFather的a

  • Tony是TonyFather的子类，又是公有继承，故Tony可以访问TonyFather的a，b

  • Beauty是TonyFather的友元类，故Beauty可以访问TonyFather的a，b，c

  • TonyMother和TonyFather互为友元类，所以TonyMother可以访问TonyFather的a，b，c，TonyFather可以访问TonyMother的d

4、设计原则

  1. 依赖倒置
  • 高层模块不应该依赖低层模块，两者都应该依赖抽象
  • 抽象不应该依赖具体实现，具体实现应该依赖于抽象
    在这里插入图片描述
  • 自动驾驶系统公司是高层，汽车生产厂商为低层，它们不应该互相依赖，一方变动另一方也会跟着
    变动；而应该抽象一个自动驾驶行业标准，高层和低层都依赖它；这样以来就解耦了两方的变动；
    自动驾驶系统、汽车生产厂商都是具体实现，它们应该都依赖自动驾驶行业标准（抽象）
  1. 开放封闭
  • 一个类应该对扩展开放，对修改封闭
  1. 面向接口
  • 不将变量类型声明为某个特定的具体类，而是声明为某个接口
  • 客户程序无需获知对象的具体类型，只需要知道对象所具有的接口
  • 减少系统中各部分的依赖关系，从而实现“高内聚、松耦合”的类型设计方案
  1. 封装变化点
  • 将稳定点和变化点分离，扩展修改变化点
  • 让稳定点和变化点的实现层次分离
  1. 单一职责
  • 一个类应该仅有一个引起它变化的原因
  1. 里氏替换
  • 子类型必须能够替换掉它的父类型
  • 主要出现在子类覆盖父类实现，原来使用父类型的程序可能出现错误，覆盖了父类方法却没有实现父类方法的职责
  1. 接口隔离
  • 不应该强迫客户依赖于它们不用的方法
  • 一般用于处理一个类拥有比较多的接口，而这些接口涉及到很多职责
  1. 组合优于继承
  • 继承耦合度高，组合耦合度低

5、设计方法

5.1 模板方法

  1. 定义
    定义一个操作中的算法的骨架 ，而将一些步骤延迟到子类中。 Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 ——《 设计模式》 GoF
  2. 要点
  • 最常用的设计模式，子类可以复写父类子流程，使父类的骨架流程丰富
  • 反向控制流程的典型应用
  • 父类 protected 保护子类需要复写的子流程；这样子类的子流程只能父类来调用
  1. 本质
  • 通过固定算法骨架来约束子类的行为
  1. 结构图
    在这里插入图片描述
  2. 例子
    需求：某个品牌动物园，有一套固定的表演流程，但是其中有若干个表演子流程可创新替换，以尝试迭代
    更新表演流程；
  • 不使用设计模式实现：
#include <iostream>
using namespace std;

#if 0
class ZooShow {
public:
    void Show0() {
        cout << "show0" << endl;
    }
    void Show2() {
        cout << "show2" << endl;
    }
};

class ZooShowEx {
public:
    void Show1() {
        cout << "show1" << endl;
    }
    void Show3() {
        cout << "show3" << endl;
    }
};

#else if 2

class ZooShow {
public:
    ZooShow(int type = 1) : _type(type) {}

public:
    void Show() {
        Show0();
        Show1();
        Show2();
        Show3();
    }

private:
    void Show0() {
        cout << _type << " show0" << endl;
    }

    void Show1() {
        if (_type == 1) {
            cout << _type << " Show1" << endl;
        } else if (_type == 2) {
            cout << _type << " Show11" << endl;
        } else if (_type == 3) {

        }
    }

    void Show2() {
        if (_type == 20) {
            cout << "base Show22" << endl;
        }
        cout << "base Show2" << endl;
    }

    void Show3() {
        if (_type == 1) {
            cout << _type << " Show3" << endl;
        } else if (_type == 2) {
            cout << _type << " Show33" << endl;
        }
    }
private:
    int _type;
}

#endif

int main () {
#if 0
    ZooShow *zs = new ZooShow;
    ZooShowEx *zs1 = new ZooShowEx;
    zs->Show0();
    zs1->Show1();
    zs->Show2();
    zs1->Show3();
#else if 2
    ZooShow *zs = new ZooShow(1);
    zs->Show();
#endif
    return 0;
}

在上述伪代码中，我们用两种方式实现了需求
第一种方式：定义了两个表演类，每个表演类中又实现了两个表演子类；当我们需要创新替换时，需要重新排列他们的出场顺序
第二种方式：只定义一个表演类，在表演类中，使用一个方法show将子表演顺序确定；当我们需要修改子表演的内容时，我们需要修改_type

  • 使用模板方法实现
#include <iostream>
using namespace std;

class ZooShow {
public:
    // 固定流程封装到这里
    void Show() {
        Show0();
        Show1();
        Show2();
        Show3();
    }
protected:
    // 子流程 使用protected保护起来 不被客户调用 但允许子类扩展
    virtual void Show0(){
        cout << "show0" << endl;
    }
    virtual void Show2(){
        cout << "show2" << endl;
    }
    virtual void Show1() {

    }
    virtual void Show3() {

    }
};
class ZooShowEx : public ZooShow {
protected:
    virtual void Show1(){
        cout << "show1" << endl;
    }
    virtual void Show3(){
        cout << "show3" << endl;
    }
    virtual void Show4() {
        //
    }
};

class ZooShowEx1 : public ZooShow {
protected:
    virtual void Show0(){
        cout << "show1" << endl;
    }
    virtual void Show2(){
        cout << "show3" << endl;
    }
};

class ZooShowEx2 : public ZooShow {
protected:
    virtual void Show1(){
        cout << "show1" << endl;
    }
    virtual void Show2(){
        cout << "show3" << endl;
    }
};
/*
*/
int main () {
    ZooShow *zs = new ZooShowEx;
    // ZooShow *zs1 = new ZooShowEx1;
    // ZooShow *zs2 = new ZooShowEx2;
    zs->Show();
    return 0;
}

在需求中，我们分析可以知道，稳定点是“固定的流程”，变化点是“表演子流程”，在伪代码实现中，我们将表演子流程固定在show方法中，将表演子流程使用virtual声明为虚函数，在继承时可以修改表演子流程里的内容

  1. 其他例子
    C++设计模式之模板方法模式

5.2 观察者模式

  1. 定义
    定义对象间的一种一对多（变化）的依赖关系，以便当一个对象(Subject)的状态发生改变时，所
    有依赖于它的对象都得到通知并自动更新。 ——《 设计模式》 GoF

  2. 要点

  • 观察者模式使得我们可以独立地改变目标与观察者，从而使二者之间的关系松耦合
  • 观察者自己决定是否订阅通知，目标对象并不关注谁订阅了
  • 观察者不要依赖通知顺序，目标对象也不知道通知顺序
  • 常用在基于事件的ui框架中，也是 MVC 的组成部分
  • 常用在分布式系统中、actor框架中
  1. 本质
  • 触发联动
  1. 结构图
    在这里插入图片描述
  2. 例子
    需求：气象站发布气象资料给数据中心，数据中心经过处理，将气象信息更新到两个不同的显示终端（A 和B）
  • 不用设计模式实现

class DisplayA {
public:
    void Show(float temperature);
};

class DisplayB {
public:
    void Show(float temperature);
};

class WeatherData {
};

class DataCenter {
public:
    float CalcTemperature() {
        WeatherData * data = GetWeatherData();
        // ...
        float temper/* = */;
        return temper;
    }
private:
    WeatherData * GetWeatherData(); // 不同的方式
};

int main() {
    DataCenter *center = new DataCenter;
    DisplayA *da = new DisplayA;
    DisplayB *db = new DisplayB;
    float temper = center->CalcTemperature();
    da->Show(temper);
    db->Show(temper);
    return 0;
}
// 终端变化（增加和删除）   数据中心 不应该受终端变化的影响
  • 使用观察者模式实现
#include <vector>

class IDisplay {
public:
    virtual void Show(float temperature) = 0;
    virtual ~IDisplay() {}
};

class DisplayA : public IDisplay {
public:
    virtual void Show(float temperature);
};

class DisplayB : public IDisplay{
public:
    virtual void Show(float temperature);
};

class WeatherData {
};

class DataCenter {
public:
    void Attach(IDisplay * ob);
    void Detach(IDisplay * ob);
    void Notify() {
        float temper = CalcTemperature();
        for (auto iter = obs.begin(); iter != obs.end(); iter++) {
            (*iter)->Show(temper);
        }
    }

private:
    virtual WeatherData * GetWeatherData();

    virtual float CalcTemperature() {
        WeatherData * data = GetWeatherData();
        // ...
        float temper/* = */;
        return temper;
    }
    std::vector<IDisplay*> obs;
};

int main() {
    DataCenter *center = new DataCenter;
    IDisplay *da = new DisplayA();
    IDisplay *db = new DisplayB();
    center->Attach(da);
    center->Attach(db);
    center->Notify();
    
    //-----
    center->Detach(db);
    center->Notify();
    return 0;
}
  1. 其他例子
    C++设计模式之观察者模式

5.3 策略模式

  1. 定义
    定义一系列算法，把它们一个个封装起来，并且使它们可互相替换。该模式使得算法可独立于使用它的客户程序而变化。 ——《设计模式》 GoF

  2. 要点

  • 策略模式提供了一系列可重用的算法，从而可以使得类型在运⾏时方便地根据需要在各个算法之间
    进行切换
  • 策略模式消除了条件判断语句（实际上还是又条件判断语句），也就是在解耦合；

  1. 本质
    分离算法，选择实现

  2. 结构图
    在这里插入图片描述

  3. 例子
    需求：某商场节假日有固定促销活动，为了加大促销力度，现提升国庆节促销活动规格

  • 不使用设计模式实现
enum VacationEnum {
	VAC_Spring,
    VAC_QiXi,
	VAC_Wuyi,
	VAC_GuoQing,
    //VAC_ShengDan,
};

// 稳定的  变化的
class Promotion {
    VacationEnum vac;
public:
    double CalcPromotion(){
        if (vac == VAC_Spring){
            // 春节
        }
        else if (vac == VAC_QiXi){
            // 七夕
        }
        else if (vac == VAC_Wuyi){
            // 五一
        }
		else if (vac == VAC_GuoQing){
			// 国庆
		}
     }
    
};
  • 使用策略模式实现
class Context {

};

class ProStategy {
public:
    virtual double CalcPro(const Context &ctx) = 0;
    virtual ~ProStategy();
};
// cpp
class VAC_Spring : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_QiXi : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
class VAC_QiXi1  : public VAC_QiXi {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_Wuyi : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_GuoQing : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};

class VAC_Shengdan : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};

// 稳定的  变化的
class Promotion {
public:
    Promotion(ProStategy *sss) : s(sss){}
    ~Promotion(){}
    double CalcPromotion(const Context &ctx){
        return s->CalcPro(ctx);
    }
private:
    ProStategy *s;
};

int main () {
    Context ctx;
    ProStategy *s = new VAC_QiXi1();
    Promotion *p = new Promotion(s);
    p->CalcPromotion(ctx);
    return 0;
}
  1. 其他例子

c++设计模式之策略模式

沉默不语者
关注
健康打卡模块_设计模式报告_202005031
08-08
1.2.1 创建型设计模式 创建型设计模式关注对象的创建过程，如工厂模式、单例模式和建造者模式等。在健康打卡模块中，可能会用到工厂模式，通过一个工厂类来创建不同类型的健康打卡对象，这些对象可能包括员工打卡、...
详细介绍23种设计模式，IT人员必读的一本书
04-20
本文将深入探讨23种经典的设计模式，分为创建型模式、结构型模式和行为型模式三类。 #### 1.1 创建型模式 创建型模式关注的是对象的创建机制，它们能够帮助开发者在系统中使用实例化的对象而不需指定具体的类。 #...
Java中23种设计模式
热门推荐
呜呜老司机的博客家园
10-10 8万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
23种设计模式之创建型模式篇
qq_40068304的博客
04-20 1181
1.简单工厂模式2.工厂方法模式 3.抽象工厂模式单例模式是一种常用的软件设计模式，它确保一个类只有一个实例，并提供该实例的全局访问点。//操作步骤一:抽象工厂//操作步骤二:抽象产品A//操作步骤三:抽象产品B//操作步骤四:具体产品A1@Override//操作步骤四:具体产品A2@Override//操作步骤四:具体产品B1@Override//操作步骤四:具体产品B2@Override//操作步骤五:具体工厂1@Override@Override。
（一）创建型设计模式
krain的博客
03-29 653
1. 工厂模式 定义：定义一个创建产品对象的工厂接口，将对象的创建工作推迟到具体子工厂类当中，使其满足创建与使用相分离这一特点。 1.1 简单工厂模式 1.1.1 问题背景分析 现实生活中，原始社会自给自足（没有工厂），农耕社会小作坊（简单工厂，民间酒坊），工业革命流水线（工厂方法，自产自销），现代产业链代工厂（抽象工厂，富士康）。我们的项目代码同样是由简到繁一步一步迭代而来的，但对于调用者来说，却越来越简单。 在日常开发中，凡是需要生成复杂对象的地方，都可以尝试考虑使用工厂模式来代替。 1.1.2
python设计模式（二）--创建类设计模式
chucksun0426的博客
07-31 520
定义将一个复杂对象的构建与表示分离，同样的构建过程可以创建不同的东西建造者模式与抽象工厂模式相似，也用来创建复杂对象主要区别是建造者模式着重一步步构造一个复杂对象，而抽象工厂模式着重于多个系列的产品对象角色产品抽象建造者具体建造者导演定义保证一个类仅有一个实例，并提供一个访问它的全局访问点，避免重复创建实例，以节省系统资源。用途日志读写，web计数器定义创建实时对象的克隆，也叫克隆模式特点优点内存拷贝方式复制，比new方法更优，尤其针对复杂参数创建的对象。...............
23种设计模式之结构型模式篇
qq_40068304的博客
04-20 766
*控制访问：**代理模式可以控制对原始对象的访问，例如可以在访问对象之前或之后执行一些额外的操作，如权限检查、日志记录等。**扩展功能：**代理模式可以在不修改原始对象的基础上，通过代理类来扩展对象的功能。这意味着可以在不影响原有代码的情况下，为对象添加新的行为或特性。**智能化处理：**代理能够实现智能化处理，比如动态代理可以在运行时动态地生成代理对象，这为处理一些需要在运行时才能确定具体行为的情况提供了便利。
创建型设计模式
自古深情留不住，总是套路得人心
02-21 977
1单例模式 定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点 1.1单例模式的写法 1.1.1饿汉模式 public class Singleton { private static Singleton instance = new Singleton(); private Singleton() { } public static Singleton g...
23种设计模式分类
zxn2010的专栏
10-12 1126
软件设计模式使人们可以更加简单方便复用成功的设计和体系结构，它通常包含以下几个基本要素：模式名称、别名、动机、问题、解决方案、效果、模式角色、合作关系、实现方法、实用性、已知应用、例程、模式扩展和相关模式等。
创建型模式 | 单例模式
个人技术博客
12-18 993
单例模式(Singleton Pattern)，使用最广泛的设计模式之一。其意图是保证一个类仅有一个实例被构造，并提供一个访问它的全局访问接口，该实例被程序的所有模块共享。
23种设计模式——创建型设计模式（5种）
Steffen Dinn 的博客
09-07 679
1. 总述 ☞23 种设计模式——创建型设计模式（5种） ☞ 23 种设计模式——结构型设计模式（7种） ☞23 种设计模式——行为型设计模式（11种） 软件设计模式使人们可以更加简单方便复用成功的设计和体系结构，它通常包含以下几个基本要素：模式名称、别名、动机、问题、解决方案、效果、模式角色、合作关系、实现方法、实用性、已知应用、例程、模式扩展和相关模式等。 设计模式...
23种JAVA设计模式和15种J2EE设计模式.docx
09-28
JAVA设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。下面是对每种模式的详细介绍： 创建型模式 创建型模式主要用于解决对象创建的问题。包括以下几种模式： 1.1.1. Abstract Factory—抽象工厂...
Java23种设计模式(总结).doc
09-18
Java 设计模式总结 Java 设计模式是软件开发中的一个重要概念，它们提供了一种通用的解决方案来解决常见的软件设计问题。下面是 23 种 Java 设计模式的总结： 创建型模式 创建型模式处理对象的创建机制，例如类的...
LabVIEW提高开发效率技巧----调度器设计模式
bjcyck的博客
10-04 1363
在LabVIEW开发中，针对多任务并行的需求，使用调度器设计模式（Scheduler Pattern）可以有效地管理多个任务，确保它们根据优先级或时间间隔合理执行。这种模式在需要多任务并发执行时特别有用，尤其是在实时系统、数据采集、硬件控制等场景中。
设计模式、系统设计 record part04
最新发布
m0_47505062的博客
10-08 859
结构型。
Prototype(原型模式)
TimerSea的博客
10-06 543
本篇介绍了原型设计模式基础与实现示例
设计模式-解释器模式
ZSS1753936255的博客
10-04 619
解释器模式描述了如何构成一个简单的语言解释器，主要应用在使用面向对象语言开发的编译器中。它描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。解释器模式（Interpreter）:给定一种语言，定义它的文法表示，并定义一个解释器，该解释器用来根据文法表示来解释语言中的句子。总结：了解即可，难度太大了。
JS设计模式之策略模式：灵活、可扩展的编程利器
前端梦工厂
10-08 993
在 JavaScript 前端开发中，随着代码规模的增长和项目的复杂性，我们常常需要处理各种不同的条件和情况，而这可能导致代码变得冗长、难以维护。这时，我们就需要一种强大而灵活的编程模式来应对这些复杂的逻辑，策略模式就是其中之一。策略模式是一种经典的设计模式，它通过将特定操作封装在独立的策略函数中，使得我们能够轻松地切换和组合不同的算法和策略。在 JavaScript 中，策略模式可以帮助我们处理各种条件判断、算法选择和逻辑分支，提高代码的可读性、可维护性和可扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值