🏆 作者简介，愚公搬代码
🏆《头衔》：华为云特约编辑，华为云云享专家，华为开发者专家，华为产品云测专家，CSDN博客专家，阿里云专家博主，腾讯云优秀博主，掘金优秀博主，51CTO博客专家等。
🏆《近期荣誉》：2022年CSDN博客之星TOP2，2022年华为云十佳博主等。
🏆《博客内容》：.NET、Java、Python、Go、Node、前端、IOS、Android、鸿蒙、Linux、物联网、网络安全、大数据、人工智能、U3D游戏、小程序等相关领域知识。
🏆🎉欢迎 👍点赞✍评论⭐收藏

🚀前言

设计模式（Design Pattern）是软件开发领域的宝贵经验，是多人反复借鉴和广泛应用的代码设计指导。它们是一系列经过分类和归纳的代码组织方法，旨在实现可重用性、可维护性和可理解性。使用设计模式，我们能够编写高质量的代码，使其更易于他人理解，并提供了代码可靠性的保证。

毫无疑问，设计模式对个人、团队和整个系统都带来了显著的益处。它们将代码开发提升到工程化水平，为软件工程构建提供了坚实的基础，就如同大厦的一块块精巧的砖石一样。在项目中明智地应用设计模式可以完美地解决各种复杂问题。每种设计模式都有相应的原理和最佳实践，它们描述了我们日常开发中不断遇到的问题，以及这些问题的核心解决方法。正是因为这种实用性和通用性，设计模式才能在软件开发中广泛地得以应用。设计模式是构建稳健、可扩展和可维护软件的关键工具，为开发者们提供了解决问题的智慧和指导。

🚀一、简单工厂模式(Simple Factory Pattern)

简单工厂模式是创建型设计模式，又被称为静态工厂方法（Static Factory Method）模式，虽然它不包含在经典的23种GoF（Gang of Four）设计模式之中，但却是学习其他工厂模式的重要前提。

在简单工厂模式中，一个工厂对象负责根据输入的条件来创建不同种类的产品类的实例。这种模式可以被视为工厂模式家族中的最简单且最实用的一员，它可以被看作是其他更复杂工厂模式的一种特殊实现。

简单工厂模式的核心思想是将对象的创建过程封装在一个独立的工厂类中，客户端代码通过与工厂类交互来获取所需的对象，而无需关心对象的具体创建细节。这种方式有助于降低代码的耦合度，使得系统更易于维护和扩展。

学习简单工厂模式是理解和掌握其他更复杂的工厂模式的基础。它为开发者提供了一个简单而直观的工厂模式入门点，使他们能够逐步深入研究和应用更高级的工厂模式，以满足不同项目和场景的需求。简单工厂模式虽然简单，但在许多情况下都是非常有用的设计模式。通过学习和应用它，开发者可以积累更多的设计模式经验，提高自己的软件开发技能

🚀二、使用步骤

🔎1.角色

🦋1.1 工厂（Creator）

简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象，它具有以下作用和功能：

1. 对象创建：工厂负责根据客户端的需求和输入条件创建具体的对象实例。这样，客户端代码无需直接调用对象的构造函数，而是通过工厂来获取所需的对象，从而实现对象的创建和初始化。

2. 封装对象创建逻辑：工厂将对象的创建逻辑封装在自己内部，客户端无需关心对象如何创建以及所需的构造参数。这有助于降低客户端与具体对象之间的耦合度，提高代码的灵活性和可维护性。

3. 隐藏对象的具体类：客户端代码仅与工厂接口或抽象类交互，不需要了解具体的对象类。这有助于隐藏对象的具体实现细节，使系统更加抽象和可扩展。

4. 支持多种产品类型：简单工厂模式允许工厂根据输入条件创建不同种类的产品，这使得客户端可以灵活地获取不同类型的对象，而无需关心它们的具体实现。

简单工厂模式中的工厂起到了集中化对象创建的作用，它封装了对象的创建过程，并根据客户端的需求动态地选择创建哪种类型的对象。这种模式有助于提高代码的可维护性、可扩展性和可重用性，同时降低了客户端代码与具体对象之间的依赖关系。

🦋1.2 抽象产品（Product）

简单工厂模式所创建的所有对象的抽象基类，它负责描述所有实例所共有的公共接口，它具有以下作用和功能：

1. 定义产品接口：抽象产品是一个接口或者抽象类，它定义了具体产品对象应该具备的行为和属性。这样，客户端和工厂都可以依赖于抽象产品，而不需要关心具体产品的细节。

2. 统一产品类型：抽象产品确保了不同种类的具体产品都遵循相同的接口或抽象类定义。这样，工厂可以根据客户端的需求创建不同类型的具体产品，而客户端可以一致地操作这些产品，从而提高了代码的一致性和可维护性。

3. 隐藏具体产品细节：客户端代码不需要了解具体产品的类名或实现细节，它只需要知道如何与抽象产品进行交互。这有助于降低客户端代码与具体产品之间的耦合度，使系统更加灵活和易于维护。

4. 支持产品家族：抽象产品可以用于定义产品家族，即一组相关的产品类型。工厂可以创建不同产品家族的产品，而客户端可以通过抽象产品接口操作这些产品，从而实现一致的产品家族支持。

抽象产品在简单工厂模式中充当了产品的公共接口或抽象，它定义了客户端与具体产品之间的契约，使得客户端代码能够与具体产品的实现解耦。通过抽象产品，简单工厂模式支持了多态性、一致性和扩展性，有助于提高代码的可维护性和可扩展性。

🦋1.3 具体产品（Concrete Product）

在简单工厂模式中，具体产品（Concrete Product）是抽象产品（Abstract Product）的实际实现之一，具有以下概念和作用：

1. 实现产品接口：具体产品是抽象产品接口或抽象类的实际实现。它必须实现抽象产品定义的所有方法和属性，以确保产品的一致性和符合规范。

2. 封装产品细节：具体产品封装了与特定产品相关的细节和行为。这包括产品的属性、方法实现以及与产品特性相关的功能。

3. 定义产品的不同类型：在简单工厂模式中，可能会有多个具体产品，每个具体产品代表了不同的产品类型或变体。这些不同类型的产品通过具体产品类来表示，工厂可以根据客户端的需求创建不同类型的具体产品。

4. 支持工厂的创建：工厂根据客户端的请求，使用不同的具体产品类来创建相应类型的产品实例。每个具体产品类都有自己的构造方法，工厂通过调用这些构造方法来创建产品。

具体产品是简单工厂模式中的核心组成部分，它们是抽象产品的具体实现，代表了不同种类或变体的产品。具体产品类的作用是将产品的细节封装起来，使客户端代码与具体产品的创建和实现细节解耦。通过具体产品，工厂能够创建并提供客户端所需的不同类型的产品实例。这种方式实现了对象的多态性，使得系统更加灵活和可扩展。

🔎2.示例

命名空间SimpleFactory中包含抽象水果基类Fruit、三个具体水果类、水果工厂类FruitFactory、未知水果异常类UnknowFruitException。本案例将向大家展示如何使用简单工厂模式来生产不同种类的水果。

public abstract class Fruit {
 
    protected Color Color { get; set; } = Color.Orange;
 
    protected abstract string BornInfo();
 
    protected const string LINE_BREAK =
        "------------------------------------------------------------";
 
    public void WhatsFruit() {
        Console.WriteLine("Printing!");
        OnPrint();
        Console.WriteLine("Printed!");
        OnPrinted();
    }
 
    protected virtual void OnPrint() {
        Console.WriteLine($"I'm a(n) {this.ToString().Replace(nameof(SimpleFactory) + ".", "")} " +
                            $"with {Color.ToString()} and I born in {BornInfo()}!");
    }
 
    protected virtual void OnPrinted() {
        Console.WriteLine(LINE_BREAK);
    }
 
}

抽象水果基类Fruit 包含颜色Color属性、出生信息BornInfo抽象方法、这是什么水果WhatsFruit方法、打印水果OnPrint和打印完OnPrinted方法。

public class Apple : Fruit {

    public Apple() {
        Color = Color.Red;
    }

    protected override string BornInfo() => "summer";

    protected override void OnPrint() {
        Console.WriteLine($"I'm an apple with {Color.ToString()},not an IPhone!");
    } 

}

public class Orange : Fruit {

    protected override string BornInfo() => "autumn";

    protected override void OnPrinted() {
        Console.WriteLine("override OnPrinted()!");
        Console.WriteLine(LINE_BREAK);
    }

}

public class Pear : Fruit {

    public Pear() {
        Color = Color.Yellow;
    }

    protected override string BornInfo() => "China";

}

具体水果类，苹果Apple类、橘子Orange类和梨子Pear类，各自实现或重写不同的构造函数、抽象方法、虚拟方法和属性。

public enum FruitType {
    Unknow = -1,
    Apple,
    Orange,
    Pear
}

public static class FruitFactory {

    public static Fruit CreateFruit(FruitType type) {
        Fruit fruit = null;
        switch (type) {
            case FruitType.Apple:
                fruit = new Apple();
                break;
            case FruitType.Orange:
                fruit = new Orange();
                break;
            case FruitType.Pear:
                fruit = new Pear();
                break;
            default:
                throw new UnknowFruitException();
        }

        return fruit;
    }

}

水果工厂类FruitFactory，该类是简单工厂的核心类，包含CreateFruit方法，传递FruitType参数以便确定产出何种水果。方法返回抽象水果基类，以便调用方使用基类变量接受返回值。

public class UnknowFruitException : Exception {

    public UnknowFruitException()
        : base("Not Supported Fruit!") {

    }

    public UnknowFruitException(string message, Exception innerException)
        : base(message, innerException) {

    }

}

使用未知水果异常类UnknowFruitException，进行简单的异常处理。

public static void Main(string[] args) {
    try {
        var fruit = FruitFactory.CreateFruit(FruitType.Pear);
        fruit.WhatsFruit();

        fruit = FruitFactory.CreateFruit(FruitType.Apple);
        fruit.WhatsFruit();

        fruit = FruitFactory.CreateFruit(FruitType.Orange);
        fruit.WhatsFruit();

        fruit = FruitFactory.CreateFruit(FruitType.Unknow);
        fruit.WhatsFruit();
    }
    catch (UnknowFruitException ex) {
        Console.WriteLine(nameof(UnknowFruitException) + ":" + ex.Message);
    }
    catch (Exception ex) {
        Console.WriteLine(nameof(Exception) + ":" + ex.Message);
    }

    Console.ReadKey();
}

调用方用变量fruit接受水果工厂不同的产出，由WhatsFruit方法在控制台打印出水果信息，用catch分别处理不同类型的异常。以下是这个案例的输出结果：

Printing!
I'm a(n) Pear with Color [Yellow] and I born in China!
Printed!
-----------------------------------------------------------
Printing!
I'm an apple with Color [Red],not an IPhone!
Printed!
-----------------------------------------------------------
Printing!
I'm a(n) Orange with Color [Orange] and I born in autumn!
Printed!
override OnPrinted()!
-----------------------------------------------------------
UnknowFruitException:Not Supported Fruit!

🚀总结

🔎1.优点

简单工厂模式（Simple Factory Pattern）具有以下优点：

1. 封装对象创建逻辑：简单工厂模式将对象的创建逻辑封装在工厂类中，客户端代码无需关心对象的具体创建过程，只需向工厂请求所需的对象。这有助于降低客户端代码与具体对象之间的耦合度。

2. 隐藏对象的具体类：客户端只需要与工厂接口或抽象类交互，而无需了解具体产品的类名或实现细节。这有助于隐藏对象的具体实现，使系统更加抽象和可扩展。

3. 中心化管理对象的创建：简单工厂模式集中了对象的创建过程，可以在工厂中进行统一管理和维护。如果需要修改对象的创建方式或切换不同的产品实现，只需修改工厂类而无需修改客户端代码。

4. 支持多态性：客户端代码通过工厂获取对象实例，从而支持多态性。不同的具体产品类可以共享相同的抽象产品接口，客户端可以针对抽象接口编程，实现代码的灵活性和可扩展性。

5. 降低代码重复：如果有多个地方需要创建相同类型的对象，使用简单工厂模式可以避免代码重复，统一创建逻辑，提高代码的重用性。

6. 适用于初始阶段的设计：在项目的初始阶段，可能不清楚最终需要使用哪种具体产品，简单工厂模式可以帮助快速进行原型开发和验证设计概念。

简单工厂模式是一种简单但有效的设计模式，适用于某些情况下，特别是在对象创建过程相对简单，且需要降低客户端代码与具体对象之间的依赖度时。它提供了一种集中管理对象创建的方式，有助于提高代码的可维护性、可扩展性和可重用性。但需要注意的是，简单工厂模式并不是适用于所有情况，对于复杂的对象创建需求，可能需要考虑其他工厂模式，如工厂方法模式或抽象工厂模式。

🔎2.缺点

简单工厂模式（Simple Factory Pattern）虽然具有一些优点，但也存在一些缺点和局限性：

1. 不符合开闭原则：当需要新增具体产品类型时，通常需要修改工厂类的代码，违反了开闭原则（Open-Closed Principle）。每次添加新产品都需要修改工厂类，可能导致工厂类变得庞大，容易引发维护和扩展问题。

2. 单一职责原则问题：工厂类不仅负责对象的创建，还需要处理客户端的具体请求和条件判断，可能导致工厂类的职责不够单一，难以维护和扩展。

3. 违反依赖倒置原则：客户端代码依赖于具体的工厂类，而不是依赖于抽象接口或抽象类。这种依赖关系限制了代码的灵活性，使得客户端难以切换不同的工厂实现或产品家族。

4. 不支持产品族的创建：简单工厂模式只能创建单一类型的产品，不能很好地支持产品族的创建，即一组相关的产品类型。

5. 工厂类膨胀问题：随着产品类型的增多，工厂类的代码可能会不断膨胀，变得复杂难以维护。

6. 降低了代码的可测试性：由于客户端代码直接依赖于具体工厂类，难以进行单元测试，因为测试难以替代具体工厂类的实例。

7. 不适用于复杂对象的创建：当对象的创建过程非常复杂或需要根据多个因素进行定制化配置时，简单工厂模式可能不够灵活，需要考虑使用其他创建型设计模式，如工厂方法模式或抽象工厂模式。

简单工厂模式虽然在某些情况下可以简化对象的创建过程，但它也存在一些设计上的限制和缺点。在选择是否使用简单工厂模式时，需要根据具体的需求和项目情况进行权衡和考虑，确保选择的模式符合项目的设计目标和要求。

🔎3.使用场景

简单工厂模式（Simple Factory Pattern）适用于以下场景：

1. 对象创建过程相对简单：当需要创建的对象的构造过程相对简单，不涉及复杂的逻辑或条件判断时，简单工厂模式可以提供一个快速而一致的创建方式。

2. 客户端不需要知道具体产品的类名：如果客户端代码不需要知道具体产品类的名称或实现细节，而只需关心产品的接口或抽象类，那么可以使用简单工厂模式来隐藏具体产品的细节。

3. 对象的类型在运行时可动态确定：在某些情况下，客户端可能需要在运行时根据条件或配置信息来决定所需的具体产品类型，简单工厂模式可以满足这种需求。

4. 减少客户端与具体产品的耦合度：简单工厂模式通过将对象创建过程封装在工厂中，可以降低客户端与具体产品之间的依赖关系，使系统更加灵活和可维护。

5. 初始设计阶段的快速原型开发：在项目的初始阶段，可能不清楚最终需要使用哪种具体产品，简单工厂模式可以帮助快速进行原型开发和验证设计概念。

6. 具体产品类型较少且稳定：如果具体产品的类型较少，且不经常变化，简单工厂模式可以提供一个简单而有效的创建方式。

需要注意的是，简单工厂模式虽然在某些情况下有用，但它也具有一些缺点，如不符合开闭原则、不支持产品族等。在选择是否使用简单工厂模式时，需要权衡其优点和缺点，确保它符合项目的需求和设计目标。如果需要更高的灵活性和扩展性，可以考虑其他工厂模式，如工厂方法模式或抽象工厂模式。

🚀感谢：给读者的一封信

亲爱的读者，

我在这篇文章中投入了大量的心血和时间，希望为您提供有价值的内容。这篇文章包含了深入的研究和个人经验，我相信这些信息对您非常有帮助。

如果您觉得这篇文章对您有所帮助，我诚恳地请求您考虑赞赏1元钱的支持。这个金额不会对您的财务状况造成负担，但它会对我继续创作高质量的内容产生积极的影响。

我之所以写这篇文章，是因为我热爱分享有用的知识和见解。您的支持将帮助我继续这个使命，也鼓励我花更多的时间和精力创作更多有价值的内容。

如果您愿意支持我的创作，请扫描下面二维码，您的支持将不胜感激。同时，如果您有任何反馈或建议，也欢迎与我分享。

再次感谢您的阅读和支持！

最诚挚的问候， “愚公搬代码”