设计模式之抽象工厂模式（四）

动机

在软件系统中，常常面临着“一系列相互依赖的对象”的建立工做；同时，因为需求的变化，每每存在更多系列对象的建立工做。

如何应对这种变化？如何绕过常规的对象建立方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象建立工做”的紧耦合？

 

意图

提供一个接口，让该接口负责建立一系列“相关或者相互依赖的对象”，无需指定它们具体的类。

 

示意图

 

抽象工厂的代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 抽象工厂
{
    class Program
    {
        static void Main(string[] args)
        {
            Screen screen = null;
            Mouse mouse = null;
            ComputeShop shop = null;

            while (true)
            {
                Console.WriteLine("按下1键是购买dell产品，按下2键购买sam产品");
                int num = int.Parse(Console.ReadLine());
                switch (num)
                {
                    case 1: shop = new DellComputeShop(); break;
                    case 2: shop = new SamComputeShop(); break;
                    default:
                        shop = null;
                        Console.WriteLine("请点击1键或2键");
                        break;
                }
                if (shop!=null)
                {
                    screen = shop.SellScrenn();
                    mouse = shop.SellMouse();
                    string s = screen.ToString();
                    string m = screen.ToString();

                    Console.WriteLine("你购买了{0}和{1}", s, m);
                    
                }
                
               
                
            }
        }
    }

    public abstract class Screen
    { 
        
    
    }

    public abstract class Mouse
    { 
        
    }

    public class DellScreen : Screen
    {
        public override string ToString()
        {
            return "戴尔屏幕";
        }
    
    }

    public class SamScreen : Screen
    {
        public override string ToString()
        {
            return "三星屏幕";
        }
    }

    public class DellMouse : Mouse
    {
        public override string ToString()
        {
            return "戴尔鼠标";
        }
    }

    public class SamMouse : Mouse
    {
        public override string ToString()
        {
            return "三星鼠标";
        }
    
    }

    public abstract class ComputeShop
    {
        public abstract Screen SellScrenn();
        public abstract Mouse SellMouse();
    }

    public class DellComputeShop : ComputeShop
    {

        public override Screen SellScrenn()
        {
            return new DellScreen();
        }

        public override Mouse SellMouse()
        {
            return new DellMouse();
        }
    }

    public class SamComputeShop : ComputeShop
    {

        public override Screen SellScrenn()
        {
            return new SamScreen();
        }

        public override Mouse SellMouse()
        {
            return new SamMouse();
        }
    }

}
 

实现要点

抽象工厂将产品对象的建立延迟到它的具体工厂的子类。

一般在运行时刻建立一个具体工厂类的实例，这一具体工厂的建立具备特定实现的产品对象，为建立不一样的产品对象，客户应使用不一样的具体工厂。

把工厂做为单件，一个应用中通常每一个产品系列只需一个具体工厂的实例，所以，工厂一般最好实现为一个单件模式。

建立产品，抽象工厂仅声明一个建立产品的接口，真正建立产品是由具体工厂类建立的，最一般的一个办法是为每个产品定义一个工厂方法，一个具体的工厂将为每一个产品重定义该工厂方法以指定产品，虽然这样的实现很简单，但它要求每一个产品系列都要有一个新的具体工厂子类，即便这些产品系列的差异很小。

 

适用性

一个系统不该当依赖于产品类实例如何被建立、组合和表达的细节，这对于全部形态的工厂模式都是重要的。

这个系统有多于一个的产品族，而系统只消费其中某一产品族。

同属于同一个产品族的产品是在一块儿使用的，这一约束必须在系统的设计中体现出来。

系统提供一个产品类的库，全部的产品以一样的接口出现，从而使客户端不依赖于实现。

 

总结

若是没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的静态工厂彻底能够。

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

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

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

 

和简单工厂和工厂模式的比较

比较事例

一家门店,只卖一个系列产品:馒头(玉米满头,高粱馒头)
简单工厂

多家门店(分店),但还只卖一个系列产品(馒头)
工厂方法

多家门店,产品系列丰富:馒头(同上)+包子(芥菜包子,梅干菜包子)
抽象工厂

 

比较

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

Abstract Factory 模式解决“系列对象”的需求变化，

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