C# 设计模式之简单工厂模式

鲤籽鲲

已于 2024-07-31 13:47:19 修改

阅读量837

点赞数 26

分类专栏： C# 文章标签： c# 设计模式简单工厂模式

于 2024-07-31 13:45:52 首次发布

本文链接：https://blog.csdn.net/qq_39847278/article/details/140817436

版权

C# 专栏收录该内容

49 篇文章 30 订阅

订阅专栏

总目录

前言

本文是个人基于C#学习设计模式总结的学习笔记，希望对你有用！

1 基本介绍

简单工厂模式定义：用于创建对象，将对象的创建与使用分离。

简单工厂模式中用于创建实例的方法是静态(static)方法，因而简单工厂模式又被称为静态工厂方法模式，它属于类创建型模式，但不属于GOF23种设计模式。

工厂模式有三种类型：
- 简单工厂模式（或称静态工厂方法模式）
- 工厂方法模式
- 抽象工厂模式
工厂模式是一种创建型模式，负责封装和管理对象的创建；主要用来解耦代码，将对象的创建和使用分离，使得代码更加灵活和可维护。
简单工厂模式是工厂模式的基本形式，通过定义一个工厂类，类中定义一个静态方法，该方法根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。
简单工厂包含三大角色：
- 抽象产品（抽象类）
  - 定义了产品的规范，描述了产品的主要特征和功能。
  - 它是工厂类创建的所有对象的父类，封装了各种产品对象的共有方法。
- 具体产品（子类）
  - 继承抽象产品的子类，某个产品的具体实现类。
- 具体工厂（实例化对象类）
  - 它是简单工厂模式的核心，负责实现创建所有产品实例的内部逻辑；
  - 可以被外界直接调用，创建所需的产品对象

2 适用场景

适用于创建对象需要大量重复的步骤，或者需要依赖于其它对象的情况，它提供了一种方式来封装多个相关或依赖对象的创建逻辑。

当工厂类负责创建的对象比较少时可以考虑使用简单工厂模式
客户如果只知道传入工厂类的参数，对于如何创建对象的逻辑不关心时可以考虑使用简单工厂模式

3 实现方式

假如我们有个抽象产品：鞋子(所有种类鞋子的父类)，鞋子内有个抽象方法Show

	//抽象父类，抽象产品
    public abstract class AbstractShoes
    {
    	//该方法负责输出 产品名称
        public abstract void Show();
    }

现在该产品有两个子类：LeatherShoes（皮鞋）和GymShoes（体育鞋）

    public class LeatherShoes : AbstractShoes
    {
        public override void Show()
        {
            Console.WriteLine($"我是：{nameof(LeatherShoes)} ！");
        }
    }

    public class GymShoes : AbstractShoes
    {
        public override void Show()
        {
            Console.WriteLine($"我是：{nameof(GymShoes)} ！");
        }
    }

现在张三鞋穿坏了，需要自己做鞋子，于是张三开始自己动手做鞋子：

    //定义一个张三 的类，里面有个做鞋子的行为（方法）
    public class ZhangSan
    {
        //张三制作鞋子的办法
        public AbstractShoes MakeShoes(string type)
        {
            if (type == "LeatherShoes")
            {
                return new LeatherShoes();
            }
            else if (type == "GymShoes")
            {
                return new GymShoes();
            }
            else
            {
                throw new ArgumentException("Invalid type.");
            }
        }

        // 张三自己想做鞋子的时候
        public void Main()
        {
            //自己做皮鞋
            AbstractShoes abstractShoes1 = MakeShoes("LeatherShoes");
            abstractShoes1.Show();
            //自己做体育鞋
            AbstractShoes abstractShoes2 = MakeShoes("GymShoes");
            abstractShoes2.Show();
        }
    }

张三虽然可以自己制作鞋子，但是不免有些太麻烦了，太耗时间了；正好他家附近有个鞋厂，因此他想偷懒，下次没鞋子了就去鞋厂买，因此代码改进如下：

    //定义一个造鞋工厂类，专门负责生产鞋子
    public class ShoesFactory
    {
    	//定义一个公有的静态方法，传入鞋子类别，然后返回一个具体类型的鞋子实例
        public static AbstractShoes MakeShoes(string type)
        {
            if (type == "LeatherShoes")
            {
                return new LeatherShoes();
            }
            else if (type == "GymShoes")
            {
                return new GymShoes();
            }
            else
            {
                throw new ArgumentException("Invalid type.");
            }
        }
    }

此时对于张三来说，就简单了，张三需要鞋子穿就直接去找鞋子工厂了

    public class ZhangSan
    {
        public void Main()
        {
            //去鞋厂买皮鞋
            AbstractShoes abstractShoes1 = ShoesFactory.MakeShoes("LeatherShoes");
            abstractShoes1.Show();
            //去鞋厂买体育鞋
            AbstractShoes abstractShoes2 = ShoesFactory.MakeShoes("GymShoes");
            abstractShoes2.Show();
        }
    }

在这里我们发现，对于而言，不需要再去学习那么多做鞋子的技能，只需要掏钱买些即可。张三可以将时间花在更为重要的事情上面。

4 优缺点分析

通过简单工厂模式的实现，你会发现我们只是把变化的点移到了工厂类中而已，好像没有太大变化；

因为如果张三想再来一双凉鞋的时候，此时我们还是需要修改工厂类中的造鞋方法（增加一个类型的判断），在没实现简单工厂前，我们同样也会做同样的修改，只不过是修改张三自己的造鞋方法。从这里我们要知道每个模式都不是万能的，只是某一类问题的解决方案，都会有优缺点。

优点：实现了对象的创建和使用分离，使得代码更加灵活和可维护（总的一点）。
- 简单工厂模式解决了客户端直接依赖于具体对象的问题，客户端可以消除直接创建对象的责任，而仅仅是消费产品。
- 简单工厂模式实现了对责任的分割。
- 简单工厂模式也起到了代码复用的作用，因为之前的实现（张三自己做鞋的情况）中，换了一个人同样要去在自己的类中实现做鞋的方法，然后有了简单工厂之后，需要鞋子的所有人都不用那么麻烦了，只需要负责消费就可以了。此时简单工厂的造鞋技能就让所有客户共用了。
缺点：增加新的产品需要修改工厂接口，违背了“开放-封闭原则”。
- 系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，这样就会造成工厂逻辑过于复杂。
- 简单工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都会受到影响（通俗地意思就是：一旦鞋厂关门了，很多不会造鞋的人就没鞋穿了）