创作型---抽象工厂模式

抽象工厂详细介绍

具体代码:

namespace ConsoleApplication1
{
    /// <summary>
    /// 抽象产品A类
    /// </summary>
    public abstract class AbstractProductA
    {
        //每个产品共有的方法
        public void shareMethod()
        {
        }
        //每个产品相同方法,不同实现
        public abstract void doSomething();
    }

    public class ProductA1 : AbstractProductA
    {
        public override void doSomething()
        {
            Console.WriteLine("产品A1的实现方法");
        }
    }

    public class ProductA2 : AbstractProductA
    {
        public override void doSomething()
        {
            Console.WriteLine("产品A2的实现方法");
        }
    }

    /// <summary>
    /// 抽象产品A类
    /// </summary>
    public abstract class AbstractProductB
    {
        //每个产品共有的方法
        public void shareMethod()
        {
        }
        //每个产品相同方法,不同实现
        public abstract void doSomething();
    }

    public class ProductB1 : AbstractProductB
    {
        public override void doSomething()
        {
            Console.WriteLine("产品B1的实现方法");
        }
    }

    public class ProductB2 : AbstractProductB
    {
        public override void doSomething()
        {
            Console.WriteLine("产品B2的实现方法");
        }
    }

    /// <summary>
    /// 抽象工厂类
    /// </summary>
    public abstract class AbstractCreator
    {
        //注意:有N个产品族,在抽象工厂类中就应该有N个创建方法

        //创建A产品家族
        public abstract AbstractProductA CreateProdcutA();
        //创建B产品家族
        public abstract AbstractProductB CreateProdcutB();
    }

    /// <summary>
    /// 产品等级1的实现类
    /// </summary>
    public class Creator1 : AbstractCreator
    {
        //只生产产品等级为1的A产品
        public override AbstractProductA CreateProdcutA()
        {
            return new ProductA1();
        }
        //只生产产品等级为1的B产品
        public override AbstractProductB CreateProdcutB()
        {
            return new ProductB1();
        }
    }

    /// <summary>
    /// 产品等级2的实现类
    /// </summary>
    public class Creator2 : AbstractCreator
    {
        //只生产产品等级为1的A产品
        public override AbstractProductA CreateProdcutA()
        {
            return new ProductA2();
        }
        //只生产产品等级为1的B产品
        public override AbstractProductB CreateProdcutB()
        {
            return new ProductB2();
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            //定义出两个工厂
            AbstractCreator creator1 = new Creator1();
            AbstractCreator creator2 = new Creator2();

            //产生A1对象
            AbstractProductA a1 = creator1.CreateProdcutA();
            //产生A2对象
            AbstractProductA a2 = creator2.CreateProdcutA();
            //产生B1对象
            AbstractProductB b1 = creator1.CreateProdcutB();
            //产生B2对象
            AbstractProductB b2 = creator2.CreateProdcutB();


            Console.ReadLine();
        }
    }
}

抽象工厂的分析

抽象工厂模式将具体产品的创建延迟到具体工厂的子类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而使系统耦合度低，这样更有利于后期的维护和扩展，这真是抽象工厂模式的优点所在，然后抽象模式同时也存在不足的地方。下面就具体看下抽象工厂的缺点（缺点其实在前面的介绍中以已经涉及了）：

抽象工厂模式很难支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可以被创建的产品集合，如果需要添加新产品，此时就必须去修改抽象工厂的接口，这样就涉及到抽象工厂类的以及所有子类的改变，这样也就违背了“开发——封闭”原则。

知道了抽象工厂的优缺点之后，也就能很好地把握什么情况下考虑使用抽象工厂模式了，下面就具体看看使用抽象工厂模式的系统应该符合那几个前提：

• 一个系统不要求依赖产品类实例如何被创建、组合和表达的表达，这点也是所有工厂模式应用的前提。
• 这个系统有多个系列产品，而系统中只消费其中某一系列产品
• 系统要求提供一个产品类的库，所有产品以同样的接口出现，客户端不需要依赖具体实现。

 

抽象工厂模式的优缺点

 　　抽象工厂模式具有以下优点：

• 封装性,每个产品的实现类不是高层模块要关心的,它要关心的是接口、抽象,它不关心对象是如何创建出来。
• 产品族内的约束为非公开状态。

　　缺点：

• 产品族扩展非常困难,以通用代码为例,如果要增加一个产品C,也就是说产品家族由原来的2个增加到3个,那么就需要在抽象类AbstractCreator增加一个方法createProductC(),然后两个实现类(Creator1,Creator2)要修改。

 

抽象工厂模式的使用场景

 　　抽象工厂模式的使用场景:一个对象族(或是一组没有任何关系的对象)都有相同的约束,则可以使用抽象工厂模式

       例如一个文件编辑器和一个图片处理器,都是软件实体,但是在Linx和Windows下虽然功能和界面相同,但是代码实现是不同的,于是就可以使用抽象工厂模式

抽象工厂的具体实现

下面就以生活中 “绝味” 连锁店的例子来实现一个抽象工厂模式。例如，绝味鸭脖想在江西南昌和上海开分店，但是由于当地人的口味不一样，在南昌的所有绝味的东西会做的辣一点，而上海不喜欢吃辣的，所以上海的所有绝味的东西都不会做的像南昌的那样辣，然而这点不同导致南昌绝味工厂和上海的绝味工厂生成所有绝味的产品都不同，也就是某个具体工厂需要负责一系列产品(指的是绝味所有食物)的创建工作，下面就具体看看如何使用抽象工厂模式来实现这种情况。

抽象工厂模式：提供一个创建产品的接口来负责创建相关或依赖的对象，而不具体明确指定具体类

抽象工厂允许客户使用抽象的接口来创建一组相关产品，而不需要知道或关心实际生产出的具体产品是什么。这样客户就可以从具体产品中被解耦。下面通过抽象工模式的类图来了解各个类中之间的关系：

具体代码实现:

namespace TempApplication
{
    /// <summary>
    /// 下面以绝味鸭脖连锁店为例子演示下抽象工厂模式
    /// 因为每个地方的喜欢的口味不一样，有些地方喜欢辣点的，有些地方喜欢吃不辣点
    /// 客户端调用
    /// </summary>
    class Client
    {
        static void Main(string[] args)
        {
            // 南昌工厂制作南昌的鸭脖和鸭架
            AbstractFactory nanChangFactory = new NanChangFactory();
            YaBo nanChangYabo = nanChangFactory.CreateYaBo();
            nanChangYabo.Print();
            YaJia nanChangYajia = nanChangFactory.CreateYaJia();
            nanChangYajia.Print();

            // 上海工厂制作上海的鸭脖和鸭架
            AbstractFactory shangHaiFactory = new ShangHaiFactory();
            shangHaiFactory.CreateYaBo().Print();
            shangHaiFactory.CreateYaJia().Print();

            Console.Read();
        }
    }

    /// <summary>
    /// 抽象工厂类，提供创建两个不同地方的鸭架和鸭脖的接口
    /// </summary>
    public abstract class AbstractFactory
    {
        // 抽象工厂提供创建一系列产品的接口，这里作为例子，只给出了绝味中鸭脖和鸭架的创建接口
        public abstract YaBo CreateYaBo();
        public abstract YaJia CreateYaJia();
    }

    /// <summary>
    /// 南昌绝味工厂负责制作南昌的鸭脖和鸭架
    /// </summary>
    public class NanChangFactory : AbstractFactory
    {
        // 制作南昌鸭脖
        public override YaBo CreateYaBo()
        {
            return new NanChangYaBo();
        }
        // 制作南昌鸭架
        public override YaJia CreateYaJia()
        {
            return new NanChangYaJia();
        }
    }

    /// <summary>
    /// 上海绝味工厂负责制作上海的鸭脖和鸭架
    /// </summary>
    public class ShangHaiFactory : AbstractFactory
    {
        // 制作上海鸭脖
        public override YaBo CreateYaBo()
        {
            return new ShangHaiYaBo();
        }
        // 制作上海鸭架
        public override YaJia CreateYaJia()
        {
            return new ShangHaiYaJia();
        }
    }

    /// <summary>
    /// 鸭脖抽象类，供每个地方的鸭脖类继承
    /// </summary>
    public abstract class YaBo
    {
        /// <summary>
        /// 打印方法，用于输出信息
        /// </summary>
        public abstract void Print();
    }

    /// <summary>
    /// 鸭架抽象类，供每个地方的鸭架类继承
    /// </summary>
    public abstract class YaJia
    {
        /// <summary>
        /// 打印方法，用于输出信息
        /// </summary>
        public abstract void Print();
    }

    /// <summary>
    /// 南昌的鸭脖类，因为江西人喜欢吃辣的，所以南昌的鸭脖稍微会比上海做的辣
    /// </summary>
    public class NanChangYaBo : YaBo
    {
        public override void Print()
        {
            Console.WriteLine("南昌的鸭脖");
        }
    }

    /// <summary>
    /// 上海的鸭脖没有南昌的鸭脖做的辣
    /// </summary>
    public class ShangHaiYaBo : YaBo
    {
        public override void Print()
        {
            Console.WriteLine("上海的鸭脖");
        }
    }

    /// <summary>
    /// 南昌的鸭架
    /// </summary>
    public class NanChangYaJia : YaJia
    {
        public override void Print()
        {
            Console.WriteLine("南昌的鸭架子");
        }
    }

    /// <summary>
    /// 上海的鸭架
    /// </summary>
    public class ShangHaiYaJia : YaJia
    {
        public override void Print()
        {
            Console.WriteLine("上海的鸭架子");
        }
    }
}

抽象工厂应对需求变更

看完上面抽象工厂的实现之后，如果 “绝味”公司又想在湖南开一家分店怎么办呢？ 因为湖南人喜欢吃麻辣的，下面就具体看看应用了抽象工厂模式的系统是如何应对这种需求的。

    /// <summary>
    /// 如果绝味又想开一家湖南的分店时，因为湖南喜欢吃麻的
    /// 所以这是有需要有一家湖南的工厂专门制作
    /// </summary>
    public class HuNanFactory : AbstractFactory
    {
        // 制作湖南鸭脖
        public override YaBo CreateYaBo()
        {
            return new HuNanYaBo();
        }

        // 制作湖南鸭架
        public override YaJia CreateYaJia()
        {
            return new HuNanYajia();
        }
    }

    /// <summary>
    /// 湖南的鸭脖
    /// </summary>
    public class HuNanYaBo : YaBo
    {
        public override void Print()
        {
            Console.WriteLine("湖南的鸭脖");
        }
    }

    /// <summary>
    /// 湖南的鸭架
    /// </summary>
    public class HuNanYajia : YaJia
    {
        public override void Print()
        {
            Console.WriteLine("湖南的鸭架子");
        }
    }