04、【C\#设计模式】工厂方法模式（FactoryMethodPattern）【创建型】-程序员快看-教程，程序员编程资料站

前言
一、模式的详细介绍
- 1.1 动机（Motivate）
1.2 意图（Intent）
1.3 结构图（Structure）
1.4 模式的组成
1.5 模式的具体实现
二、模式的实现要点
- 2.1 模式的优点
2.2 模式的缺点
2.3 模式使用的场景
三、.NET 中模式的实现【略】
总结

特别说明：主要通过实例代码来理解！
和简单工厂模式的核心区别：将对象的创建延迟到具体工厂中

前言

在上一篇文章中我们讲解了过渡的一种模式叫做【简单工厂】，也有叫【静态工厂】的，通过对简单工厂模式得了解，我们也发现了它的缺点，就是随着需求的变化我们要不停地修改工厂里面的方法的代码，需求变化越多，里面的If–Else–也越多，这样就会造成简单工厂的实现逻辑过于复杂。设计模式是遵循一定原则而得来的，比如，我们要怎么增加代码，怎么修改代码，不是想怎么来就怎么来的，其中一个原则就是OCP原则，中文是【开放关闭原则】，对增加代码开发，对修改代码关闭，所以我们就不能总是这样修改简单工厂里面的方法。本章介绍的工厂方法模式可以解决简单工厂模式中存在的这个问题，下面就具体看看工厂方法模式是如何解决该问题的。

一、模式的详细介绍

1.1 动机（Motivate）

在软件系统的构建过程中，经常面临着“某个对象”的创建工作：由于需求的变化，这个对象（的具体实现）经常面临着剧烈的变化，但是它却拥有比较稳定的接口。

如何应对这种变化？如何提供一种“封装机制”来隔离出“这个易变对象”的变化，从而保持系统中“其他依赖对象的对象”不随着需求改变而改变？

1.2 意图（Intent）

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟到子类。 --《设计模式》GoF

1.3 结构图（Structure）

1.4 模式的组成

可以看出，在工厂方法模式的结构图有以下角色：

（1）抽象工厂角色（Creator）: 充当抽象工厂角色，定义工厂类所具有的基本的操作，任何具体工厂都必须继承该抽象类。

（2）具体工厂角色（ConcreteCreator）：充当具体工厂角色，该类必须继承抽象工厂角色，实现抽象工厂定义的方法，用来创建具体产品。

（3）抽象产品角色（Product）：充当抽象产品角色，定义了产品类型所有具有的基本操作，具体产品必须继承该抽象类。
（4）具体产品角色（ConcreteProduct）：充当具体产品角色，实现抽象产品类对定义的抽象方法，由具体工厂类创建，它们之间有一一对应的关系。

1.5 模式的具体实现

【简单工厂模式】的问题是：如果有新的需求就需要修改工厂类里面创建产品对象实例的那个方法的实现代码，在面向对象设计一个原则就是哪里有变化，我就封装哪里。还有另外两个大的原则，其一是：面向抽象编程，细节和高层实现都要依赖抽象，第二个原则是：多组合，少继承。这三个原则是最根本的原则，学习设计模式必须以这三个原则为基点，否则都是枉然。

根据这三大原则又衍生出来6个具体的原则，分别是【单一职责原则】，【里氏替换原则】，【依赖倒置原则】，【接口隔离原则】、【迪米特法则】和【开闭原则】，既然工厂类有变化，我们就封装它，面向抽象编程，我们先抽象出一个工厂基类，然后，每个需求就实现一个具体的工厂类，这样我们就符合了【开闭原则OCP】，让一个工厂生产一款产品，并一一对应。我们把具体产品的创建推迟到子类中，此时工厂类（这类是基类了）不再负责所有产品的创建，而只是给出具体工厂必须实现的接口，这样工厂方法模式就可以允许系统不修改工厂类逻辑的情况下来添加新产品，这样也就克服了简单工厂模式中缺点。下面就是工厂方法模式的实现代码：

using System;
using System.Collections;
using System.Collections.Generic;

namespace 设计模式之工厂方法模式
{
   
     
    /// <summary>
    /// 汽车抽象类
    /// </summary>
    public abstract class Car
    {
   
     
        // 开始行驶
        public abstract void Go();
    }

    /// <summary>
    /// 红旗汽车
    /// </summary>
    public class HongQiCar : Car
    {
   
     
        public override void Go()
        {
   
     
            Console.WriteLine("红旗汽车开始行驶了！");
        }
    }

    /// <summary>
    /// 奥迪汽车
    /// </summary>
    public class AoDiCar : Car
    {
   
     
        public override void Go()
        {
   
     
            Console.WriteLine("奥迪汽车开始行驶了");
        }
    }

    /// <summary>
    /// 抽象工厂类
    /// </summary>
    public abstract class Factory
    {
   
     
        // 工厂方法
        public abstract Car CreateCar();
    }

    /// <summary>
    /// 红旗汽车工厂类
    /// </summary>
    public class HongQiCarFactory : Factory
    {
   
     
        /// <summary>
        /// 负责生产红旗汽车
        /// </summary>
        /// <returns></returns>
        public override Car CreateCar()
        {
   
     
            return new HongQiCar();
        }
    }

    /// <summary>
    /// 奥迪汽车工厂类
    /// </summary>
    public class AoDiCarFactory : Factory
    {
   
     
        /// <summary>
        /// 负责创建奥迪汽车
        /// </summary>
        /// <returns></returns>
        public override Car CreateCar()
        {
   
     
            return new AoDiCar();
        }
    }

    /// <summary>
    /// 客户端调用
    /// </summary>
    class Client
    {
   
     
        static void Main(string[] args)
        {
   
     
            // 初始化创建汽车的两个工厂
            Factory hongQiCarFactory = new HongQiCarFactory();
            Factory aoDiCarFactory = new AoDiCarFactory();

            // 生产一辆红旗汽车
            Car hongQi = hongQiCarFactory.CreateCar();
            hongQi.Go();

            //生产一辆奥迪汽车
            Car aoDi = aoDiCarFactory.CreateCar();
            aoDi.Go();

            Console.Read();
        }
    }
}

运行结果：

在【工厂方法模式】中，我们同样也把汽车的类抽象出来一个抽象的基类，这里正好符合了【面向抽象编程】，客户端在使用的时候不会依赖具体的什么汽车。使用工厂方法实现的系统，如果系统需要添加新产品时，我们可以利用多态性来完成系统的扩展，对于抽象工厂类和具体工厂中的代码都不需要做任何改动。例如，我们想增加一辆奔驰车，我们只需从Car抽象类下继承一个BenChiCar类，同时在从Factory抽象基类下继承一个“奔驰”的工厂类BenChinaCarFactory就可以了，这样扩展符合OCP的原则。具体代码为：

 /// <summary>
    /// 奔驰车
    /// </summary>
    public class BenChiCar : Car
    {
   
     
        /// <summary>
        /// 重写抽象类中的方法
        /// </summary>
        public override void Go()
        {
   
     
            Console.WriteLine("奔驰车开始行驶了！");
        }
    }

    /// <summary>
    /// 奔驰车的工厂类
    /// </summary>
    public class BenChiCarFactory : Factory
    {
   
     
        /// <summary>
        /// 负责生产奔驰车
        /// </summary>
        /// <returns></returns>
        public override Car CreateCar()
        {
   
     
            return new BenChiCar();
        }
    }

    /// <summary>
    /// 客户端调用
    /// </summary>
    class Client
    {
   
     
        static void Main(string[] args)
        {
   
     

            // 如果客户又生产一辆奔驰车
            // 再另外初始化一个奔驰车的工厂
            Factory benChiCarFactory = new BenChiCarFactory();

            // 利用奔驰车的工厂生产奔驰车
            Car benChi = benChiCarFactory.CreateCar();
            benChi.Go();

            Console.Read();
        }
    }

二、模式的实现要点

Factory Method模式主要用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系会导致软件的脆弱。
Factory Method模式通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非更改）的策略，较好地解决了这种紧耦合关系。

Factory Method模式解决“单个对象”的需求变化；

AbstractFactory模式解决“系列对象”的需求变化；

Builder模式解决“对象部分”的需求变化；

2.1 模式的优点

（1）在工厂方法中，用户只需要知道所要产品的具体工厂，无须关系具体的创建过程，甚至不需要具体产品类的类名。

（2）在系统增加新的产品时，我们只需要添加一个具体产品类和对应的实现工厂，无需对原工厂进行任何修改，很好地符合了“开闭原则”。

2.2 模式的缺点

（1）每次增加一个产品时，都需要增加一个具体类和对象实现工厂，是的系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

2.3 模式使用的场景

（1）一个类不知道它所需要的对象的类。在工厂方法模式中，我们不需要具体产品的类名，我们只需要知道创建它的具体工厂即可。

（2）一个类通过其子类来指定创建那个对象。在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。

（3）将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定。

三、.NET 中模式的实现【略】

总结

每种模式都有自己的使用场合，切记，如果使用错误，还不如不用。工厂方法模式通过面向对象编程中的多态性来将对象的创建延迟到具体工厂中【核心！】，从而解决了简单工厂模式中存在的问题，也很好地符合了开放封闭原则（即对扩展开发，对修改封闭）。

学习设计模式我们一定要谨记设计模式的几大原则，否则是徒劳无功的。就像学武功一样，我们要记心法。6大原则就像孤独求败的独孤九剑的剑诀，学会了，变化无穷。

【C#设计模式】总目录—共23种