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

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
认识、理解、分类——acm之搜索

认识、理解、分类——acm之搜索

普通搜索方法有两种：1、广度优先搜索；2、深度优先搜索； 更多搜索方法： 3、双向广度优先搜索； 4、启发式搜索（包括A*算法等）； 搜索通常会用到的知识点：状态压缩（位压缩，利用hash思想压缩）。
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟 开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚 第一站：海量资源，应有尽有 走进“智听
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2