设计模式-抽象工厂设计模式

(比如游戏升级,传进来升级信息后,好多东西都要更改,就要用到工厂模式)

在简单工厂中，我们的工厂类一次只可以处理一类产品。那么如果我们想处理多类产品，简单工厂是满足不了的。必须要用抽象工厂设计模式。

我们先从概念上来了解下什么是抽象工厂设计模式：

•1、提供一系列相互依赖对象的创建工作

 

•2、封装对象常规的创建方法（new）

 

•3、提供统一调用访问方法的方式

 

•4、避免调用访问方法和具体对象创建工作的紧耦合

 

 

这些概念性的东西看起来比较抽象，直接上图

 

如上图所示，我们如何去更好的理解抽象工厂，首先 我们要分清在这个模式中的几类角色。有抽象工厂，实体工厂，抽象产品，实体产品，客户(调用代码的类)。

•抽象工厂设计模式中各个对象的主要功能、职责：

•1、用抽象工厂生产抽象产品

 

•2、用实体工厂生产实体产品

 

•3、用抽象产品提供实体产品访问接口

 

•4、用实体产品实现自己的功能

 

直接上代码：

1、定义抽象产品 (父类可以是接口或者抽象类，我们定义一个抽象类，一个接口)

定义抽象产品A：

    /// <summary>
    /// 抽象产品A
    /// </summary>
    public abstract class Car
    {
        public abstract void Run();
    }

抽象产品B：

    /// <summary>
    /// 抽象产品B
    /// </summary>
    public interface IBus
    {
        void Run();
    }

2、定义实体产品

实体产品A1：

    /// <summary>
    /// 实体产品A1
    /// </summary>
   public class BMWCar:Car
    {
        public override void Run()
        {
            Console.WriteLine("宝马轿车在行驶！");
        }
    }

实体产品A2：

    /// <summary>
    /// 实体产品A2
    /// </summary>
    public class BenzCar:Car
    {
        public override void Run()
        {
            Console.WriteLine("奔驰轿车在行驶！");
        }
    }

实体产品B1：

    /// <summary>
    /// 实体产品B1
    /// </summary>
    public class BMWBus : IBus
    {
        public void Run()
        {
            Console.WriteLine("宝马大汽车");
        }
    }

 

实体产品B2：

    /// <summary>
    /// 实体产品B2
    /// </summary>
    public class BenzBus : IBus
    {
        public void Run()
        {
            Console.WriteLine("奔驰大汽车");
        }
    }

我们甚至可以再建N个A3，A4，B3，B4.................... 此处省略。

 

3、定义抽象工厂

众所周知现实生活中工厂都是生产产品的，在我们这 工厂是用来生产类的对象的。抽象工厂就是用来定义 工厂应该做什么的。相当于工厂接口规定工厂应该做什么。同时创建实体工厂对象，创建对象可以用反射，本例中只是为了说明抽象工厂的思想和具体实现。我们直 接使用配置文件来读取。

    /// <summary>
    /// 抽象工厂
    /// </summary>
    public abstract class AbstractFactory
    {
        public static AbstractFactory CreateFactory(string strType)
        {
            AbstractFactory factory = null;
            switch (strType)
            {
                case "BMW":
                    factory = new BMWFactory();
                    break;
                case "Benz":
                    factory = new BenzFactory();
                    break;
            }
            return factory;
        }

        /// <summary>
        /// 抽象方法 创建Car对象
        /// </summary>
        /// <returns></returns>
        public abstract Car CreateCar();

        /// <summary>
        /// 创建BUS
        /// </summary>
        /// <returns></returns>
        public abstract IBus CreateBus();
    }

 

 

4、定义实体工厂

 实体工厂1：

   /// <summary>
    /// 实体工厂1
    /// </summary>
   public class BMWFactory:AbstractFactory
    {
        public override Car CreateCar()
        {
            return new BMWCar();
        }

        public override IBus CreateBus()
        {
            return new BMWBus();
        }
    }

实体工厂2：

    /// <summary>
    /// 实体工厂2
    /// </summary>
    public class BenzFactory : AbstractFactory
    {
        public override Car CreateCar()
        {
            return new BenzCar();
        }

        public override IBus CreateBus()
        {
            return new BenzBus();
        }
    }

 

5、客户端调用

从 最上面的图我们可以看出客户端调用抽象工厂的代码只关注抽象工厂和抽象产品，而不关注具体的实现类。如下图：

 由此我们得出抽象工厂的定义：

提供一个创建一系列相关或相互依赖对象的接口，无需指定它们具体的类

 static void Main(string[] args)
 {

            AbstractFactory factory = AbstractFactory.CreateFactory("Benz");
            Car car = factory.CreateCar();
            car.Run();
            IBus bus = factory.CreateBus();
            bus.Run();
   }