首页 > 其他分享 >工厂设计模式：深入解析与应用

工厂设计模式：深入解析与应用

时间：2024-08-18 19:24:59浏览次数：9  
标签：Product 解析 具体 工厂 深入 产品 抽象 设计模式 public

工厂设计模式：深入解析与应用

在软件开发领域，设计模式是解决常见问题的最佳实践。工厂设计模式（Factory Design Pattern）作为一种创建型设计模式，提供了一种创建对象的接口，但由子类决定要实例化的类是哪一个。本文将深入探讨工厂设计模式的定义、分类、实现方式、优缺点以及应用场景，并附上详细的代码示例和注释，帮助读者全面理解并掌握这一重要的设计模式。

一、工厂设计模式概述

1.1 什么是工厂设计模式？

工厂设计模式是一种创建型设计模式，它提供了一种创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类。

1.2 工厂设计模式的分类

工厂设计模式主要分为三种：

  • 简单工厂模式（Simple Factory Pattern）
  • 工厂方法模式（Factory Method Pattern）
  • 抽象工厂模式（Abstract Factory Pattern）

二、简单工厂模式

2.1 定义与特点

简单工厂模式不属于23种GOF设计模式之一，但它是最简单的工厂模式，常用于创建单一产品。简单工厂模式通过一个工厂类来创建不同类型的对象，客户端无需知道具体的创建细节。

2.2 实现方式

简单工厂模式包含以下几个角色：

  • 工厂类（Factory Class）：负责创建对象的类。
  • 抽象产品类（Abstract Product Class）：定义产品的接口。
  • 具体产品类（Concrete Product Class）：实现抽象产品接口的具体类。

2.3 代码示例

抽象产品类：
// 抽象产品类
public interface Product {
    void use();
}
具体产品类：
// 具体产品类A
public class ProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

// 具体产品类B
public class ProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}
工厂类：
// 工厂类
public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ProductA();
        } else if ("B".equals(type)) {
            return new ProductB();
        } else {
            throw new IllegalArgumentException("Unknown product type");
        }
    }
}
客户端代码：
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();

        Product productB = SimpleFactory.createProduct("B");
        productB.use();
    }
}

2.4 代码注释

  • Product：抽象产品接口，定义产品的使用方法。
  • ProductA和ProductB：具体产品类，实现抽象产品接口。
  • SimpleFactory：工厂类，根据传入的类型创建不同的产品实例。
  • Client：客户端代码，通过工厂类创建产品并使用。

2.5 优缺点

优点：
  • 客户端无需知道具体的创建细节，只需通过工厂类获取产品。
  • 集中管理对象的创建逻辑，便于维护和扩展。
缺点：
  • 工厂类集中了所有产品的创建逻辑，违反了单一职责原则。
  • 增加新产品时需要修改工厂类，违反了开闭原则。

三、工厂方法模式

3.1 定义与特点

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类。

3.2 实现方式

工厂方法模式包含以下几个角色：

  • 抽象工厂类（Abstract Factory Class）：定义创建产品的接口。
  • 具体工厂类（Concrete Factory Class）：实现抽象工厂接口，创建具体产品。
  • 抽象产品类（Abstract Product Class）：定义产品的接口。
  • 具体产品类（Concrete Product Class）：实现抽象产品接口的具体类。

3.3 代码示例

抽象产品类：
// 抽象产品类
public interface Product {
    void use();
}
具体产品类：
// 具体产品类A
public class ProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

// 具体产品类B
public class ProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}
抽象工厂类：
// 抽象工厂类
public interface Factory {
    Product createProduct();
}
具体工厂类：
// 具体工厂类A
public class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

// 具体工厂类B
public class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}
客户端代码：
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.use();

        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

3.4 代码注释

  • Product：抽象产品接口，定义产品的使用方法。
  • ProductA和ProductB：具体产品类，实现抽象产品接口。
  • Factory：抽象工厂接口，定义创建产品的接口。
  • FactoryA和FactoryB：具体工厂类，实现抽象工厂接口，创建具体产品。
  • Client：客户端代码，通过具体工厂类创建产品并使用。

3.5 优缺点

优点：
  • 符合开闭原则，增加新产品时只需增加新的具体工厂类和产品类，无需修改现有代码。
  • 符合单一职责原则，每个具体工厂类只负责创建一种产品。
缺点：
  • 增加了类的数量，增加了系统的复杂度。
  • 客户端需要知道具体的工厂类，增加了客户端的复杂度。

四、抽象工厂模式

4.1 定义与特点

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式适用于创建一组相关的产品族。

4.2 实现方式

抽象工厂模式包含以下几个角色：

  • 抽象工厂类（Abstract Factory Class）：定义创建一组产品的接口。
  • 具体工厂类（Concrete Factory Class）：实现抽象工厂接口，创建一组具体产品。
  • 抽象产品类（Abstract Product Class）：定义产品的接口。
  • 具体产品类（Concrete Product Class）：实现抽象产品接口的具体类。

4.3 代码示例

抽象产品类：
// 抽象产品类A
public interface ProductA {
    void useA();
}

// 抽象产品类B
public interface ProductB {
    void useB();
}
具体产品类：
// 具体产品类A1
public class ProductA1 implements ProductA {
    @Override
    public void useA() {
        System.out.println("Using Product A1");
    }
}

// 具体产品类A2
public class ProductA2 implements ProductA {
    @Override
    public void useA() {
        System.out.println("Using Product A2");
    }
}

// 具体产品类B1
public class ProductB1 implements ProductB {
    @Override
    public void useB() {
        System.out.println("Using Product B1");
    }
}

// 具体产品类B2
public class ProductB2 implements ProductB {
    @Override
    public void useB() {
        System.out.println("Using Product B2");
    }
}
抽象工厂类：
// 抽象工厂类
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}
具体工厂类：
// 具体工厂类1
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂类2
public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}
客户端代码：
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.useA();
        productB1.useB();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.useA();
        productB2.useB();
    }
}

4.4 代码注释

  • ProductA和ProductB：抽象产品接口，定义产品的使用方法。
  • ProductA1、ProductA2、ProductB1和ProductB2：具体产品类，实现抽象产品接口。
  • AbstractFactory：抽象工厂接口，定义创建一组产品的接口。
  • ConcreteFactory1和ConcreteFactory2：具体工厂类，实现抽象工厂接口，创建一组具体产品。
  • Client：客户端代码，通过具体工厂类创建产品并使用。

4.5 优缺点

优点：
  • 符合开闭原则，增加新产品族时只需增加新的具体工厂类和产品类，无需修改现有代码。
  • 符合单一职责原则，每个具体工厂类只负责创建一组相关的产品。
缺点：
  • 增加了类的数量，增加了系统的复杂度。
  • 客户端需要知道具体的工厂类，增加了客户端的复杂度。

五、应用场景

5.1 简单工厂模式的应用场景

  • 创建对象的逻辑简单，且不经常变化。
  • 客户端不需要知道具体的创建细节。

5.2 工厂方法模式的应用场景

  • 创建对象的逻辑复杂，且需要灵活扩展。
  • 符合开闭原则，便于维护和扩展。

5.3 抽象工厂模式的应用场景

  • 需要创建一组相关的产品族。
  • 符合开闭原则，便于维护和扩展。

六、总结

工厂设计模式作为一种创建型设计模式，提供了多种创建对象的方式，包括简单工厂模式、工厂方法模式和抽象工厂模式。通过合理选择和应用这些模式，开发者可以提高代码的灵活性、可维护性和可扩展性。本文详细讲解了工厂设计模式的定义、分类、实现方式、优缺点以及应用场景，并附上了详细的代码示例和注释，帮助读者全面理解并掌握这一重要的设计模式。

在当今快速变化的软件开发领域，设计模式将继续发挥其重要作用，引领开发者构建高效、可维护的软件系统。无论是传统的三层架构，还是现代的微服务架构、云原生应用，工厂设计模式都将是开发者不可或缺的利器。

标签：Product,解析,具体,工厂,深入,产品,抽象,设计模式,public
From： https://blog.csdn.net/xycxycooo/article/details/141137923

相关文章

  • Spring中的循环依赖：深入解析与解决方案
    Spring中的循环依赖：深入解析与解决方案在Spring框架中，循环依赖（CircularDependency）是一个常见的问题，它发生在两个或多个Bean之间相互依赖，形成一个闭环。循环依赖可能导致应用启动失败、Bean创建失败等问题，影响应用的正常运行。本文将深入探讨Spring中循环依赖的产生原因、......
  • 【项目】多设计模式下的同步&&异步日志系统（二）
    继上文对日志系统的介绍，并且实现了日志等级、日志消息的定义、以及格式化消息等。由这三个模块就能完整的输出一条消息。但是考虑到日志消息不可能全部都通过显示器展示。本项目针对落地方式，也进行多种编写，以供使用。消息落地类(简单工厂模式)消息落地的方式标准输出文件按......
  • 【项目】多设计模式下的同步&&异步日志系统（三）
    继前俩次完成了日志系统的等级类、消息结构以及格式化消息，并且将格式化的数据实现落地。落地存在同步和异步的落地方式。同步：本线程生成消息，并且进行IO写。异步：线程生成消息，交给子线程写。为此实现了双缓冲区用来减少异步带来的频繁申请锁释放锁减低效率。本文继续实现异步......
  • Ubuntu无法解析域名DNS指向127.0.0.53问题处理
    首次尝试编辑/etc/resolved.conf文件DNS为114.114.114.114发现reboot重启后又恢复到127.0.0.53的内容再次尝试修改文件vi/etc/systemd/resolved.conf 在其中添加dns信息DNS=114.114.114.114保存退出依次执行重启解析服务systemctlrestartsystemd-resolved设置解析服务......
  • 【重学c++primer】第五章第二节 深入浅出：左值和右值
    文章目录左值右值传统的左值和右值划分glvalueprvaluexvalue总结左值和右值的转换左值转右值decltype左值右值传统的左值和右值划分左值：英文为leftvalue，简写lvalue右值：英文为rightvalue，简写rvalue一个左一个右，这个左右的判定是针对什么呢？实际上是针对等......
  • 如何快速将地址解析为经纬度坐标？
    GIS数据转换器的"地址转坐标"功能，可以帮助用户将地址文本快速转换为对应的经纬度坐标，广泛应用于地图定位、数据分析、GIS项目、在线导航、城市规划、紧急服务以及科学研究等多个领域，极大地提高了地理信息处理的效率和准确性。下面是详细的使用步骤：方法/步骤1. ......
  • 【OpenHarmony4.1 之 U-Boot 2024.07源码深度解析】019 - RK3568 Uboot 完整流程梳理
    【OpenHarmony4.1之U-Boot2024.07源码深度解析】019-RK3568Uboot完整流程梳理一、系统环境初始化：_start入口地址，初始化CPU环境二、系统环境初始化：_main入口，初始化堆栈，初始化gd全局环境变量，初始化CRuntime运行环境，开始执行board_init_f函数三、board_......
  • AI语言大模型商业价值深度解析
    点击蓝字关注我随着人工智能（AI）技术的飞速发展，特别是深度学习算法的进步，AI语言大模型在自然语言处理领域的表现日益突出。国内外多种语言大模型如：OpenAi的ChatGpt，阿里通义千问，百度文心一言，科大讯飞星火大模型等等纷纷推出相关应用以及算力服务。这些模型通过大规......
  • 设计模式六大原则之：开闭原则
    1.开闭原则简介开闭原则（OpenClosedPrinciple,OCP）‌是面向对象程序设计（OOP）中的一个基本原则，也是软件工程中的一项重要原则。它的核心思想是：一个软件实体（如类、模块或函数）应该对扩展开放，即当需求变化时，可以通过添加新的代码进行扩展来满足新的需求，而不需要修改现有的代码。......
  • 深入理解JVM运行时数据区（内存布局 ）5大部分 | 异常讨论
    前言：    JVM运行时数据区（内存布局）是Java程序执行时用于存储各种数据的内存区域。这些区域在JVM启动时被创建，并在JVM关闭时销毁。它们的布局和管理方式对Java程序的性能和稳定性有着重要影响。  一、由以下5大部分组成1.Heap堆区（线程共享）概念：堆是JVM中最大......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99