设计模式之工厂模式(通俗易懂--代码辅助理解【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。

相关文章

使用Java将DOCX文档解析为Markdown文档的代码实现

使用Java将DOCX文档解析为Markdown文档的代码实现

《使用Java将DOCX文档解析为Markdown文档的代码实现》在现代文档处理中,Markdown（MD）因其简洁的语法和良好的可读性,逐渐成为开发者、技术写作者和内容创作者的首选格式,然而,许多文... 目录引言1. 工具和库介绍2. 安装依赖库3. 使用Apache POI解析DOCX文档4. 将解析
阅读更多...
Java字符串处理全解析(String、StringBuilder与StringBuffer)

Java字符串处理全解析(String、StringBuilder与StringBuffer)

《Java字符串处理全解析(String、StringBuilder与StringBuffer)》：本文主要介绍Java字符串处理全解析(String、StringBuilder与StringBu... 目录Java字符串处理全解析：String、StringBuilder与StringBuffer一、St
阅读更多...
C++使用printf语句实现进制转换的示例代码

C++使用printf语句实现进制转换的示例代码

《C++使用printf语句实现进制转换的示例代码》在C语言中,printf函数可以直接实现部分进制转换功能,通过格式说明符（formatspecifier）快速输出不同进制的数值,下面给大家分享C+... 目录一、printf 原生支持的进制转换1. 十进制、八进制、十六进制转换2. 显示进制前缀3. 指
阅读更多...
springboot整合阿里云百炼DeepSeek实现sse流式打印的操作方法

springboot整合阿里云百炼DeepSeek实现sse流式打印的操作方法

《springboot整合阿里云百炼DeepSeek实现sse流式打印的操作方法》：本文主要介绍springboot整合阿里云百炼DeepSeek实现sse流式打印,本文给大家介绍的非常详细,对大... 目录1.开通阿里云百炼,获取到key2.新建SpringBoot项目3.工具类4.启动类5.测试类6.测
阅读更多...
Spring Boot循环依赖原理、解决方案与最佳实践(全解析)

Spring Boot循环依赖原理、解决方案与最佳实践(全解析)

《SpringBoot循环依赖原理、解决方案与最佳实践(全解析)》循环依赖指两个或多个Bean相互直接或间接引用,形成闭环依赖关系,：本文主要介绍SpringBoot循环依赖原理、解决方案与最... 目录一、循环依赖的本质与危害1.1 什么是循环依赖？1.2 核心危害二、Spring的三级缓存机制2.1 三
阅读更多...
在Spring Boot中浅尝内存泄漏的实战记录

在Spring Boot中浅尝内存泄漏的实战记录

《在SpringBoot中浅尝内存泄漏的实战记录》本文给大家分享在SpringBoot中浅尝内存泄漏的实战记录,结合实例代码给大家介绍的非常详细,感兴趣的朋友一起看看吧... 目录使用静态集合持有对象引用，阻止GC回收关键点：可执行代码：验证：1，运行程序（启动时添加JVM参数限制堆大小）：2，访问 htt
阅读更多...
SpringBoot集成Milvus实现数据增删改查功能

SpringBoot集成Milvus实现数据增删改查功能

《SpringBoot集成Milvus实现数据增删改查功能》milvus支持的语言比较多,支持python,Java,Go,node等开发语言,本文主要介绍如何使用Java语言,采用springboo... 目录1、Milvus基本概念2、添加maven依赖3、配置yml文件4、创建MilvusClient
阅读更多...
浅析Java中如何优雅地处理null值

浅析Java中如何优雅地处理null值

《浅析Java中如何优雅地处理null值》这篇文章主要为大家详细介绍了如何结合Lambda表达式和Optional,让Java更优雅地处理null值,感兴趣的小伙伴可以跟随小编一起学习一下... 目录场景 1：不为 null 则执行场景 2：不为 null 则返回，为 null 则返回特定值或抛出异常场景
阅读更多...
SpringMVC获取请求参数的方法

SpringMVC获取请求参数的方法

《SpringMVC获取请求参数的方法》：本文主要介绍SpringMVC获取请求参数的方法,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下... 目录1、通过ServletAPI获取2、通过控制器方法的形参获取请求参数3、@RequestParam4、@
阅读更多...
SpringBoot应用中出现的Full GC问题的场景与解决

SpringBoot应用中出现的Full GC问题的场景与解决

《SpringBoot应用中出现的FullGC问题的场景与解决》这篇文章主要为大家详细介绍了SpringBoot应用中出现的FullGC问题的场景与解决方法,文中的示例代码讲解详细,感兴趣的小伙伴可... 目录Full GC的原理与触发条件原理触发条件对Spring Boot应用的影响示例代码优化建议结论F
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2