设计模式之工厂模式(通俗易懂--代码辅助理解【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 实用工具类Spring 的 AnnotationUtils详解

Java 实用工具类Spring 的 AnnotationUtils详解

《Java实用工具类Spring的AnnotationUtils详解》Spring框架提供了一个强大的注解工具类org.springframework.core.annotation.Annot... 目录前言一、AnnotationUtils 的常用方法二、常见应用场景三、与 JDK 原生注解 API 的
阅读更多...
Java controller接口出入参时间序列化转换操作方法(两种)

Java controller接口出入参时间序列化转换操作方法(两种)

《Javacontroller接口出入参时间序列化转换操作方法(两种)》：本文主要介绍Javacontroller接口出入参时间序列化转换操作方法,本文给大家列举两种简单方法,感兴趣的朋友一起看... 目录方式一、使用注解方式二、统一配置场景：在controller编写的接口，在前后端交互过程中一般都会涉及
阅读更多...
Java中的StringBuilder之如何高效构建字符串

Java中的StringBuilder之如何高效构建字符串

《Java中的StringBuilder之如何高效构建字符串》本文将深入浅出地介绍StringBuilder的使用方法、性能优势以及相关字符串处理技术,结合代码示例帮助读者更好地理解和应用,希望对大家... 目录关键点什么是 StringBuilder？为什么需要 StringBuilder？如何使用 St
阅读更多...
使用Java将各种数据写入Excel表格的操作示例

使用Java将各种数据写入Excel表格的操作示例

《使用Java将各种数据写入Excel表格的操作示例》在数据处理与管理领域,Excel凭借其强大的功能和广泛的应用,成为了数据存储与展示的重要工具,在Java开发过程中,常常需要将不同类型的数据,本文... 目录前言安装免费Java库1. 写入文本、或数值到 Excel单元格2. 写入数组到 Excel表格
阅读更多...
Java并发编程之如何优雅关闭钩子Shutdown Hook

Java并发编程之如何优雅关闭钩子Shutdown Hook

《Java并发编程之如何优雅关闭钩子ShutdownHook》这篇文章主要为大家详细介绍了Java如何实现优雅关闭钩子ShutdownHook,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起... 目录关闭钩子简介关闭钩子应用场景数据库连接实战演示使用关闭钩子的注意事项开源框架中的关闭钩子机制1.
阅读更多...
Maven中引入 springboot 相关依赖的方式(最新推荐)

Maven中引入 springboot 相关依赖的方式(最新推荐)

《Maven中引入springboot相关依赖的方式(最新推荐)》：本文主要介绍Maven中引入springboot相关依赖的方式(最新推荐),本文给大家介绍的非常详细,对大家的学习或工作具有... 目录Maven中引入 springboot 相关依赖的方式1. 不使用版本管理（不推荐）2、使用版本管理（推
阅读更多...
Java 中的 @SneakyThrows 注解使用方法(简化异常处理的利与弊)

Java 中的 @SneakyThrows 注解使用方法(简化异常处理的利与弊)

《Java中的@SneakyThrows注解使用方法(简化异常处理的利与弊)》为了简化异常处理,Lombok提供了一个强大的注解@SneakyThrows,本文将详细介绍@SneakyThro... 目录1. @SneakyThrows 简介 1.1 什么是 Lombok？2. @SneakyThrows
阅读更多...
在 Spring Boot 中实现异常处理最佳实践

在 Spring Boot 中实现异常处理最佳实践

《在SpringBoot中实现异常处理最佳实践》本文介绍如何在SpringBoot中实现异常处理,涵盖核心概念、实现方法、与先前查询的集成、性能分析、常见问题和最佳实践,感兴趣的朋友一起看看吧... 目录一、Spring Boot 异常处理的背景与核心概念1.1 为什么需要异常处理？1.2 Spring B
阅读更多...
如何在 Spring Boot 中实现 FreeMarker 模板

如何在 Spring Boot 中实现 FreeMarker 模板

《如何在SpringBoot中实现FreeMarker模板》FreeMarker是一种功能强大、轻量级的模板引擎,用于在Java应用中生成动态文本输出（如HTML、XML、邮件内容等）,本文... 目录什么是 FreeMarker 模板？在 Spring Boot 中实现 FreeMarker 模板1. 环
阅读更多...
SpringMVC 通过ajax 前后端数据交互的实现方法

SpringMVC 通过ajax 前后端数据交互的实现方法

《SpringMVC通过ajax前后端数据交互的实现方法》：本文主要介绍SpringMVC通过ajax前后端数据交互的实现方法,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价... 在前端的开发过程中，经常在html页面通过AJAX进行前后端数据的交互，SpringMVC的controll
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2