设计模式学习之路——Abstract Factory 抽象工厂模式

     所有的创建型模式都涉及到创建对象实例的方式，因为程序不应该依赖于对象如何创建和安排，当然，使用new 是C#创建一个对象实例最简单的方法。然而，很多情况下，创建对象的本意随程序的需求不同而不同，将创建过程抽象成一个专门的“创造器”类，会使程序更灵活，更通用。

意图：

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

动机：

在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？

抽象工厂模式（Abstract Factory）提供了一个创建并返回一系列相关对象的接口。

结构：

代码实现：

以红警游戏为场景（设想有两个玩家，一个是苏联一方，一个是美国一方，开始游戏后，双方开始造飞机和坦克），实现抽象工厂模式

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

namespace Abstract_Factory
{
    class Program
    {
        static void Main(string[] args)
        {
            ClientManager Su = new ClientManager(new SuWeaponFactory());//苏联一方
            Su.CreateWeapon();

            Console.WriteLine("");

            ClientManager Usa = new ClientManager(new USAWeaponFactory());//美国一方
            Usa.CreateWeapon();

            Console.ReadKey();
        }
    }

    /// <summary>
    /// 制造飞机抽象类
    /// </summary>
    public abstract class CreateFighter
    {
        public CreateFighter()
        {
            Console.Write("战斗机：");
        }

        public abstract void createFighter();
    }

    /// <summary>
    /// 制造坦克抽象类
    /// </summary>
    public abstract class CreateTank
    {
        public CreateTank()
        {
            Console.Write("坦克：");
        }
        public abstract void createTank();
    }

    /// <summary>
    /// 兵工厂抽象类
    /// </summary>
    public abstract class WeaponFactory
    {
        public abstract CreateFighter createFighter();
        public abstract CreateTank createTank();

    }



    /// <summary>
    /// 制造苏式战机类
    /// </summary>
    public class SuCreateFighter : CreateFighter
    {
        public override void createFighter()
        {
            Console.WriteLine("Su30");
        }
    }

    /// <summary>
    /// 制造美式战机类
    /// </summary>
    public class USACreateFighter : CreateFighter
    {
        public override void createFighter()
        {
            Console.WriteLine("F16");
        }
    }

    /// <summary>
    /// 制造苏式坦克类
    /// </summary>
    public class SuCreateTank : CreateTank
    {
        public override void createTank()
        {
            Console.WriteLine("T90");
        }
    }

    /// <summary>
    /// 制造美式坦克类
    /// </summary>
    public class USACreateTank : CreateTank
    {
        public override void createTank()
        {
            Console.WriteLine("M1AI");
        }
    }

    /// <summary>
    /// 苏联兵工厂类
    /// </summary>
    public class SuWeaponFactory : WeaponFactory
    {
        public override CreateFighter createFighter()
        {
            return new SuCreateFighter();
        }
        public override CreateTank createTank()
        {
            return new SuCreateTank();
        }
    }
    /// <summary>
    /// 美国兵工厂类
    /// </summary>
    public class USAWeaponFactory : WeaponFactory
    {
        public override CreateTank createTank()
        {
            return new USACreateTank();
        }
        public override CreateFighter createFighter()
        {
            return new USACreateFighter();
        }
    }


    /// <summary>
    /// 客户端
    /// </summary>
    public class ClientManager
    {
        WeaponFactory weaponFactory;
        public ClientManager(WeaponFactory _weaponFactory)
        {
            this.weaponFactory = _weaponFactory;
        }
        /// <summary>
        /// 制造武器
        /// </summary>
        public void CreateWeapon()
        {
            CreateFighter fighter = weaponFactory.createFighter();
            fighter.createFighter();

            CreateTank tank = weaponFactory.createTank();
            tank.createTank();
        }
    }

}

Abstract Factory模式的几个要点：

1. 如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的静态工厂完全可以。

2. “系列对象”指的是这些对象之间有相互依赖、或作用的关系，例如游戏开发场景中的“道路”与“房屋”的依赖，“道路”与“地道”的依赖。

3. Abstract Factory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。

4. Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。