boolan 设计模式第二周笔记

最新推荐文章于 2024-10-04 19:09:21 发布
最新推荐文章于 2024-10-04 19:09:21 发布
阅读量87 收藏
点赞数
文章标签： 设计模式 数据库
原文链接：https://segmentfault.com/a/1190000012729391
版权

对象创建模式

  • 通过对象创建模式绕开new，来避免对象创建过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。
  • 典型模式

Factory Method
Abstract Factory
Prototype
Builder

Factory Method

clipboard.png

class ISplitter{
public:
    virtual void split()=0;
    virtual ~ISplitter(){}
};

class BinarySplitter : public ISplitter{
    
};

class TxtSplitter: public ISplitter{
    
};

class PictureSplitter: public ISplitter{
    
};

class VideoSplitter: public ISplitter{
    
};

class MainForm : public Form
{
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
    ProgressBar* progressBar;

public:
    void Button1_Click(){


        
        ISplitter * splitter=
            new BinarySplitter();//依赖具体类
        
        splitter->split();

    }
};

工厂模式

//抽象类
class ISplitter{
public:
    virtual void split()=0;
    virtual ~ISplitter(){}
};


//工厂基类
class SplitterFactory{
public:
    virtual ISplitter* CreateSplitter()=0;
    virtual ~SplitterFactory(){}
};

//具体类
class BinarySplitter : public ISplitter{
    
};

class TxtSplitter: public ISplitter{
    
};

class PictureSplitter: public ISplitter{
    
};

class VideoSplitter: public ISplitter{
    
};

//具体工厂
class BinarySplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new BinarySplitter();
    }
};

class TxtSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new TxtSplitter();
    }
};

class PictureSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new PictureSplitter();
    }
};

class VideoSplitterFactory: public SplitterFactory{
public:
    virtual ISplitter* CreateSplitter(){
        return new VideoSplitter();
    }
};
class MainForm : public Form
{
    SplitterFactory*  factory;//工厂

public:
    
    MainForm(SplitterFactory*  factory){
        this->factory=factory;
    }
    
    void Button1_Click(){

        
        ISplitter * splitter=
            factory->CreateSplitter(); //多态new
        
        splitter->split();

    }
};

通过抽象类和抽象工厂将具体的对象创建工作延迟到子类工厂的实现中。这样实现了在mainForm中的多态new，实现了客户端与具体类的解耦合。

  • 模式定义

定义一个用于创建子类对象的接口，让子类决定实例化哪一个类。Factory Method 使得一个类的实例化延迟（目的：解耦，手段：虚函数）到子类。
————《设计模式》GoF

clipboard.png

clipboard.png

Abstract Factory

class EmployeeDAO{
    
public:
    vector<EmployeeDO> GetEmployees(){
        SqlConnection* connection =
            new SqlConnection();
        connection->ConnectionString = "...";

        SqlCommand* command =
            new SqlCommand();
        command->CommandText="...";
        command->SetConnection(connection);

        SqlDataReader* reader = command->ExecuteReader();
        while (reader->Read()){

        }

    }
};
//数据库访问有关的基类
class IDBConnection{
    
};
class IDBConnectionFactory{
public:
    virtual IDBConnection* CreateDBConnection()=0;
};


class IDBCommand{
    
};
class IDBCommandFactory{
public:
    virtual IDBCommand* CreateDBCommand()=0;
};


class IDataReader{
    
};
class IDataReaderFactory{
public:
    virtual IDataReader* CreateDataReader()=0;
};


//支持SQL Server
class SqlConnection: public IDBConnection{
    
};
class SqlConnectionFactory:public IDBConnectionFactory{
    
};


class SqlCommand: public IDBCommand{
    
};
class SqlCommandFactory:public IDBCommandFactory{
    
};


class SqlDataReader: public IDataReader{
    
};
class SqlDataReaderFactory:public IDataReaderFactory{
    
};

//支持Oracle
class OracleConnection: public IDBConnection{
    
};

class OracleCommand: public IDBCommand{
    
};

class OracleDataReader: public IDataReader{
    
};



class EmployeeDAO{
    IDBConnectionFactory* dbConnectionFactory;
    IDBCommandFactory* dbCommandFactory;
    IDataReaderFactory* dataReaderFactory;
    
    
public:
    vector<EmployeeDO> GetEmployees(){
        IDBConnection* connection =
            dbConnectionFactory->CreateDBConnection();
        connection->ConnectionString("...");

        IDBCommand* command =
            dbCommandFactory->CreateDBCommand();
        command->CommandText("...");
        command->SetConnection(connection); //关联性

        IDBDataReader* reader = command->ExecuteReader(); //关联性
        while (reader->Read()){

        }

    }
};
//数据库访问有关的基类
class IDBConnection{
    
};

class IDBCommand{
    
};

class IDataReader{
    
};


class IDBFactory{
public:
    virtual IDBConnection* CreateDBConnection()=0;
    virtual IDBCommand* CreateDBCommand()=0;
    virtual IDataReader* CreateDataReader()=0;
    
};


//支持SQL Server
class SqlConnection: public IDBConnection{
    
};
class SqlCommand: public IDBCommand{
    
};
class SqlDataReader: public IDataReader{
    
};


class SqlDBFactory:public IDBFactory{
public:
    virtual IDBConnection* CreateDBConnection()=0;
    virtual IDBCommand* CreateDBCommand()=0;
    virtual IDataReader* CreateDataReader()=0;
 
};

//支持Oracle
class OracleConnection: public IDBConnection{
    
};

class OracleCommand: public IDBCommand{
    
};

class OracleDataReader: public IDataReader{
    
};



class EmployeeDAO{
    IDBFactory* dbFactory;
    
public:
    vector<EmployeeDO> GetEmployees(){
        IDBConnection* connection =
            dbFactory->CreateDBConnection();
        connection->ConnectionString("...");

        IDBCommand* command =
            dbFactory->CreateDBCommand();
        command->CommandText("...");
        command->SetConnection(connection); //关联性

        IDBDataReader* reader = command->ExecuteReader(); //关联性
        while (reader->Read()){

        }

    }
};

模式定义：
提供一个接口，让该接口负责创建一系列相关或者相互依赖的对象，无需指定它们具体的类。
————《设计模式》GoF

clipboard.png

clipboard.png

Prototype&原形模式

动机：
clipboard.png

//抽象类
class ISplitter{
public:
    virtual void split()=0;
    virtual ISplitter* clone()=0; //通过克隆自己来创建对象
    
    virtual ~ISplitter(){}

};
//具体类
class BinarySplitter : public ISplitter{
public:
    virtual ISplitter* clone(){
        return new BinarySplitter(*this);
    }
};

class TxtSplitter: public ISplitter{
public:
    virtual ISplitter* clone(){
        return new TxtSplitter(*this);
    }
};

class PictureSplitter: public ISplitter{
public:
    virtual ISplitter* clone(){
        return new PictureSplitter(*this);
    }
};

class VideoSplitter: public ISplitter{
public:
    virtual ISplitter* clone(){
        return new VideoSplitter(*this);
    }
};
class MainForm : public Form
{
    ISplitter*  prototype;//原型对象

public:
    
    MainForm(ISplitter*  prototype){
        this->prototype=prototype;
    }
    
    void Button1_Click(){

        ISplitter * splitter=
            prototype->clone(); //克隆原型
        
        splitter->split();
        
        

    }
};
  • 模式定义

使用原型实例指定创建对象的种类，然后通过拷贝这些原型来创建新的对象。
————《设计模式》GoF

clipboard.png

clipboard.png

Builder 构建器

  • 动机

clipboard.png


class House{
    //....
};

class HouseBuilder {
public:
    House* GetResult(){
        return pHouse;
    }
    virtual ~HouseBuilder(){}
protected:
    
    House* pHouse;
    virtual void BuildPart1()=0;
    virtual void BuildPart2()=0;
    virtual void BuildPart3()=0;
    virtual void BuildPart4()=0;
    virtual void BuildPart5()=0;
    
};

class StoneHouse: public House{
    
};

class StoneHouseBuilder: public HouseBuilder{
protected:
    
    virtual void BuildPart1(){
        //pHouse->Part1 = ...;
    }
    virtual void BuildPart2(){
        
    }
    virtual void BuildPart3(){
        
    }
    virtual void BuildPart4(){
        
    }
    virtual void BuildPart5(){
        
    }
    
};


class HouseDirector{
    
public:
    HouseBuilder* pHouseBuilder;
    
    HouseDirector(HouseBuilder* pHouseBuilder){
        this->pHouseBuilder=pHouseBuilder;
    }
    
    House* Construct(){
        
        pHouseBuilder->BuildPart1();
        
        for (int i = 0; i < 4; i++){
            pHouseBuilder->BuildPart2();
        }
        
        bool flag=pHouseBuilder->BuildPart3();
        
        if(flag){
            pHouseBuilder->BuildPart4();
        }
        
        pHouseBuilder->BuildPart5();
        
        return pHouseBuilder->GetResult();
    }
};
  • 模式定义

讲一个复杂对象的构建与其表示相分离，使得同样的构建过程（稳定）可以创建不同的表示（变化）
————《设计模式》GoF

  • 结构

clipboard.png

clipboard.png

接口隔离模式

  • 在组件构建过程中，某些接口之间的依赖常常会带来很对问题，甚至根本无法实现。采用添加一层间接（稳定）的接口，来隔离本来互相紧密关联的接口是一种常见的解决方案。

典型模式
Facade
Proxy
Adapter
Mediator

Facade&门面模式

  • 系统间耦合的复杂度

clipboard.png

  • 动机

clipboard.png

  • 模式定义

为子系统中的一组接口提供一个一致的界面，Facade，模式定义了一个高层接口，这个接口使得这一子系统更加容易使用（复用）
————《设计模式》GoF

  • 结构

clipboard.png

clipboard.png

Proxy&代理模式

  • 动机

clipboard.png

  • 模式定义

为其他对象提供一种代理以控制（隔离，使用窗口）对这个对象的访问。
————《设计模式》GoF

class ISubject{
public:
    virtual void process();
};


//Proxy的设计
class SubjectProxy: public ISubject{
    
    
public:
    virtual void process(){
        //对RealSubject的一种间接访问
        //....
    }
};

class ClientApp{
    
    ISubject* subject;
    
public:
    
    ClientApp(){
        subject=new SubjectProxy();
    }
    
    void DoTask(){
        //...
        subject->process();
        
        //....
    }
};
class ISubject{
public:
    virtual void process();
};


class RealSubject: public ISubject{
public:
    virtual void process(){
        //....
    }
};

class ClientApp{
    
    ISubject* subject;
    
public:
    
    ClientApp(){
        subject=new RealSubject();
    }
    
    void DoTask(){
        //...
        subject->process();
        
        //....
    }
};
  • 结构

clipboard.png

clipboard.png

Adapter&适配器

  • 动机

clipboard.png

//目标接口（新接口）
class ITarget{
public:
    virtual void process()=0;
};

//遗留接口（老接口）
class IAdaptee{
public:
    virtual void foo(int data)=0;
    virtual int bar()=0;
};

//遗留类型
class OldClass: public IAdaptee{
    //....
};

//对象适配器
class Adapter: public ITarget{ //继承
protected:
    IAdaptee* pAdaptee;//组合
    
public:
    
    Adapter(IAdaptee* pAdaptee){
        this->pAdaptee=pAdaptee;
    }
    
    virtual void process(){
        int data=pAdaptee->bar();
        pAdaptee->foo(data);
        
    }
    
    
};


//类适配器
class Adapter: public ITarget,
               protected OldClass{ //多继承
               
               
}


int main(){
    IAdaptee* pAdaptee=new OldClass();
    
    
    ITarget* pTarget=new Adapter(pAdaptee);
    pTarget->process();
    
    
}


class stack{
    deqeue container;
    
};

class queue{
    deqeue container;
    
};
  • 模式定义

将一个类的接口转换成客户希望的另一个接口，Adapter模式使得原本由于接口不兼容而不能在一起工作的那些类可以一起工作。
————《设计模式》GoF

  • 结构

clipboard.png

clipboard.png

Mediator&中介者

  • 动机

clipboard.png

  • 模式定义

用一个中介对象来封装（封装变化）一系列的对象交互。中介者使各对象不需要显示的互相引用（编译时依赖-》运行时依赖），从而使其耦合松散（管理变化），而且可以独立地改变它们之间的交互。
————《设计模式》GoF

  • 结构

clipboard.png

clipboard.png

weixin_34343000
关注
Boolan C++设计模式 第二周笔记
Sylar2016的博客
07-06 492
23种设计模式 “对象创建”模式 通过“对象创建”模式绕开new，来避免对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。 典型模式： Factory MethodAbstract FactoryPrototypeBuilder 6. Factory Method工厂方法 模式定义 定义一个用于
Boolan C++设计模式 第三周笔记
Sylar2016的博客
07-16 649
23种设计模式 “对象性能”模式 面向对象很好的解决了“抽象”的问题，但是必不可免地要付出一定的代价。对于通常情况来讲，面向对象的成本大都可以忽略不计。但是某些情况，面向对象所带来的成本必须谨慎处理。 典型模式 SingletonFlyweight
Boolan 设计模式 第二周
Zarathustra的博客
10-09 279
“对象创建”模式 通过”对象创建”模式绕开new,来避免对象创建(new)过程中所导致的紧耦合(依赖具体类),从而支持对象创建的稳定.它是接口抽象之后的第一步工作. 典型模式Factory Method Abstract Factory Prototype Builder工厂方法 工厂模式（Factory Pattern）属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对
Boolan C++设计模式 第一周笔记
Sylar2016的博客
06-29 660
1.什么是设计模式 “每一个描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案。这样，你就能一次又一次地使用该方案而不必做重复劳动”。 ——Christopher Alexander 设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。 使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可
boolan 设计模式笔记
weixin_34235371的博客
12-31 92
设计模式 什么是设计模式 每一个描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案。这样，你就能一次又一次地使用该方案而不必做重复劳动”。 ...
Boolan c++学习第三周笔记
u013127035的博客
04-08 264
类之间的关系：1.      inheritance(继承)2.      composition（复合）3.      delegation（委托）首先讲复合：1.      我这个类里面有一个其他的类的对象，has  a  ，有一个就叫复合；这就是所谓的复合。我们的这个例子比较特殊，我们的这个新类的所有的功能都可以借助这个类来实现所有的功能。这个地方的pop这个函数，并没有任何的操作，直接调用...
cppan 命令_(Boolan)C++设计模式学习笔记(第三周)
weixin_39866646的博客
02-23 143
“对象性能”模式面向对象很好的解决了“抽象”的问题，但是必不可免地要付出一定的代价。对于通常情况来讲，面向对象的成本大都可以忽略不计。但是某些情况，面向对象所带来的成本必须谨慎处理。典型模式SingletonFlyweight模式定义保证一个类仅有一个实例，并提供一个该实例的全局访问点。——《设计模式》GoF动机(Motivation)在软件系统中，经常有这样一个特殊的类，必须保证它们在系统中只存...
Boolan 第三周笔记
weixin_30808693的博客
01-21 86
首先反思一下第二周作业。我在Rectangle类中对Point类的数据成员进行赋值，而没有为Point写构造函数再通过构造函数初始化Point的成员，这样是不好的。“每个类负责定义各自的接口”，“要想与对象交互必须使用该类的接口（C++ Primer中文第五版 P532)”,这样的准则在原书中是描述基类和派生类的，我觉得同样适用于委托。因此第二周作业中Point和Rectangle应该负责定义各自...
设计模式笔记
保持一颗敬畏之心，简单地调用C++，适当地向C++妥协，让以后的自己看懂代码，让别人看懂代码。
01-26 99
目录前言正文参考 前言 正文 参考 设计模式
C++课程--设计设计思想、方法与模式（李建忠老师）
gomissionone的博客
07-06 2951
【干货回顾】李建忠老师在 Boolan 直播间和大家畅聊《C++ 软件设计与模式的道法术》，精辟囊括了《软件设计思想、方法与模式》C++课程的主要内容，以下为本期直播干货重点：李建忠
Boolan C++ 笔记 七
Zarathustra的博客
08-31 325
OOP(Object-Oriented programming) VS. GP(Generic Programming) OOP企图将datas 和 methods 关联在一起 数据放在类里面,操作这些数据的函数也放在类里面 template<class T,class Alloc = alloc> class list{ ... void sort(); }为什么list不能使用::sort()
（Boolan）C++设计模式 <九> ——单例模式（Singleton）和享元模式（FlyWeight）
Toonle的专栏
08-23 567
“对象性能”模式 面向对象很好的解决了“抽象”的问题，但是必不可免地要付出一定的代价。对于通常情况来讲，面向对象的成本大都可以忽略不计。但是某些情况，面向对象所带来的成本必须谨慎处理。 典型模式 Sington Flyweight 单例模式Singleton 保证一个类仅有一个实例，并提供一个该实例的全局访问点。——《设计模式》GoF 动机在软件系统中，经常有这样一个特殊的类，必须保证
Boolan 软件架构与C++专家团队走进华为，助力软件变革共创技术新生态
gomissionone的博客
01-18 290
2020年是全球科技版图的转折年，提升基础软件创新能力，掌握技术主导权至关重要。华为作为中国自主技术创新的代表性力量，一直在不断寻求突破，引领业界。Boolan专家团队助力华为软件变革，为其定制软件架构和C++系列技术赋能方案，包括性能工程、架构重构、安全可信、领域驱动等多项专题，在华为反响热烈。
（Boolan）C++设计模式 <十二> ——命令模式（Command）和访问器（Visitor）
Toonle的专栏
08-23 514
“行为变化”模式 在组建的构建过程中，组建行为的变化经常导致组建本身剧烈的变化。“行为变化”模式将组建的行为和组建本身进行解耦，从而主持组件的变化，实现两者之间的松耦合。 典型模式 Command Visitor 命令模式Command 将一个请求（行为）封装为对象，从而使你可用不同的请求，对客户进行参数化；对请求排队或记录请求日志以及支持可撤销的操作。——《设计模式》GoF 动机在软件
LabVIEW提高开发效率技巧----调度器设计模式
bjcyck的博客
10-04 1067
在LabVIEW开发中，针对多任务并行的需求，使用调度器设计模式（Scheduler Pattern）可以有效地管理多个任务，确保它们根据优先级或时间间隔合理执行。这种模式在需要多任务并发执行时特别有用，尤其是在实时系统、数据采集、硬件控制等场景中。
设计模式-解释器模式
最新发布
ZSS1753936255的博客
10-04 307
解释器模式描述了如何构成一个简单的语言解释器，主要应用在使用面向对象语言开发的编译器中。它描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。解释器模式（Interpreter）:给定一种语言，定义它的文法表示，并定义一个解释器，该解释器用来根据文法表示来解释语言中的句子。总结：了解即可，难度太大了。
设计模式之访问者模式
一个老Java开发的自白
10-02 1253
访问者模式是一种强大的设计模式，它通过将数据结构与数据操作分离，使得系统更加灵活和可扩展。然而，它也有一些缺点，如增加新的数据结构困难、破坏封装等。因此，在使用访问者模式时，需要权衡其优缺点，并根据具体的应用场景进行选择。 在实际开发中，访问者模式通常适用于需要对一个对象结构中的对象进行很多不同并且不相关的操作的场景。在这些情况下，使用访问者模式可以避免让这些操作“污染”这些对象的类，从而保持代码的清晰和简洁。
设计模式-适配器模式
ZSS1753936255的博客
10-02 424
这段代码就是在适配器Adapter中关联了适配器适配器母接口Speker. 在适配器中的translate中实现了 speaker.speak()方法。首先：如何调用被适配的对象呢？可以通过 关联或者继承 适配器来实现。（1：这段代码是通过是通过继承来实现的，也达到了接口转换的目的）适配器模式：将一类的接口转换成满足用户需求的另一种接口。是的不相容的接口得以共同工作。2:通过对象关联的方法来实现适配器，就是上述的UML类图保持一致。
C++编程学习：STL课件与设计模式解析
1. **C++设计模式**：这部分内容涵盖了设计之道和设计之术，主要讲解了GOF23种经典设计模式。设计模式是软件工程中经过验证的、在特定场景下解决常见问题的解决方案。通过学习设计模式，开发者可以更好地理解和应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值