设计模式--工厂模式（Factory Pattern）

news2024/11/16 17:27:52

一、 什么是工厂模式

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的接口，但是将对象的实例化过程推迟到子类中。工厂模式允许通过调用一个共同的接口方法来创建不同类型的对象，而无需暴露对象的实例化逻辑。

工厂模式的主要目标是解耦对象的创建和使用，以及提供一种更灵活的方式来管理对象的实例化。通过使用工厂模式，可以轻松添加新类型的对象，而不会影响到已有的代码。

工厂模式通常涉及以下几个核心角色：

  1. 产品（Product）：这是一个抽象类或接口，定义了所创建对象的通用接口。
  2. 具体产品（Concrete Product）：这些是实现了产品接口的具体类，它们是工厂方法模式的创建目标。
  3. 工厂（Factory）：这是一个抽象类或接口，定义了创建对象的接口方法。工厂类通常是一个创建具体产品对象的工厂方法。
  4. 具体工厂（Concrete Factory）：这些是实现了工厂接口的具体类，它们负责实例化具体的产品对象。

工厂模式可以分为三种常见的变体：

  1. 简单工厂模式（Simple Factory Pattern）：通过一个共同的工厂类来创建对象，客户端只需传递一个参数来指定所需的对象类型。虽然不是严格意义上的设计模式，但它是工厂模式的基础。
  2. 工厂方法模式（Factory Method Pattern）：定义一个工厂接口，具体的工厂子类负责实现工厂接口并创建对象。每个具体工厂对应一个特定的产品。
  3. 抽象工厂模式（Abstract Factory Pattern）：提供了一种创建一系列相关或相互依赖对象的接口，而无需指定具体类。适用于创建一组相互关联的产品。

二、简单工厂模式的代码样例

简单工厂模式（Simple Factory Pattern）虽然不是严格的设计模式，但它是工厂模式的一种基本形式，适用于创建单一类别的对象。在简单工厂模式中，有一个工厂类负责根据客户端的请求创建不同类型的对象。

以下是一个用C++实现简单工厂模式的示例：

#include <iostream>

// 抽象产品类
class Product {
public:
    virtual void operation() = 0;
};

// 具体产品类A
class ConcreteProductA : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductA operation." << std::endl;
    }
};

// 具体产品类B
class ConcreteProductB : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductB operation." << std::endl;
    }
};

// 简单工厂类
class SimpleFactory {
public:
    // 根据传入的参数创建不同类型的产品对象
    static Product* createProduct(char type) {
        if (type == 'A') {
            return new ConcreteProductA();
        } else if (type == 'B') {
            return new ConcreteProductB();
        } else {
            return nullptr; // 可以抛出异常或其他处理
        }
    }
};

int main() {
    // 客户端通过工厂创建产品
    Product* productA = SimpleFactory::createProduct('A');
    Product* productB = SimpleFactory::createProduct('B');

    if (productA) {
        productA->operation();
        delete productA;
    }

    if (productB) {
        productB->operation();
        delete productB;
    }

    return 0;
}

在这个例子中，我们定义了一个抽象产品类 Product，然后有两个具体的产品类 ConcreteProductA 和 ConcreteProductB。简单工厂类 SimpleFactory 有一个静态方法 createProduct，根据传入的参数来创建不同类型的产品对象。

虽然简单工厂模式简化了对象的实例化，但它的弊端在于如果需要添加新类型的产品，就需要修改工厂类的代码。因此，当需要支持更多产品类型时，更推荐使用工厂方法模式或抽象工厂模式。

三、工厂方法模式的代码样例

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但是将具体的对象实例化推迟到子类中。每个具体的工厂子类负责创建特定类型的对象。这种模式使得客户端代码与具体创建对象的代码分离，实现了松耦合。

以下是一个用C++实现工厂方法模式的示例：

#include <iostream>

// 抽象产品类
class Product {
public:
    virtual void operation() = 0;
};

// 具体产品类A
class ConcreteProductA : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductA operation." << std::endl;
    }
};

// 具体产品类B
class ConcreteProductB : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductB operation." << std::endl;
    }
};

// 抽象工厂类
class Factory {
public:
    virtual Product* createProduct() = 0;
};

// 具体工厂类A
class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

// 具体工厂类B
class ConcreteFactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};

int main() {
    // 客户端通过具体工厂来创建产品
    Factory* factoryA = new ConcreteFactoryA();
    Product* productA = factoryA->createProduct();
    productA->operation();
    delete factoryA;
    delete productA;

    Factory* factoryB = new ConcreteFactoryB();
    Product* productB = factoryB->createProduct();
    productB->operation();
    delete factoryB;
    delete productB;

    return 0;
}

在这个例子中，我们定义了一个抽象产品类 Product，然后有两个具体的产品类 ConcreteProductA 和 ConcreteProductB。抽象工厂类 Factory 定义了一个纯虚函数 createProduct，由具体的工厂子类来实现该方法并创建特定类型的产品对象。

客户端使用具体的工厂类来创建产品，这样客户端代码与具体的产品创建代码分离，实现了解耦。工厂方法模式允许通过添加新的工厂子类来支持新的产品类型，而无需修改现有的代码。

四、抽象工厂模式的代码样例

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供一个接口用于创建一系列相关或相互依赖的对象，而无需指定具体类。抽象工厂模式适用于需要创建一组相互关联的产品的情况，它将一组相关的工厂类封装起来。

以下是一个用C++实现抽象工厂模式的示例：

#include <iostream>

// 抽象产品类A
class AbstractProductA {
public:
    virtual void operationA() = 0;
};

// 具体产品类A1
class ConcreteProductA1 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ConcreteProductA1 operation." << std::endl;
    }
};

// 具体产品类A2
class ConcreteProductA2 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ConcreteProductA2 operation." << std::endl;
    }
};

// 抽象产品类B
class AbstractProductB {
public:
    virtual void operationB() = 0;
};

// 具体产品类B1
class ConcreteProductB1 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ConcreteProductB1 operation." << std::endl;
    }
};

// 具体产品类B2
class ConcreteProductB2 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ConcreteProductB2 operation." << std::endl;
    }
};

// 抽象工厂类
class AbstractFactory {
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

// 具体工厂类1
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA1();
    }
    AbstractProductB* createProductB() override {
        return new ConcreteProductB1();
    }
};

// 具体工厂类2
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA2();
    }
    AbstractProductB* createProductB() override {
        return new ConcreteProductB2();
    }
};

int main() {
    // 客户端通过具体工厂来创建一组相关的产品
    AbstractFactory* factory1 = new ConcreteFactory1();
    AbstractProductA* productA1 = factory1->createProductA();
    AbstractProductB* productB1 = factory1->createProductB();
    productA1->operationA();
    productB1->operationB();
    delete factory1;
    delete productA1;
    delete productB1;

    AbstractFactory* factory2 = new ConcreteFactory2();
    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();
    productA2->operationA();
    productB2->operationB();
    delete factory2;
    delete productA2;
    delete productB2;

    return 0;
}

在这个例子中，我们定义了两组相关的产品类：AbstractProductA 和 AbstractProductB，然后分别有两个具体的产品类。抽象工厂类 AbstractFactory 定义了两个纯虚函数，分别用于创建 AbstractProductA 和 AbstractProductB 对象。具体的工厂类 ConcreteFactory1 和 ConcreteFactory2 实现了这些方法，并创建特定类型的产品对象。

通过使用抽象工厂模式，客户端可以通过具体的工厂来创建一组相关的产品，实现了一种创建一系列相互关联产品的方式。这有助于实现高内聚、低耦合的设计。

五、三种工厂模式之间的关系

这三种工厂模式（简单工厂模式、工厂方法模式和抽象工厂模式）都是创建型设计模式，旨在解决对象的创建问题。它们之间有一些共同点，但也存在一些差异。下面是它们之间的关系和区别：

共同点：

  • 都关注对象的创建，封装了对象的实例化过程，使客户端代码与具体创建逻辑分离。
  • 都遵循了开闭原则，即可以通过添加新的产品类或工厂类来扩展功能，而无需修改现有代码。

差异：

  • 简单工厂模式：虽然不是严格意义上的设计模式，但它是工厂模式的基础。它通过一个共同的工厂类来创建不同类型的对象，客户端根据参数来指定对象类型。适用于创建单一类别的对象。
  • 工厂方法模式：定义了一个工厂接口，由具体的工厂子类来实现工厂接口并创建特定类型的产品对象。每个工厂只负责创建一种产品。适用于创建一组相关的产品，每个产品有一个对应的工厂。
  • 抽象工厂模式：提供了一种创建一组相关或相互依赖对象的接口，每个具体的工厂子类负责创建一组相关产品。适用于创建一组相互关联的产品，每组产品都有一个对应的工厂。

适用场景：

  • 简单工厂模式适用于创建简单的对象，例如基于传入参数创建对象的情况。
  • 工厂方法模式适用于需要创建多种具有相同接口的产品，而且每种产品都有对应的工厂。
  • 抽象工厂模式适用于创建一组相关或相互依赖的产品，且每组产品都有对应的工厂。

总之，这三种工厂模式都在不同情况下提供了灵活的对象创建机制，可以根据具体的需求来选择合适的模式。简单工厂模式通常是基础，而工厂方法模式和抽象工厂模式则在更复杂的场景下提供更大的灵活性。

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/933765.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

＜C++＞ STL_vector

＜C++＞ STL_vector

1.vector的介绍 vector是表示可变大小数组的序列容器。就像数组一样&#xff0c;vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问&#xff0c;和数组一样高效。但是又不像数组&#xff0c;它的大小是可以动态改变的&#xff0c;而且它的…
阅读更多...
【JavaEE】Spring事务-事务的基本介绍-事务的实现-@Transactional基本介绍和使用

【JavaEE】Spring事务-事务的基本介绍-事务的实现-@Transactional基本介绍和使用

【JavaEE】Spring事务&#xff08;1&#xff09; 文章目录 【JavaEE】Spring事务&#xff08;2&#xff09;1. 为什么要使用事务2. Spring中事务的实现2.1 事务针对哪些操作2.2 MySQL 事务使用2.3 Spring 编程式事务&#xff08;手动挡&#xff09;2.4 Spring 声明式事务&#…
阅读更多...
匈牙利算法 in 二分图匹配

匈牙利算法 in 二分图匹配

https://www.luogu.com.cn/problem/P3386 重新看这个算法&#xff0c;才发现自己没有理解。 左边的点轮流匹配&#xff0c;看是否能匹配成功。对右边的点进行记录是否尝试过 然后有空就进&#xff0c;别人能退的就进 遍历左部点&#xff1a; 尝试匹配过程&#xff1a;
阅读更多...
报错处理：Docker容器无法启动

报错处理：Docker容器无法启动

具体报错&#xff1a; Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"program\": executable file not found in $PATH": unknown. 报错环境&#xff1a; 该报错出现在使用…
阅读更多...
网络编程套接字(2): 简单的UDP网络程序

网络编程套接字(2): 简单的UDP网络程序

文章目录 网络编程套接字(2): 简单的UDP网络程序3. 简单的UDP网络程序3.1 服务端创建(1) 创建套接字(2) 绑定端口号(3) sockaddr_in结构体(4) 数据的接收与发送接收发送 3.2 客户端创建3.3 代码编写(1) v1_简单发送消息(2) v2_小写转大写(3) v3_模拟命令行解释器(4) v4_多线程版…
阅读更多...
软件测试 day3

软件测试 day3

今天目标 执行用例&#xff08;课上案例编写的用例&#xff09; 缺陷相关知识 能够说出软件缺陷判定标准 能够说出项目中缺陷的管理流程 能够使用Excel对于缺陷进行管理 能使用工具管理缺陷一、用例执行 说明&#xff1a;执行结果与用例的期望结果不一致&#xff08;含义&…
阅读更多...
Lingo软件安装包分享（附安装教程）

Lingo软件安装包分享（附安装教程）

目录 一、软件简介 二、软件下载 一、软件简介 Lingo是一款专门为解决线性和非线性优化问题而设计的专业软件&#xff0c;广泛应用于运筹学、工程管理、交通管理、生产调度、物流管理等领域。它提供了一个易于使用的界面和灵活的求解器&#xff0c;能够高效地求解大规模的线性…
阅读更多...
前端需要理解的Vue知识

前端需要理解的Vue知识

1 模板语法 Vue使用基于 HTML 的模板语法&#xff0c;能声明式地将其组件实例的数据绑定到DOM。所有Vue 模板可以被符合规范的浏览器和 HTML 解析器解析。Vue 会将模板编译成高度优化的 JavaScript 代码。结合响应式系统&#xff0c;当应用状态变更时&#xff0c;Vue 能够智能…
阅读更多...
Android 实现资源国际化

Android 实现资源国际化

前言 国际化指的是当Android系统切换语言时&#xff0c;相关设置也随之改变&#xff0c;从而使用不同的国家地区&#xff1b; 简而言之&#xff0c;就是我们的Android App中的文字和图片会随着不同国家的地区变化从而切换为不同语言文字和不同国家的图片 文字图片国际化 只要…
阅读更多...
Python绘图系统9：新建绘图类型控件，实现混合类型图表

Python绘图系统9：新建绘图类型控件，实现混合类型图表

文章目录 绘图类型控件改造AxisList更改绘图逻辑源代码 Python绘图系统&#xff1a; 从0开始实现一个三维绘图系统自定义控件&#xff1a;坐标设置控件&#x1f4c9;坐标列表控件&#x1f4c9;支持多组数据的绘图系统图表类型和风格&#xff1a;散点图和条形图&#x1f4ca;混…
阅读更多...
【已解决】在 SpringBoot 中使用 CloseableHttpClient 调用接口时，接收参数中的中文变为“?“

【已解决】在 SpringBoot 中使用 CloseableHttpClient 调用接口时，接收参数中的中文变为“?“

问题描述 由于项目需要&#xff0c;需要在代码中使用POST请求去调用另一个服务的接口&#xff0c;即不通过前端&#xff0c;A 项目直接在方法中发起HTTP请求调用 B 项目的接口&#xff0c;当请求体中的参数有中文时&#xff0c;参数接收后中文会变为“?”。 具体原因是参数的…
阅读更多...
玩转git第7章节，本地git的用户名和密码的修改

玩转git第7章节，本地git的用户名和密码的修改

一 本地git的用户名和密码 1.1 本地用户名和密码修改 1.本地用户名修改 2.凭据管理 3.进行修改密码 1.2 代码提交操作
阅读更多...
8、Spring_整合Mybatis

8、Spring_整合Mybatis

五、Spring整合Mybatis 1.添加依赖 添加依赖 <dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.17.RELEASE</version></dependency><depend…
阅读更多...
Nuxt.js--》添加路由、视图和过渡效果

Nuxt.js--》添加路由、视图和过渡效果

博主今天开设Nuxt.js专栏&#xff0c;带您深入探索 Nuxt.js 的精髓&#xff0c;学习如何利用其强大功能构建出色的前端应用程序。我们将探讨其核心特点、灵活的路由系统、优化技巧以及常见问题的解决方案。无论您是想了解 Nuxt.js 的基础知识&#xff0c;还是希望掌握进阶技巧&…
阅读更多...
LibreOffice新一代的办公软件for Mac/Windows免费版

LibreOffice新一代的办公软件for Mac/Windows免费版

LibreOffice是一款免费、开源的办公软件套件&#xff0c;可在多个操作系统上运行&#xff0c;包括Windows、Mac和Linux。它提供了一系列功能强大的办公工具&#xff0c;包括文档处理、电子表格、演示文稿、数据库管理等。 LibreOffice的界面简洁直观&#xff0c;与其他流行的办…
阅读更多...
mybatis与spring集成与spring aop集成pagehelper插件

mybatis与spring集成与spring aop集成pagehelper插件

Mybatis与Spring的集成 Mybatis是一款轻量级的ORM框架&#xff0c;而Spring是一个全栈式的框架&#xff0c;二者的结合可以让我们更加高效地进行数据持久化操作。 Mybatis与Spring的集成主要有两种方式&#xff1a;使用Spring的Mybatis支持和使用Mybatis的Spring支持。 使用…
阅读更多...
MySQL学习-day1

MySQL学习-day1

2023.8.26 今天是8月26号&#xff0c;正式开始学习MySQL&#xff0c;看的是尚硅谷的MySQL教程&#xff0c;每天记录一下自己的学习笔记&#xff0c;以供复盘。 数据库的常见概念 1、DB&#xff1a;数据库&#xff0c;存储数据的容器。 2、DBMS&#xff1a;数据…
阅读更多...
kettle实现爬虫

kettle实现爬虫

步骤概览 获取请求 请求地址 东方财富网股票请求 自定义常量数据 获取HTTP请求之前&#xff0c;必须先定义一个URL常量作为HTTP client的输入 HTTP client 注&#xff1a;此处得到的数据并不是原生的json字符串&#xff0c;自己可以用文本文件输出测试以下。如下图 JavaScri…
阅读更多...
Python实现自动登录+获取数据

Python实现自动登录+获取数据

前言 Dy这个东西想必大家都用过&#xff0c;而且还经常刷&#xff0c;今天就来用代码&#xff0c;获取它的视频数据 环境使用 Python 3.8 Pycharm 模块使用 requests selenium json re 一. 数据来源分析 1. 明确需求 明确采集网站以及数据内容 网址: https://www.dy.co…
阅读更多...
PyCharm软件安装包分享（附安装教程）

PyCharm软件安装包分享（附安装教程）

目录 一、软件简介 二、软件下载 一、软件简介 PyCharm是一种集成开发环境&#xff08;IDE&#xff09;&#xff0c;专门为Python开发者设计。它是由捷克软件公司JetBrains开发的&#xff0c;为Python开发人员提供了高效、易用和功能丰富的工具集。 以下是PyCharm软件的主要…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023