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

2024-09-08 13:28

本文主要是介绍设计模式之工厂模式(通俗易懂--代码辅助理解【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

相关文章

在C#中调用Python代码的两种实现方式

《在C#中调用Python代码的两种实现方式》:本文主要介绍在C#中调用Python代码的两种实现方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录C#调用python代码的方式1. 使用 Python.NET2. 使用外部进程调用 Python 脚本总结C#调

springboot报错Invalid bound statement (not found)的解决

《springboot报错Invalidboundstatement(notfound)的解决》本文主要介绍了springboot报错Invalidboundstatement(not... 目录一. 问题描述二.解决问题三. 添加配置项 四.其他的解决方案4.1 Mapper 接口与 XML 文件不匹配

MySQL新增字段后Java实体未更新的潜在问题与解决方案

《MySQL新增字段后Java实体未更新的潜在问题与解决方案》在Java+MySQL的开发中,我们通常使用ORM框架来映射数据库表与Java对象,但有时候,数据库表结构变更(如新增字段)后,开发人员可... 目录引言1. 问题背景:数据库与 Java 实体不同步1.1 常见场景1.2 示例代码2. 不同操作

SpringBoot使用OkHttp完成高效网络请求详解

《SpringBoot使用OkHttp完成高效网络请求详解》OkHttp是一个高效的HTTP客户端,支持同步和异步请求,且具备自动处理cookie、缓存和连接池等高级功能,下面我们来看看SpringB... 目录一、OkHttp 简介二、在 Spring Boot 中集成 OkHttp三、封装 OkHttp

JavaScript错误处理避坑指南

《JavaScript错误处理避坑指南》JavaScript错误处理是编程过程中不可避免的部分,它涉及到识别、捕获和响应代码运行时可能出现的问题,本文将详细给大家介绍一下JavaScript错误处理的... 目录一、错误类型:三大“杀手”与应对策略1. 语法错误(SyntaxError)2. 运行时错误(R

SpringBoot如何通过Map实现策略模式

《SpringBoot如何通过Map实现策略模式》策略模式是一种行为设计模式,它允许在运行时选择算法的行为,在Spring框架中,我们可以利用@Resource注解和Map集合来优雅地实现策略模式,这... 目录前言底层机制解析Spring的集合类型自动装配@Resource注解的行为实现原理使用直接使用M

JavaScript Array.from及其相关用法详解(示例演示)

《JavaScriptArray.from及其相关用法详解(示例演示)》Array.from方法是ES6引入的一个静态方法,用于从类数组对象或可迭代对象创建一个新的数组实例,本文将详细介绍Array... 目录一、Array.from 方法概述1. 方法介绍2. 示例演示二、结合实际场景的使用1. 初始化二

Spring Boot 整合 MyBatis 连接数据库及常见问题

《SpringBoot整合MyBatis连接数据库及常见问题》MyBatis是一个优秀的持久层框架,支持定制化SQL、存储过程以及高级映射,下面详细介绍如何在SpringBoot项目中整合My... 目录一、基本配置1. 添加依赖2. 配置数据库连接二、项目结构三、核心组件实现(示例)1. 实体类2. Ma

Java时间轮调度算法的代码实现

《Java时间轮调度算法的代码实现》时间轮是一种高效的定时调度算法,主要用于管理延时任务或周期性任务,它通过一个环形数组(时间轮)和指针来实现,将大量定时任务分摊到固定的时间槽中,极大地降低了时间复杂... 目录1、简述2、时间轮的原理3. 时间轮的实现步骤3.1 定义时间槽3.2 定义时间轮3.3 使用时

Java 中实现异步的多种方式

《Java中实现异步的多种方式》文章介绍了Java中实现异步处理的几种常见方式,每种方式都有其特点和适用场景,通过选择合适的异步处理方式,可以提高程序的性能和可维护性,感兴趣的朋友一起看看吧... 目录1. 线程池(ExecutorService)2. CompletableFuture3. ForkJoi