设计模式之工厂模式(通俗易懂--代码辅助理解【Java版】）

2024-09-08 13:28
文章标签 java 代码 设计模式 模式 理解 辅助 工厂 通俗易懂

本文主要是介绍设计模式之工厂模式(通俗易懂--代码辅助理解【Java版】），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

  • 1、工厂模式概述
    • 1）特点：
    • 2）主要角色：
    • 3）工作流程：
    • 4）优点
    • 5）缺点
    • 6）适用场景
  • 2、简单工厂模式(静态工厂模式)
    • 1) 在简单工厂模式中，有三个主要角色：
    • 2) 简单工厂模式的优点包括：
    • 3) 简单工厂模式也有一些限制和考虑因素：
    • 4) 简单工厂模式适用场景：
    • 5) 简单工厂UML类图：
    • 6) 代码示例：
  • 3、工厂方法模式
    • 1) 在工厂方法模式中，有4个主要角色：
    • 2) 工厂方法模式的工作流程：
    • 3) 工厂方法模式适用场景：
    • 4) 工厂方法模式UML类图：
    • 5) 代码示例：
  • 4、抽象工厂模式
    • 1) 在抽象工厂模式中，有4个主要角色：
    • 2) 抽象工厂模式的工作流程：
    • 3) 抽象工厂模式的优点：
    • 4) 抽象工厂模式的缺点：
    • 5) 抽象工厂模式适用场景：
    • 6) 抽象工厂模式UML类图：
    • 7) 代码示例：

1、工厂模式概述

1）特点：

工厂模式（Factory Pattern）是一种创建型设计模式，旨在提供一种统一的方式来创建对象，将对象的实例化过程封装在一个单独的类中。工厂模式通过定义一个公共的接口来创建对象，但允许子类决定实例化哪个类。这样可以将对象的实例化与客户端代码的耦合度降到最低，同时也提供了一种可扩展的方式来创建对象。

2）主要角色：

  • 抽象产品：定义产品的通用接口，具体产品类需要实现该接口。
  • 具体产品：实现抽象产品接口的类，代表实际的产品。
  • 抽象工厂：定义创建产品的接口，可以是抽象类或接口，声明工厂方法。
  • 具体工厂：实现抽象工厂的接口，负责创建具体产品对象。

3）工作流程：

  • 客户端通过抽象工厂请求产品实例。
  • 具体工厂类根据请求创建并返回对应的具体产品。
  • 客户端使用产品实例，而不直接依赖具体产品类。

4）优点

  • 解耦：将对象的创建与使用分离，降低了客户端与具体产品的耦合度。
  • 易扩展：可以通过新增具体产品和工厂，轻松扩展系统而无需修改现有代码。
  • 灵活性：可以动态替换产品实例，提供灵活的对象创建方式。

5）缺点

  • 系统复杂性增加：引入了多个类和接口，增加了系统的复杂度。
  • 代码量增加：添加新产品时，需要创建新的具体产品类和对应的具体工厂类。
  • 类的爆炸性增长：随着产品族增加，具体工厂类的数量可能大幅增长。

6）适用场景

  • 需要统一管理对象创建过程的场景。
  • 系统需要频繁扩展和替换产品类的场景。

2、简单工厂模式(静态工厂模式)

简单工厂模式(Simple Factory Pattern) 是工厂模式的一种简化形式，也被称为静态工厂模式。它通过一个专门的工厂类来创建对象，而无需将对象的实例化过程放在客户端代码中。

1) 在简单工厂模式中，有三个主要角色：

  • 抽象产品（Abstract Product）：定义产品的通用接口，所有具体产品类都应该实现这个接口。
  • 具体产品（Concrete Product）：实现抽象产品接口的具体类。
  • 简单工厂（Simple Factory）：负责创建具体产品的工厂类。它通常包含一个静态方法，根据客户端的请求来创建并返回具体产品的实例。

2) 简单工厂模式的优点包括：

  • 将对象的创建过程集中在一个工厂类中，减少了客户端代码与具体产品的直接耦合。
  • 可以通过简单工厂类的静态方法来创建产品，简化了客户端的调用代码。
  • 可以轻松添加新的产品，只需修改简单工厂类的创建方法，而无需修改客户端代码。

3) 简单工厂模式也有一些限制和考虑因素：

  • 工厂类负责创建所有产品，当产品种类较多时，工厂类的代码可能会变得复杂。
  • 添加新产品时，需要修改工厂类的代码，违反了开闭原则。

4) 简单工厂模式适用场景：

  • 简单工厂模式适用于需要根据客户端请求来创建不同类型对象的场景，但产品种类较少且不经常变化的情况。它提供了一种简单的方式来封装对象的创建过程，降低了客户端代码与具体产品的耦合度。

5) 简单工厂UML类图：

在这里插入图片描述

6) 代码示例：

// 抽象产品类
abstract class Product {public abstract void use();
}// 具体产品类A
class ConcreteProductA extends Product {@Overridepublic void use() {System.out.println("Using ConcreteProductA");}
}// 具体产品类B
class ConcreteProductB extends Product {@Overridepublic void use() {System.out.println("Using ConcreteProductB");}
}// 简单工厂类
class SimpleFactory {public Product createProduct(String type) {if (type.equals("A")) {return new ConcreteProductA();} else if (type.equals("B")) {return new ConcreteProductB();} else {// 处理未知产品类型的情况return null;}}
}public class Main {public static void main(String[] args) {// 使用简单工厂创建产品SimpleFactory factory = new SimpleFactory();Product productA = factory.createProduct("A");if (productA != null) {productA.use();}Product productB = factory.createProduct("B");if (productB != null) {productB.use();}Product unknownProduct = factory.createProduct("C");if (unknownProduct == null) {System.out.println("Unknown product type.");}}
}

3、工厂方法模式

工厂方法模式（Factory Method Pattern） 是一种创建型设计模式，它提供了一种将对象的创建委托给子类的方式。在工厂方法模式中，定义一个用于创建对象的接口，但让子类决定实例化哪个类。这样可以将对象的创建与使用解耦，使得系统在不修改具体产品类的情况下可以引入新的产品。

1) 在工厂方法模式中，有4个主要角色：

  • 抽象产品（Abstract Product）：定义产品的通用接口，所有具体产品类都应该实现这个接口。
  • 具体产品（Concrete Product）：实现抽象产品接口的具体类，是工厂方法模式所创建的对象。
  • 抽象工厂（Factory）：定义了工厂方法的接口，负责创建抽象产品的对象。
  • 具体工厂（Concrete Factory）：实现了抽象工厂接口，具体工厂类根据具体业务逻辑，创建具体产品的对象。

2) 工厂方法模式的工作流程：

  • 客户端通过调用具体工厂类的工厂方法来创建产品对象。
  • 具体工厂类根据客户端的请求，调用具体产品类的构造方法创建具体产品对象。
  • 具体工厂类将创建的具体产品对象返回给客户端。

通过工厂方法模式，客户端与具体产品类解耦，客户端只需关心抽象产品和抽象工厂，具体产品的创建由具体工厂类来完成。这样，当需要引入新的产品时，只需创建一个新的具体产品类和对应的具体工厂类，而不需要修改客户端代码。

3) 工厂方法模式适用场景：

  • 当一个类无法预知它需要创建的对象的具体类时，可以使用工厂方法模式。
  • 当一个类希望将对象的创建责任委托给多个子类中的某一个时，可以使用工厂方法模式。
  • 当一个类需要通过其子类来指定创建对象时，可以使用工厂方法模式。

总结来说，工厂方法模式通过定义一个创建对象的接口，将对象的实例化延迟到子类中去完成，实现了对象的创建与使用的解耦，提高了系统的可扩展性和灵活性。

4) 工厂方法模式UML类图：

在这里插入图片描述

5) 代码示例：

// 抽象产品类
abstract class Product {// 抽象方法public abstract void use();
}// 具体产品类A
class ConcreteProductA extends Product {@Overridepublic void use() {System.out.println("Using ConcreteProductA");}
}// 具体产品类B
class ConcreteProductB extends Product {@Overridepublic void use() {System.out.println("Using ConcreteProductB");}
}// 抽象工厂类
abstract class Factory {// 抽象工厂方法public abstract Product createProduct();// 打印产品使用信息public void print() {Product product = createProduct();product.use();}
}// 具体工厂类A
class ConcreteFactoryA extends Factory {@Overridepublic Product createProduct() {return new ConcreteProductA();}
}// 具体工厂类B
class ConcreteFactoryB extends Factory {@Overridepublic Product createProduct() {return new ConcreteProductB();}
}public class Main {public static void main(String[] args) {// 使用工厂类创建产品Factory factoryA = new ConcreteFactoryA();factoryA.print();Factory factoryB = new ConcreteFactoryB();factoryB.print();}
}
运行结果
Using ConcreteProductA
Using ConcreteProductB

4、抽象工厂模式

抽象工厂模式（Abstract Factory Pattern） 是一种创建型设计模式，旨在提供一种统一的方式来创建一系列相关或相互依赖的对象，而无需指定具体的类。它通过定义一个抽象工厂接口和一组具体工厂类，来创建一族产品对象。

1) 在抽象工厂模式中，有4个主要角色：

  • 抽象工厂（Abstract Product）：定义了创建一族产品对象的接口。它通常包含一组用于创建不同产品的工厂方法。
  • 具体工厂（Concrete Product）：实现了抽象工厂接口，负责创建具体的产品对象。
  • 抽象产品（Factory）：定义了一族产品对象的通用接口。具体产品类应实现这个接口。
  • 具体产品（Concrete Factory）：实现了抽象产品接口，是由具体工厂创建的对象。

2) 抽象工厂模式的工作流程：

  • 客户端通过抽象工厂接口来创建一族相关的产品对象。
  • 具体工厂类实现了抽象工厂接口，负责创建具体的产品对象。
  • 抽象工厂的工厂方法根据具体工厂的实现，创建并返回具体产品的实例。
  • 客户端使用返回的产品实例进行操作，而无需关心具体产品的实现细节。

3) 抽象工厂模式的优点：

  • 将对象的创建和使用分离，降低了客户端代码与具体产品的耦合度。
  • 提供了一种可替换的方式来创建一族相关产品，使得系统更加灵活和可维护。
  • 符合开闭原则，可以轻松添加新的具体工厂和产品类，扩展系统功能。

4) 抽象工厂模式的缺点：

  • 当产品族的数量增加时，抽象工厂和具体工厂的接口可能变得复杂，需要谨慎设计和管理。
  • 添加新的产品族可能需要修改抽象工厂和所有具体工厂的代码，违反了开闭原则。

5) 抽象工厂模式适用场景：

抽象工厂模式适用于需要创建一族相关产品对象的场景，其中产品之间存在一定的关联或依赖关系。它提供了一种统一的方式来管理产品的创建过程，将对象的创建与客户端代码解耦，同时也支持动态替换和扩展对象的创建。

6) 抽象工厂模式UML类图：

在这里插入图片描述

7) 代码示例：

// 抽象产品A
interface AbstractProductA {void use();
}// 具体产品A1
class ConcreteProductA1 implements AbstractProductA {@Overridepublic void use() {System.out.println("Using ConcreteProductA1");}
}// 具体产品A2
class ConcreteProductA2 implements AbstractProductA {@Overridepublic void use() {System.out.println("Using ConcreteProductA2");}
}// 抽象产品B
interface AbstractProductB {void eat();
}// 具体产品B1
class ConcreteProductB1 implements AbstractProductB {@Overridepublic void eat() {System.out.println("Eating ConcreteProductB1");}
}// 具体产品B2
class ConcreteProductB2 implements AbstractProductB {@Overridepublic void eat() {System.out.println("Eating ConcreteProductB2");}
}// 抽象工厂
interface AbstractFactory {AbstractProductA createProductA();AbstractProductB createProductB();
}// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {@Overridepublic AbstractProductA createProductA() {return new ConcreteProductA1();}@Overridepublic AbstractProductB createProductB() {return new ConcreteProductB1();}
}// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {@Overridepublic AbstractProductA createProductA() {return new ConcreteProductA2();}@Overridepublic AbstractProductB createProductB() {return new ConcreteProductB2();}
}// 主程序
public class Main {public static void main(String[] args) {// 使用具体工厂1创建产品族1AbstractFactory factory1 = new ConcreteFactory1();AbstractProductA productA1 = factory1.createProductA();AbstractProductB productB1 = factory1.createProductB();productA1.use();productB1.eat();// 使用具体工厂2创建产品族2AbstractFactory factory2 = new ConcreteFactory2();AbstractProductA productA2 = factory2.createProductA();AbstractProductB productB2 = factory2.createProductB();productA2.use();productB2.eat();}
}
运行结果
Using ConcreteProductA1
Eating ConcreteProductB1
Using ConcreteProductA2
Eating ConcreteProductB2

这篇关于设计模式之工厂模式(通俗易懂--代码辅助理解【Java版】）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1148238。

相关文章

Spring Cloud LoadBalancer 负载均衡详解

Spring Cloud LoadBalancer 负载均衡详解

《SpringCloudLoadBalancer负载均衡详解》本文介绍了如何在SpringCloud中使用SpringCloudLoadBalancer实现客户端负载均衡,并详细讲解了轮询策略和... 目录1. 在 idea 上运行多个服务2. 问题引入3. 负载均衡4. Spring Cloud Load
阅读更多...
Springboot中分析SQL性能的两种方式详解

Springboot中分析SQL性能的两种方式详解

《Springboot中分析SQL性能的两种方式详解》文章介绍了SQL性能分析的两种方式：MyBatis-Plus性能分析插件和p6spy框架,MyBatis-Plus插件配置简单,适用于开发和测试环... 目录SQL性能分析的两种方式:功能介绍实现方式:实现步骤:SQL性能分析的两种方式:功能介绍记录
阅读更多...
在 Spring Boot 中使用 @Autowired和 @Bean注解的示例详解

在 Spring Boot 中使用 @Autowired和 @Bean注解的示例详解

《在SpringBoot中使用@Autowired和@Bean注解的示例详解》本文通过一个示例演示了如何在SpringBoot中使用@Autowired和@Bean注解进行依赖注入和Bean... 目录在 Spring Boot 中使用 @Autowired 和 @Bean 注解示例背景1. 定义 Stud
阅读更多...
使用 sql-research-assistant进行 SQL 数据库研究的实战指南(代码实现演示)

使用 sql-research-assistant进行 SQL 数据库研究的实战指南(代码实现演示)

《使用sql-research-assistant进行SQL数据库研究的实战指南(代码实现演示)》本文介绍了sql-research-assistant工具,该工具基于LangChain框架,集... 目录技术背景介绍核心原理解析代码实现演示安装和配置项目集成LangSmith 配置（可选）启动服务应用场景
阅读更多...
如何通过海康威视设备网络SDK进行Java二次开发摄像头车牌识别详解

如何通过海康威视设备网络SDK进行Java二次开发摄像头车牌识别详解

《如何通过海康威视设备网络SDK进行Java二次开发摄像头车牌识别详解》：本文主要介绍如何通过海康威视设备网络SDK进行Java二次开发摄像头车牌识别的相关资料,描述了如何使用海康威视设备网络SD... 目录前言开发流程问题和解决方案dll库加载不到的问题老旧版本sdk不兼容的问题关键实现流程总结前言作为
阅读更多...
SpringBoot中使用 ThreadLocal 进行多线程上下文管理及注意事项小结

SpringBoot中使用 ThreadLocal 进行多线程上下文管理及注意事项小结

《SpringBoot中使用ThreadLocal进行多线程上下文管理及注意事项小结》本文详细介绍了ThreadLocal的原理、使用场景和示例代码,并在SpringBoot中使用ThreadLo... 目录前言技术积累1.什么是 ThreadLocal2. ThreadLocal 的原理2.1 线程隔离2
阅读更多...
Python中顺序结构和循环结构示例代码

Python中顺序结构和循环结构示例代码

《Python中顺序结构和循环结构示例代码》：本文主要介绍Python中的条件语句和循环语句,条件语句用于根据条件执行不同的代码块,循环语句用于重复执行一段代码,文章还详细说明了range函数的使... 目录一、条件语句（1）条件语句的定义（2）条件语句的语法（a）单分支 if（b）双分支 if-else（
阅读更多...
springboot将lib和jar分离的操作方法

springboot将lib和jar分离的操作方法

《springboot将lib和jar分离的操作方法》本文介绍了如何通过优化pom.xml配置来减小SpringBoot项目的jar包大小,主要通过使用spring-boot-maven-plugin... 遇到一个问题，就是每次maven package或者maven install后target中的ja
阅读更多...
Java中八大包装类举例详解(通俗易懂)

Java中八大包装类举例详解(通俗易懂)

《Java中八大包装类举例详解(通俗易懂)》：本文主要介绍Java中的包装类,包括它们的作用、特点、用途以及如何进行装箱和拆箱,包装类还提供了许多实用方法,如转换、获取基本类型值、比较和类型检测,... 目录一、包装类（Wrapper Class）1、简要介绍2、包装类特点3、包装类用途二、装箱和拆箱1、装
阅读更多...
如何利用Java获取当天的开始和结束时间

如何利用Java获取当天的开始和结束时间

《如何利用Java获取当天的开始和结束时间》：本文主要介绍如何使用Java8的LocalDate和LocalDateTime类获取指定日期的开始和结束时间,展示了如何通过这些类进行日期和时间的处... 目录前言1. Java日期时间API概述2. 获取当天的开始和结束时间代码解析运行结果3. 总结前言在J
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2