抽象工厂模式(Abstract Factory)

 

抽象工厂模式

概述

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

意图

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

特点

1)        抽象工厂就是对象的创建

2)        它的特色就是可以生产超过一种类型的对象

3)        客户端创建的对象，只需要对象的接口，而不是具体执行操作的对象

4)        抽象工厂创建的不同类型的对象是相互关联的，他们来自与共同的家族

5)        抽象工厂隔离的具体的类

6)        它可以使交换家族的产品变的非常容易

7)        它提倡产品之间的一致性

8)        它支持增加新的产品和族

实例

类图

 

代码

using  System;

using  System.Collections.Generic;

using  System.Text;

using  System.Reflection;

 

namespace  Wage

{

    /**//// <summary>

    /// 动态创建工厂类

    /// </summary>

    public class Make

    {

        public IWageFactory MakeCreate(string xWhat)

        {

            //动态创建工厂

            return (IWageFactory)Assembly.Load("Wage").CreateInstance("Wage." + xWhat);

        }

    }

 

    class Program

    {

        static void Main(string[] args)

        {

            //xWhat，要创建工厂的类型，这里选择中国

            //实际运用中，我们可以根据配置文件读取

            string xWhat = "ChineseFactory";

            Make make = new Make();

 

            //接口定义

            IWageFactory wageFactory;

            IBonus bonus;

            ITax tax;

            wageFactory = make.MakeCreate(xWhat);

            bonus = wageFactory.CreateBonus();

            tax = wageFactory.CreateTax();

 

            //奖金、税收

            double dBonus = bonus.Calculate();

            double dTax = tax.Calculate();

            System.Console.WriteLine(dBonus.ToString());

            System.Console.WriteLine(dTax.ToString());

        }

    }

    

    /**//// <summary>

    /// 工资计算工厂接口

    /// </summary>

    public interface IWageFactory

    {

        IBonus CreateBonus();

        ITax CreateTax();

    }

 

    /**//// <summary>

    /// 中国工资计算工厂类

    /// </summary>

    public class ChineseFactory : IWageFactory

    {

        public IBonus CreateBonus()

        {

            return new ChineseBonus();

        }

        public ITax CreateTax()

        {

            return new ChineseTax();

        }

    }

 

    /**//// <summary>

    /// 美国工资计算工厂类

    /// </summary>

    public class AmericanFactory : IWageFactory

    {

        public IBonus CreateBonus()

        {

            return new AmericanBonus();

        }

        public ITax CreateTax()

        {

            return new AmericanTax();

        }

    }

 

    /**//// <summary>

    /// 奖金接口

    /// </summary>

    public interface IBonus

    {

        double Calculate();

    }

 

    /**//// <summary>

    /// 税收接口

    /// </summary>

    public interface ITax

    {

        double Calculate();

    }

 

    /**//// <summary>

    /// 中国的奖金类

    /// </summary>

    public class ChineseBonus:IBonus

    {

        public double Calculate()

        {

            return 2000 * 0.1;

        }

    }

 

    /**//// <summary>

    /// 中国的税收类

    /// </summary>

    public class ChineseTax:ITax

    {

        public double Calculate()

        {

            return 2000 * 0.2;

        }

    }

 

    /**//// <summary>

    /// 美国的奖金类

    /// </summary>

    public class AmericanBonus : IBonus

    {

        public double Calculate()

        {

            return 4000 * 0.3;

        }

    }

 

    /**//// <summary>

    /// 美国的税收类

    /// </summary>

    public class AmericanTax : ITax

    {

        public double Calculate()

        {

            return 4000 * 0.4;

        }

    }

}

 另外一个关于点、线、面的例子：

namespace  GeoFactory
{
    /**//// <summary>
    /// 抽象的几何工厂类
    /// </summary>
    public abstract class GeoAbstractFactory
    {
        public abstract GeoAbstratorPoint CreatePoint();
        public abstract GeoAbstractLine CreateLine();
        public abstract GeoAbstractPolygon CreatePolygon();
    }

    /**//// <summary>
    /// 具体工厂类A
    /// </summary>
    public class GeoFactoryA : GeoAbstractFactory
    {
        public override GeoAbstratorPoint CreatePoint()
        {
            return new GeoPointA();
        }
        public override GeoAbstractLine CreateLine()
        {
            return new GeoLineA();
        }
        public override GeoAbstractPolygon CreatePolygon()
        {
            return new GeoPolygonA();
        }
    }

    public class GeoFactoryB : GeoAbstractFactory
    {
        public override GeoAbstratorPoint CreatePoint()
        {
            return new GeoPointB();
        }
        public override GeoAbstractLine CreateLine()
        {
            return new GeoLineB();
        }
        public override GeoAbstractPolygon CreatePolygon()
        {
            return new GeoPolygonB();
        }
    }

    public abstract class GeoAbstratorPoint
    {
        public abstract void Draw();
    }

    public class GeoPointA : GeoAbstratorPoint
    {
        public override void Draw()
        {
            System.Console.WriteLine("The PointA has beening drawn.");
        }
    }

    public class GeoPointB : GeoAbstratorPoint
    {
        public override void Draw()
        {
            System.Console.WriteLine("The PointB has beening drawn.");
        }
    }

    public abstract class GeoAbstractLine
    {
        public abstract void Draw();
    }

    public class GeoLineA : GeoAbstractLine
    {
        public override void Draw()
        {
            System.Console.WriteLine("The LineA has beening drawn.");
        }
    }

    public class GeoLineB : GeoAbstractLine
    {
        public override void Draw()
        {
            System.Console.WriteLine("The LineB has beening drawn.");
        }
    }

    public abstract class GeoAbstractPolygon
    {
        public abstract void Draw();
    }

    public class GeoPolygonA : GeoAbstractPolygon
    {
        public override void Draw()
        {
            System.Console.WriteLine("The PolygonA has beening drawn.");
        }
    }

    public class GeoPolygonB : GeoAbstractPolygon
    {
        public override void Draw()
        {
            System.Console.WriteLine("The PolygonB has beening drawn.");
        }
    }
}

namespace  CsharpAbstractFactory
{
    using System.Reflection;
    using GeoFactory;

    public static class ChoseFactory
    {
        public static GeoAbstractFactory CreateFactory(string factoryName)
        {
            return (GeoAbstractFactory)Assembly.Load("GeoFactory").CreateInstance("GeoFactory." + factoryName);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            GeoAbstractFactory factory = ChoseFactory.CreateFactory("GeoFactoryA");

            GeoAbstratorPoint point = factory.CreatePoint();
            GeoAbstractLine line = factory.CreateLine();
            GeoAbstractPolygon polygon = factory.CreatePolygon();

            point.Draw();
            line.Draw();
            polygon.Draw();

            System.Console.ReadLine();
        }
    }

}

总结

抽象工厂模型可以采用接口，也可以采用抽象类，这两种方法都可以。在具体的运用中，我们要灵活对待，当然，这也和个人的习惯有关。上面的例子是我在TerryLee's Tech Space的博客里看的，他采用的是抽象类，在这里我采用的是接口，并给出了类图，希望对大家有所帮助。

转载于:https://www.cnblogs.com/mjgforever/archive/2006/08/08/471078.html