【软件设计】常用设计模式--工厂模式

于 2024-09-05 15:18:25 发布
阅读量936 收藏 9
点赞数 3
分类专栏： 软件设计 文章标签： 设计模式 软件设计 工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41488033/article/details/141931848
版权

软件设计模式（二）

一、工厂模式（Factory Pattern）

1. 概念

工厂模式通过定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂模式让一个类的实例化延迟到子类进行，从而实现代码的松耦合和扩展性。

2. 工厂模式的类型

工厂模式有几种不同的实现方式：

  • 简单工厂模式（Simple Factory）: 使用一个工厂类根据传递的参数决定创建哪个具体类的实例。
  • 工厂方法模式（Factory Method）: 定义一个创建对象的接口，让子类决定具体实例化哪个类。
  • 抽象工厂模式（Abstract Factory）: 提供一个接口，用于创建一系列相关或互相依赖的对象，而无需指定它们具体的类。

3. 实现方式

我们先从最基础的简单工厂模式开始，然后逐步介绍工厂方法模式和抽象工厂模式。

（1）简单工厂模式

简单工厂模式通常使用一个静态方法来根据传入的参数创建不同的对象。

C# 实现
public abstract class Product
{
    public abstract void DoSomething();
}

public class ConcreteProductA : Product
{
    public override void DoSomething()
    {
        Console.WriteLine("Product A is doing something.");
    }
}

public class ConcreteProductB : Product
{
    public override void DoSomething()
    {
        Console.WriteLine("Product B is doing something.");
    }
}

public class ProductFactory
{
    public static Product CreateProduct(string type)
    {
        switch (type)
        {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new ArgumentException("Invalid product type.");
        }
    }
}
  • 使用方法: Product product = ProductFactory.CreateProduct("A");
Java 实现
abstract class Product {
    abstract void doSomething();
}

class ConcreteProductA extends Product {
    @Override
    void doSomething() {
        System.out.println("Product A is doing something.");
    }
}

class ConcreteProductB extends Product {
    @Override
    void doSomething() {
        System.out.println("Product B is doing something.");
    }
}

class ProductFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new IllegalArgumentException("Invalid product type.");
        }
    }
}

使用方法: Product product = ProductFactory.createProduct("A");

（2）工厂方法模式

在工厂方法模式中，创建对象的逻辑被推迟到子类中，而不是集中在一个工厂类中。

C# 实现
public abstract class Product
{
    public abstract void DoSomething();
}

public class ConcreteProductA : Product
{
    public override void DoSomething()
    {
        Console.WriteLine("Product A is doing something.");
    }
}

public class ConcreteProductB : Product
{
    public override void DoSomething()
    {
        Console.WriteLine("Product B is doing something.");
    }
}

public abstract class Creator
{
    public abstract Product FactoryMethod();

    public void AnOperation()
    {
        var product = FactoryMethod();
        product.DoSomething();
    }
}

public class ConcreteCreatorA : Creator
{
    public override Product FactoryMethod()
    {
        return new ConcreteProductA();
    }
}

public class ConcreteCreatorB : Creator
{
    public override Product FactoryMethod()
    {
        return new ConcreteProductB();
    }
}

使用方法:

Creator creator = new ConcreteCreatorA();
creator.AnOperation();
Java 实现
abstract class Product {
    abstract void doSomething();
}

class ConcreteProductA extends Product {
    @Override
    void doSomething() {
        System.out.println("Product A is doing something.");
    }
}

class ConcreteProductB extends Product {
    @Override
    void doSomething() {
        System.out.println("Product B is doing something.");
    }
}

abstract class Creator {
    public abstract Product factoryMethod();

    public void anOperation() {
        Product product = factoryMethod();
        product.doSomething();
    }
}

class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

使用方法:

Creator creator = new ConcreteCreatorA();
creator.anOperation();
（3）抽象工厂模式

抽象工厂模式通过为一系列相关或依赖的对象提供一个创建接口，使得客户端可以不必指定具体的类名，就可以创建对象族。

C# 实现
public abstract class ProductA { }
public abstract class ProductB { }

public class ConcreteProductA1 : ProductA { }
public class ConcreteProductA2 : ProductA { }
public class ConcreteProductB1 : ProductB { }
public class ConcreteProductB2 : ProductB { }

public abstract class AbstractFactory
{
    public abstract ProductA CreateProductA();
    public abstract ProductB CreateProductB();
}

public class ConcreteFactory1 : AbstractFactory
{
    public override ProductA CreateProductA() => new ConcreteProductA1();
    public override ProductB CreateProductB() => new ConcreteProductB1();
}

public class ConcreteFactory2 : AbstractFactory
{
    public override ProductA CreateProductA() => new ConcreteProductA2();
    public override ProductB CreateProductB() => new ConcreteProductB2();
}

使用方法:

AbstractFactory factory = new ConcreteFactory1();
ProductA productA = factory.CreateProductA();
ProductB productB = factory.CreateProductB();
Java 实现
abstract class ProductA { }
abstract class ProductB { }

class ConcreteProductA1 extends ProductA { }
class ConcreteProductA2 extends ProductA { }
class ConcreteProductB1 extends ProductB { }
class ConcreteProductB2 extends ProductB { }

abstract class AbstractFactory {
    abstract ProductA createProductA();
    abstract ProductB createProductB();
}

class ConcreteFactory1 extends AbstractFactory {
    @Override
    ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

class ConcreteFactory2 extends AbstractFactory {
    @Override
    ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

使用方法:

AbstractFactory factory = new ConcreteFactory1();
ProductA productA = factory.createProductA();
ProductB productB = factory.createProductB();

4. 优点

  • 解耦创建和使用: 客户端代码不直接依赖于具体产品类，降低了代码的耦合度。
  • 可扩展性强: 新的产品可以通过增加新的工厂类或方法实现，而不需要修改现有代码。

5. 缺点

  • 增加复杂性: 引入工厂模式可能会增加系统的复杂性，特别是在简单对象创建的场景中。
  • 抽象工厂的维护: 随着产品族的增加，抽象工厂模式可能会导致过多的类和接口。

6. 适用场景

  • 对象创建过程复杂: 适用于需要复杂对象创建过程的场景，如多个依赖对象的创建、对象的条件创建等。
  • 系统解耦: 需要将对象的创建和使用解耦的场景，如插件系统、依赖注入等。

小结

工厂模式在创建对象时提供了灵活性和可扩展性。经过上面的学习，不难发现，从简单工厂模式到工厂模式，再到抽象工厂模式，实际就是对软件架构进一步解耦的过程，提高代码的扩展性，也使得软件架构能够更加的灵活。

二、工厂模式变体

1. 简单工厂模式的变体

虽然简单工厂模式是最基础的，但在某些情况下，我们可以通过参数化或动态生成对象来增强它的功能。

变体1: 参数化工厂

在这个变体中，工厂方法接受不同的参数类型，不仅仅是一个标识符字符串，还可以是枚举、配置对象或条件判断等。

C# 示例
public enum ProductType
{
    ProductA,
    ProductB
}

public class ProductFactory
{
    public static Product CreateProduct(ProductType type)
    {
        switch (type)
        {
            case ProductType.ProductA:
                return new ConcreteProductA();
            case ProductType.ProductB:
                return new ConcreteProductB();
            default:
                throw new ArgumentException("Invalid product type.");
        }
    }
}
变体2: 反射工厂

可以通过反射来动态创建对象，从而减少分支逻辑的硬编码。

C# 示例
public class ProductFactory
{
    public static Product CreateProduct(string className)
    {
        Type type = Type.GetType(className);
        return (Product)Activator.CreateInstance(type);
    }
}

这种方法可以在运行时通过类的名称或其他元数据信息来创建对象，适合大型系统中的动态扩展需求。

2. 工厂方法模式的变体

工厂方法模式可以根据不同的扩展需求进行调整，通常适合创建复杂对象时使用。下面是一些变体：

变体1: 可配置工厂

工厂方法可以通过读取配置文件或外部资源来确定创建的对象类型。比如在Web开发中，可以通过读取XML或JSON文件来动态配置具体类的选择。

C# 示例
public class ConfigurableProductFactory : Creator
{
    public override Product FactoryMethod()
    {
        string type = ConfigurationManager.AppSettings["ProductType"];
        if (type == "A")
            return new ConcreteProductA();
        else
            return new ConcreteProductB();
    }
}
变体2: 延迟初始化

有时候我们需要延迟创建对象，以便减少内存占用或提高启动速度。可以结合工厂模式和延迟加载模式来实现这种需求。

C# 示例
public class LazyProductFactory : Creator
{
    private Product _product;

    public override Product FactoryMethod()
    {
        if (_product == null)
        {
            _product = new ConcreteProductA(); // 延迟创建对象
        }
        return _product;
    }
}

3. 抽象工厂模式的变体

抽象工厂模式是工厂模式的进一步抽象，可以为对象族创建工厂。通常用于需要创建多个相关对象时，但在实际应用中，可以进一步优化和扩展。

变体1: 层次结构的抽象工厂

在复杂的系统中，抽象工厂可以为不同的产品层次结构创建工厂。比如，一个GUI系统可能有不同的控件类型，每种控件类型都有对应的工厂。

C#示例
// 抽象工厂为不同控件创建工厂
public abstract class GUIFactory
{
    public abstract Button CreateButton();
    public abstract Checkbox CreateCheckbox();
}

// Windows 工厂
public class WindowsFactory : GUIFactory
{
    public override Button CreateButton() => new WindowsButton();
    public override Checkbox CreateCheckbox() => new WindowsCheckbox();
}

// Mac 工厂
public class MacFactory : GUIFactory
{
    public override Button CreateButton() => new MacButton();
    public override Checkbox CreateCheckbox() => new MacCheckbox();
}

这种层次结构的抽象工厂使得我们可以轻松扩展支持新的操作系统或设备。

变体2: 工厂生产线

在某些复杂应用中，抽象工厂不仅仅用于创建单个对象，而是用于创建一组相关的对象。比如在游戏开发中，工厂可以创建整个生态系统的对象，如玩家角色、敌人、道具等。

C#示例
public abstract class GameFactory
{
    public abstract Player CreatePlayer();
    public abstract Enemy CreateEnemy();
    public abstract Item CreateItem();
}

4. 实际应用场景

场景1: 数据库连接管理

工厂模式可以用于管理数据库连接。例如，不同的数据库（如SQL Server、MySQL、Oracle）可以通过工厂模式进行选择，实现不同数据库的连接对象。

C#示例
public abstract class DatabaseConnectionFactory
{
    public abstract IDbConnection CreateConnection();
}

public class SqlServerConnectionFactory : DatabaseConnectionFactory
{
    public override IDbConnection CreateConnection()
    {
        return new SqlConnection();
    }
}

public class MySqlConnectionFactory : DatabaseConnectionFactory
{
    public override IDbConnection CreateConnection()
    {
        return new MySqlConnection();
    }
}

客户端代码可以动态决定使用哪种数据库，而不需要知道具体的实现。

场景2: GUI 元素创建

GUI系统中，控件类型众多且随平台不同。通过工厂模式，可以轻松支持不同平台的控件，如Windows和Mac的按钮、文本框等。

C#示例
GUIFactory factory = new WindowsFactory();
Button button = factory.CreateButton();
Checkbox checkbox = factory.CreateCheckbox();
场景3: 日志系统

工厂模式可以根据配置文件或运行时参数决定使用哪种日志记录系统，比如文件日志、数据库日志、远程日志等。

C#示例
public abstract class LoggerFactory
{
    public abstract ILogger CreateLogger();
}

public class FileLoggerFactory : LoggerFactory
{
    public override ILogger CreateLogger()
    {
        return new FileLogger();
    }
}

小结

工厂模式的变体和应用场景非常广泛，无论是在对象创建、系统解耦还是灵活扩展中都能提供极大的便利。不同场景可以根据需求选择不同的工厂模式变体，如动态对象创建、延迟加载、配置驱动等。通过结合工厂模式与其他设计模式（如策略模式、装饰器模式等），可以实现更加灵活和可维护的架构。

秦哈哈
关注
专栏目录
软件设计模式之工厂模式
escFAJ的博客
08-03 367
软件设计模式之工厂模式实验 一、实验目的 掌握软件设计模式中的工厂模式，能够用工厂模式编写程序，解决实际问题。 二、实验内容与要求 内容：使用工厂模式写一个简单的计算器，能实现加减乘除运算。要求输入两个数，选择运算符，程序便能够计算出结果。程序设计语言可自由选择。 要求：需要用“文字+代码+截图”的形式对实验的主要代码和运行结果进行展示和描述。 三、实验方法 Operation运算类（父类）： public class Operation { private double _numberA =
java常用设计模式-工厂模式
08-26
Java常用设计模式-工厂模式 工厂模式（Factory Pattern）是一种常用的设计模式，它通过一个工厂类来实现对象的创建，而无需直接暴露对象的创建逻辑给客户端。这种模式可以使客户端代码与具体的产品类解耦，提高代码...
常用设计模式demo代码-design.rar
08-09
1、单例模式 2、工厂模式（简单工厂、工厂方法、抽象工厂） 3、观察者模式 4、模板模式
【软件设计模式】工厂模式(简单工厂模式、一般工厂模式、抽象工厂模式)
Guanhai1617的博客
09-06 757
最近在跟Michael Sun老师学《软件体系结构与设计模式》这门课，这门课从架构和设计模式两个维度出发，是之前所学编程语言、软件设计思想的更高一层次的理论和实践，对我来讲是门非常重要也是急需掌握的一门课程，于是想把学习收获写成博客，一来巩固所学，二来方便后续回顾，水平有限，不足之处欢迎大家指正。 **概述：**工厂模式把对象的创建交由某个特定的类来实现，该类为工厂类，该类的方法称为工厂方法，仅仅...
软件里的简单工厂模式
sanqima的专栏
04-05 650
        软件中，有时需要将对象的创建与使用分离，这时就需要简单工厂模式了。         一、简单工厂模式的三个角色         1）工厂(Factory)角色: 简单工厂模式的核心，它负责实现创建所有的实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。...
软件构造——工厂模式
qq_43887432的博客
06-15 160
实验中，老师要求利用工厂方法来产生一个对象。但是，工厂方法有什么好处呢？毕竟为了实现它，还需要写一堆代码。 查阅资料以及结合课上ppt可以知道，工厂模式主要分为三种： 简单/静态工厂模式； 工厂方法模式； 抽象工厂模式； 以上这些工厂模式都实现了一个目的：解耦，从而使代码易于维护。 例如： 一个Graph接口，有多重实现类：ConcreteEdgeGraph、ConcreteVertexGraph等实现。现在客户端需要用到多个Graph，于是在客户端代码中出现了很多这样的代码： Graph instan
软件设计模式——工厂方法模式(Factory Method)
Jungle_hello的博客
04-13 1873
工厂方法模式去掉了简单工厂模式中工厂方法的静态属性,使得它可以被子类继承。通俗的来说就是把简单工厂模式里面的分支语句给去掉，将每个具体产品的实例化过程放到相应的产品中去。相应的角色如下： （1）抽象工厂角色：这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。 （2）具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
java常用设计模式-抽象工厂模式
08-26
java常用设计模式-抽象工厂模式 抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它通过定义一个创建对象的接口来创建对象，但将具体实现的决定留给子类来决定。在抽象工厂模式中，接口是负责创建...
设计模式-简单工厂模式-例题
03-13
简单工厂模式（Simple Factory Pattern）是一种常用的创建型设计模式。它提供了一种方式来封装对象的创建过程，使得整个系统更加灵活，易于扩展。在简单工厂模式中，存在一个专门用于创建对象的工厂类，它负责根据...
设计模式-工厂模式.pdf
04-11
工厂模式是一种常用的设计模式，属于创建型模式之一。它的核心思想在于将对象的创建过程封装起来，并通过特定的工厂类来实现对象的创建，以此达到降低系统耦合度的目的。在实际应用中，工厂模式可以有效地管理对象的...
软件设计模式——简单工厂模式(Simple Factory)
Jungle_hello的博客
04-13 1893
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的；设计模式使代码编制真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。一 、设计模式分为三种类型： 1.创建型模式：单例模式、抽象工厂模式、建造者模式、工厂模式、原
软件设计模式——工厂设计模式
wangshiqi666的博客
02-08 1890
工厂模式
软件设计模式--工厂模式
qq_42812195的博客
04-26 285
设计模式:代码设计经验,稳定,拓展性更强,一系列编程思想. 百度百科:软件设计模式（Design pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。   建筑设计领域引入到计算机科学中来 为什么用设计模式:以前写代码的时候很乱,所以去学了设计模式 (java) C :面向过程,一门不太友好的面向对象的语言,引入设计模式就是为了面向对象 java:面向对象 设计模式通常描述了一
23种软件设计模式——工厂模式
最新发布
如果相遇，那么你好哦~
05-31 1166
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一，它提供了一种创建对象的方式，使得创建对象的过程与使用对象的过程分离。 工厂模式提供了一种创建对象的方式，而无需指定要创建的具体类。 通过使用工厂模式，可以将对象的创建逻辑封装在一个工厂类中，而不是在客户端代码中直接实例化对象，这样可以提高代码的可维护性和可扩展性。
软件设计模式学习（四）简单工厂模式
低吟不作语的博客
03-05 549
简单工厂模式 简单工厂模式是最简单的设计模式之一，虽然不属于二十三种设计模式，但应用也较为频繁。学习它也是学习其他创建型模式的基础 模式定义 在实际软件开发中，有时需创建一些来自于相同父类的类的实例，为此可以专门定义一个类来负责创建这些类的实例，这些被创建的实例具有共同的父类。习惯上将获得其他类实例的方法定义为static方法，外部不需要实例化这个类就可以直接调用该方法获得对象，该方法也称...
六大常用软件设计模式—工厂模式
Z2658172512的博客
03-28 2110
当当当当~~~~欢迎大家阅读，今天我们学习六大常用软件设计模式中的工厂模式 工厂方法模式中只考虑生产同等级的产品，本节主要介绍抽象工厂模式，考虑多等级产品的生产 工厂模式 （Factory Pattern） 一：工厂模式的定义 就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。 二：工厂模式的实现方式 1、 抽象产品类（也可以是接口） 2、多个具体的产品类 3、..
带你一次性搞懂软件构造中的工厂模式
qq_36964853的博客
06-03 236
软件构造：工厂模式系列
工厂模式详解
CHZKAL的博客
02-12 801
出于对设计模式的学习复习，才决定写的这一系列文章，一方面是帮助自己更快的复习记忆，另一方面是帮助有需要的人快速入门，分享自己的学习内容吧。 先来张女神图亢奋一下，嘿嘿嘿~（四月是你的谎言） 概念和目的 设计模式是众多经验丰富的工程师经过大量的实验花费了很多很多时间才总结出来的，可以说是众多经验的结晶了。在所有的中、大型项目中，设计模式随处可见。使用设计模式，是为了提高代码的可重用性...
Java设计模式详解：工厂模式种类与应用
深入浅出设计模式是一本介绍面向对象编程中常用设计模式的书籍，作者AI92以通俗易懂的方式阐述了这些模式。本章主要聚焦于工厂模式，这是一种用于创建对象的抽象概念，旨在将对象的创建过程与业务逻辑分离，提升代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值