《设计模式的艺术》笔记 - 抽象工厂模式

这篇具有很好参考价值的文章主要介绍了《设计模式的艺术》笔记 - 抽象工厂模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

介绍

        提供了一个创建一系列相关或相互依赖的对象的接口,而无须指定它们具体的类。抽象工厂模式又称为Kit模式,它是一种对象创建型模式。

        在抽象工厂模式中,每个具体工厂都提供了多个工厂方法用于产生多种不同类型的产品,这些产品构成了一个产品族。

实现

myclass.h

//
// Created by yuwp on 2024/1/12.
//

#ifndef DESIGNPATTERNS_MYCLASS_H
#define DESIGNPATTERNS_MYCLASS_H

#include <iostream>

class AbstractProductA {

};

class AbstractProductB {

};

class ConcreteProductA : public AbstractProductA {
public:
    ConcreteProductA();
};

class ConcreteProductB : public AbstractProductB {
public:
    ConcreteProductB();
};

class AbstractFactory {
public:
    virtual AbstractProductA *createProductA() = 0;
    virtual AbstractProductB *createProductB() = 0;
};

class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA *createProductA() override;
    AbstractProductB *createProductB() override;
};

#endif //DESIGNPATTERNS_MYCLASS_H

myclass.cpp

//
// Created by yuwp on 2024/1/12.
//

#include "myclass.h"

#include "myclass.h"

ConcreteProductA::ConcreteProductA() {
    std::cout << "产品A" << std::endl;
}

ConcreteProductB::ConcreteProductB() {
    std::cout << "产品B" << std::endl;
}

AbstractProductA* ConcreteFactory1::createProductA() {
    std::cout << "工厂1生产了: ";
    return new ConcreteProductA();
}

AbstractProductB* ConcreteFactory1::createProductB() {
    std::cout << "工厂1生产了: ";
    return new ConcreteProductB();
}

main.cpp

#include <iostream>
#include <mutex>
#include "myclass.h"

int main() {
    AbstractFactory *factory = new ConcreteFactory1();
    auto a = factory->createProductA();
    auto b = factory->createProductB();
    delete factory;
    delete a;
    delete b;
    return 0;
}

总结

        优点:

        1. 抽象工厂模式隔离了具体类的生成,使得客户并不需要知道什么被创建。由于这种隔离,更换一个具体工厂就变得相对容易,所有的具体工厂都实现了在抽象工厂中声明的那些公共接口,因此只需改变具体工厂的实例,就可以在某种程度上改变整个软件系统的行为。

        2. 当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象。

        3. 增加新的产品族很方便,无须修改已有系统,符合开闭原则。

        缺点:

        1. 增加新的产品等级结构麻烦,需要对原有系统进行较大的修改,甚至需要修改抽象层代码,这显然会带来较大的不便,违背了开闭原则。

        使用场景:

        1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有类型的工厂模式都是很重要的,用户无须关心对象的创建过程,将对象的创建和使用解耦。

        2. 系统中有多于一个的产品族,而每次只使用其中某一个产品族。可以通过配置文件等方式来使得用户可以动态改变产品族,也可以很方便地增加新的产品族。

        3. 属于同一个产品族的产品将在一起使用,这一约束必须在系统的设计中体现出来。同一个产品族中的产品可以是没有任何关系的对象,但是它们都具有一些共同的约束。例如同一操作系统下的按钮和文本框,按钮与文本框之间没有直接关系,但它们都是属于某一操作系统的,此时具有一个共同的约束条件:操作系统的类型。

        4. 产品等级结构稳定,设计完成之后,不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。

练习

myclass.h

//
// Created by yuwp on 2024/1/12.
//

#ifndef DESIGNPATTERNS_MYCLASS_H
#define DESIGNPATTERNS_MYCLASS_H

#include <iostream>

class Controller {  // 抽象产品

};

class AndroidOperationController : public Controller { // 具体产品
public:
    AndroidOperationController();
};

class AndroidInterfaceController : public Controller { // 具体产品
public:
    AndroidInterfaceController();
};

class IOSOperationController : public Controller { // 具体产品
public:
    IOSOperationController();
};

class IOSInterfaceController : public Controller { // 具体产品
public:
    IOSInterfaceController();
};

class ControllerFactory { // 抽象工厂
public:
    virtual Controller *createOperation() = 0;
    virtual Controller *createInterface() = 0;
};

class AndroidControllerFactory : public ControllerFactory {
public:
    Controller *createOperation() override;
    Controller *createInterface() override;
};

class IOSControllerFactory : public ControllerFactory {
public:
    Controller *createOperation() override;
    Controller *createInterface() override;
};

#endif //DESIGNPATTERNS_MYCLASS_H

myclass.cpp

//
// Created by yuwp on 2024/1/12.
//

#include "myclass.h"

#include "myclass.h"

AndroidOperationController::AndroidOperationController() {
    std::cout << "Android系统游戏操作控制" << std::endl;
}

AndroidInterfaceController::AndroidInterfaceController() {
    std::cout << "Android系统游戏界面控制" << std::endl;
}

IOSOperationController::IOSOperationController() {
    std::cout << "ios系统游戏操作控制" << std::endl;
}

IOSInterfaceController::IOSInterfaceController() {
    std::cout << "ios系统游戏界面控制" << std::endl;
}

Controller* AndroidControllerFactory::createOperation() {
    return new AndroidOperationController();
}

Controller* AndroidControllerFactory::createInterface() {
    return new AndroidInterfaceController();
}

Controller* IOSControllerFactory::createOperation() {
    return new IOSOperationController();
}

Controller* IOSControllerFactory::createInterface() {
    return new IOSInterfaceController();
}

main.cpp文章来源地址https://www.toymoban.com/news/detail-793647.html

#include <iostream>
#include <mutex>
#include "myclass.h"

int main() {
    ControllerFactory *factory;
    Controller *op, *in;

    factory = new AndroidControllerFactory();
    op = factory->createOperation();
    in = factory->createInterface();
    delete factory;
    delete op;
    delete in;

    factory = new IOSControllerFactory();
    op = factory->createOperation();
    in = factory->createInterface();
    delete factory;
    delete op;
    delete in;

    return 0;
}

到了这里,关于《设计模式的艺术》笔记 - 抽象工厂模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 自学设计模式(简单工厂模式、工厂模式、抽象工厂模式)

    使用工厂模式来生产某类对象(代码简化且容易维护,类之间有血缘关系,可以通过工厂类进行生产); 简单工厂模式(用于创建简单对象) 对于简单工厂模式,需要的工厂类只有一个; 在工厂类中的公共成员函数来创建所需对象; 工厂模式 简单工厂模式会违反开放封闭

    2024年02月11日
    浏览(43)
  • 【设计模式】单例模式、工厂方法模式、抽象工厂模式

    1. 单例模式 (Singleton Pattern): 场景: 在一个应用程序中,需要一个全局唯一的配置管理器,确保配置信息只有一个实例。 2. 工厂方法模式 (Factory Method Pattern): 场景: 创建一组具有相似功能但具体实现不同的日志记录器。 3. 抽象工厂模式 (Abstract Factory Pattern): 场景: 创建不同

    2024年01月15日
    浏览(61)
  • 设计模式 - 抽象工厂模式

    学完工厂模式,才发现还有一个抽象工厂模式;学习后发现不论是通过接口方式、还是继承方式,都可以使用抽象工厂模式;但是个人建议更多的时候,我们可以优先考虑接口方式,毕竟 单继承,多实现 设计模式分为三种类型,共23种 创建型模式:单例模式、工厂模式、抽

    2024年02月13日
    浏览(45)
  • 【设计模式】抽象工厂模式

    抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个

    2024年02月13日
    浏览(43)
  • 设计模式-抽象工厂模式

    抽象工厂模式:该模式是对工厂模式的拓展,因为工厂模式中创建的产品都需要继承自同一个父类或接口,创建的产品类型相同,无法创建其他类型产品,所以抽象工厂模式对其进行拓展,使其可以创建其他类型的产品。 手机产品 Pad产品 工厂 优点:创建的产品种类不单一

    2024年02月13日
    浏览(44)
  • 重温设计模式 --- 抽象工厂模式

    抽象工厂模式 一种创建型设计模式,它提供了一种方式来封装一组具有相同主题的工厂,而不必指定它们具体的类。这样,客户端代码就可以使用抽象工厂来创建一组相关的对象,而不必关心实际创建的具体类。 抽象工厂模式有以下几个主要角色: 抽象工厂(AbstractFactory)

    2024年02月13日
    浏览(49)
  • 设计模式(三):抽象工厂模式

    抽象工厂模式 (Abstract Factory Pattern)属于创建型模式,是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。 在 抽象工厂模式 中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。 通过使用 抽

    2024年04月25日
    浏览(40)
  • 设计模式(3)抽象工厂模式

    一、介绍: 1、定义:提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。 2、组成结构: (1)抽象工厂角色:担任这个角色的是工厂方法模式的核心,它是与应用程序无关的。任何在模式中创建对象的工厂类必须实现这个接口。 (2)具体工厂角色

    2024年02月11日
    浏览(53)
  • 【设计模式专题之抽象工厂模式】3. 家具工厂

    题目描述 小明家新开了两个工厂用来生产家具,一个生产现代风格的沙发和椅子,一个生产古典风格的沙发和椅子,现在工厂收到了一笔订单,请你帮他设计一个系统,描述订单需要生产家具的信息。 输入描述 输入的第一行是一个整数 N(1 ≤ N ≤ 100),表示订单的数量。

    2024年03月12日
    浏览(51)
  • 结构型设计模式-单例模式/工厂模式/抽象工厂

    创建型设计模式-单例模式/工厂模式/抽象工厂 行为型设计模式:模板设计模式/观察者设计模式/策略设计模式 C#反射机制实现开闭原则的简单工厂模式 设计模式可以分为三种类型: 创建型设计模式、结构型设计模式和行为型设计模式 。 创建型设计模式:这些模式涉及到 对

    2024年02月11日
    浏览(53)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包