抽象工厂模式 The Abstract Factory Pattern

       抽象工厂模式——提供一个接口，用于创建相关或依赖对家的家族，而不需要明确指定具体类。（摘自《Head First Design Patterns》）      

以下是自已用VS画了一个简图：

       创建抽象工厂接口：

      

public interface IPropertyFactory

    {

        string CreateIce();



        string CreateFire();



        string CreateWind();

    }

       实现二个属性工厂：

      

class Level1Factory : IPropertyFactory

    {

        #region IPropertyFactory 成员



        public string CreateIce()

        {

            return "1级冰属性";

        }



        public string CreateFire()

        {

            return "1级火属性";

        }



        public string CreateWind()

        {

            return "1级风属性";

        }



        #endregion

    }



class Level2Factory : IPropertyFactory

    {

        #region IPropertyFactory 成员



        public string CreateIce()

        {

            return "2级冰属性";

        }



        public string CreateFire()

        {

            return "2级火属性";

        }



        public string CreateWind()

        {

            return "2级风属性";

        }



        #endregion

    }

       创建武器基类，含有一个属性工厂：

      

public abstract class Weapon

    {

        protected string Name = string.Empty;

        protected string Property = string.Empty;



        protected IPropertyFactory PropertyFactory;



        protected abstract void Process();

        public void Show()

        {

            Process();

            Console.WriteLine(string.Format("这是一把{0},附加了{1}", Name, Property));

        }

    }

       实现二个武器：

      

class Sword : Weapon

    {

        public Sword(IPropertyFactory factory)

        {

            this.PropertyFactory = factory;

        }



        protected override void Process()

        {

            this.Name = "剑";

            this.Property = string.Format("{0} {1}", this.PropertyFactory.CreateWind(), this.PropertyFactory.CreateIce());

        }

    }



class Axe : Weapon

    {

        public Axe(IPropertyFactory factory)

        {

            this.PropertyFactory = factory;

        }

    

        protected override void Process()

        {

            this.Name = "斧子";

            this.Property = string.Format("{0} {1}", this.PropertyFactory.CreateFire(), this.PropertyFactory.CreateIce());

        }

    }

       开始测试抽象工厂：

      

            IPropertyFactory level1Factory = new Level1Factory();

            IPropertyFactory level2Factory = new Level2Factory();

            Weapon sword1 = new Sword(level1Factory);

            Weapon sword2 = new Sword(level2Factory);

            sword1.Show();

            sword2.Show();

            Weapon axe1 = new Axe(level1Factory);

            Weapon axe2 = new Axe(level2Factory);

            axe1.Show();

            axe2.Show();

             测试中分别创建了一级和二级属性工厂，在实例化武器时把工厂加入，不同的工厂就产生了不同的效果，输出结果：

       这是一把剑,附加了1级风属性 1级冰属性

        这是一把剑,附加了2级风属性 2级冰属性

       这是一把斧子,附加了1级火属性 1级冰属性

        这是一把斧子,附加了2级火属性 2级冰属性

       简单的抽象工厂至此介绍完毕，下面结合一下工厂方法模式：

       创建一个武器工厂基类，含有一个属性工厂：

      

public abstract class WeaponFactory

    {

        protected IPropertyFactory PropertyFactory;

    

        public abstract Weapon CreateWeapon(string typeName);

    }

       实现一个普通工厂和一个超级工厂，超级工厂又多含有一个属性工厂，以便能生产不同级别的武器：

      

class NormalFactory : WeaponFactory

    {

        public NormalFactory()

        {

            this.PropertyFactory = new Level1Factory();

        }

    

        public override Weapon CreateWeapon(string typeName)

        {

            switch (typeName)

            {

                case "sword":

                    return new Sword(this.PropertyFactory);

                case "axe":

                    return new Axe(this.PropertyFactory);

            }

            return null;

        }

    }



class SuperFactory : WeaponFactory

    {

        protected IPropertyFactory PropertyFactory2;



        public SuperFactory()

        {

            this.PropertyFactory = new Level1Factory();

            this.PropertyFactory2 = new Level2Factory();

        }

    

        public override Weapon CreateWeapon(string typeName)

        {

            switch (typeName)

            {

                case "sword":

                    return new Sword(this.PropertyFactory);

                case "supersword":

                    return new Sword(this.PropertyFactory2);

                case "axe":

                    return new Axe(this.PropertyFactory);

                case "superaxe":

                    return new Axe(this.PropertyFactory2);

            }

            return null;

        }

    }

             接下来用新的工厂来生产武器：             

WeaponFactory normalFactory = new NormalFactory();

            WeaponFactory superFactory = new SuperFactory();

            //使用普通工厂

            Weapon sword = normalFactory.CreateWeapon("sword");

            Weapon axe = normalFactory.CreateWeapon("axe");

            sword.Show();

            axe.Show();



            //使用超级工厂

            Weapon superSword = superFactory.CreateWeapon("supersword");

            Weapon superAxe = superFactory.CreateWeapon("superaxe");

            superSword.Show();

            superAxe.Show();

            //超级工厂能创建普通工厂的产品

            Weapon normalSword = superFactory.CreateWeapon("sword");

            Weapon normalAxe = superFactory.CreateWeapon("axe");

            normalSword.Show();

            normalAxe.Show();

             普通工厂只能生产一级武器，而超级工厂能生产一级和二级武器，输出结果：

             这是一把剑,附加了1级风属性 1级冰属性

             这是一把斧子,附加了1级火属性 1级冰属性

           这是一把剑,附加了2级风属性 2级冰属性

            这是一把斧子,附加了2级火属性 2级冰属性

             这是一把剑,附加了1级风属性 1级冰属性

             这是一把斧子,附加了1级火属性 1级冰属性

工厂方法模式和抽象工厂结合就产生了这样的效果，有阐述的不对之处，还请大家指出。