工厂方法模式

姓名：赵汉青

学号：07770201

 

模式名称：工厂方法模式

1．问题描述

生活场景：很多的公司都通过生产不同品牌的同一类产品来占有市场，比如，联合利华公司生产洗发水，开始只有“夏士莲”系列，后来为了在洗发水市场上扩充份额，又推出了“清扬”系列。你会发现，不管是“清扬”还是“夏士莲”，有着相同的功能——洗发，它们在生产的过程中也有很多共同的地方。

 

设计目的：实现对具有共性的产品的创建。

 

 

2．不假思索的思路

思路描述：在生产“夏士莲”洗发水的工厂里增加一条生产“清扬”洗发水的生产线，以实现“清扬”洗发水的生产。

 

 

类结构图：

缺点：这样的设计，工厂类集中了所有的实例的创建逻辑，违反了单一职责原则，即每一个类都只负责一件具体的事情；同时，当产品不断增多时，可能会出现要求工厂类根据不同条件创建不同实例的需求，工厂类就无法满足需求，不利于后续的扩充和维护。

代码：

abstract class Shampoo   //抽象的洗发水类

        {

            public abstract void produce();

        }

 

        class HAZELINE : Shampoo  //“清扬”洗发水，继承抽象洗发水类

        {

            public override void produce()

            {

                Console.WriteLine("夏士莲洗发水");

            }

        }

 

        class CLEAR : Shampoo  //“夏士莲”洗发水，继承抽象洗发水类

        {

            public override void produce()

            {

                Console.WriteLine("清扬洗发水");

            }

        }

 

        class ShampooFactory  //洗发水工厂类

        {

            /// <summary>

            /// 用户传入不同的洗发水名称，创建不同类型的洗发水

            /// </summary>

            /// <param name="type">洗发水名称</param>

            /// <returns>返回创建好的洗发水对象</returns>

            public Shampoo createShampoo(string type)

            {

                switch (type.ToLower())

                {

                    case "clear": return new CLEAR();

                    case "hazeline": return new HAZELINE();

                    default: return null;

                }

            }

        }

 

        static void Main(string[] args)

        {

            Shampoo shampoo;

            ShampooFactory shampoofactory = new ShampooFactory();

            shampoo = shampoofactory.createShampoo("hazeline"); //告诉工厂生产“夏士莲”

            shampoo.produce();

            shampoo = shampoofactory.createShampoo("clear");//告诉工厂生产“清扬”

            shampoo.produce();

        }

3．归纳阶段:

思路描述：通过工厂方法模式进行处理：为每种系列的产品建立属于自己的工厂，各种工厂之间是有共性的，可以继承一个抽象的工厂类；各种产品之间也是有共性的，可以继承一个抽象的产品类。

 

类结构图：

代码：

abstract class Shampoo   //抽象的洗发水类

        {

            public abstract void produce();

        }

 

        class HAZELINE : Shampoo  //“清扬”洗发水，继承抽象洗发水类

        {

            public override void produce()

            {

                Console.WriteLine("夏士莲洗发水");

            }

        }

 

        class CLEAR : Shampoo  //“夏士莲”洗发水，继承抽象洗发水类

        {

            public override void produce()

            {

                Console.WriteLine("清扬洗发水");

            }

        }

 

        abstract class Factory  //抽象的洗发水工厂类

        {

            public abstract Shampoo createShampoo();

        }

 

        class HAZELINEfactory : Factory //“夏士莲”洗发水工厂，继承抽象洗发水工厂

        {

            public override Shampoo createShampoo()

            {

                Console.Write("生产：");

                return new HAZELINE();

            }

        }

 

 

        class CLEARfactory : Factory //“清扬”洗发水工厂，继承抽象洗发水工厂

        {

            public override Shampoo createShampoo()

            {

                Console.Write("生产：");

                return new CLEAR();

            }

        }

 

        static void Main(string[] args)

        {

            Shampoo shampoo;

            Factory factory = new HAZELINEfactory();  //实例化“夏士莲”工厂

            shampoo = factory.createShampoo();        //“夏士莲”工厂只创造夏士莲洗发水

            shampoo.produce();

            factory = new CLEARfactory();             //实例化“清扬”工厂

            shampoo = factory.createShampoo();        //“清扬”工厂只创造清扬洗发水

            shampoo.produce();

        }

设计体会：

这样的设计降低了工厂类的内聚，满足了类之间的层次关系，又很好的符合了面向对象设计中的单一职责原则，即每一个类都只负责一件具体的事情。当有新的产品加入时，只需要分别继承抽象的工厂类和抽象的产品类，不会对其它产品有任何影响。

4．验证阶段

思路描述：结合上面的例子，增加一个洗发水产品：“力士”

 

类结构图：

代码：

abstract class Shampoo   //抽象的洗发水类

        {

            public abstract void produce();

        }

 

        class HAZELINE : Shampoo  //“清扬”洗发水，继承抽象洗发水类

        {

            public override void produce()

            {

                Console.WriteLine("夏士莲洗发水");

            }

        }

 

        class CLEAR : Shampoo  //“夏士莲”洗发水，继承抽象洗发水类

        {

            public override void produce()

            {

                Console.WriteLine("清扬洗发水");

            }

        }

 

        class LUX : Shampoo  //"力士洗发水",继承抽象洗发水类

        {

            public override void produce()

            {

                Console.WriteLine("力士洗发水");

            }

        }

 

        abstract class Factory  //抽象的洗发水工厂类

        {

            public abstract Shampoo createShampoo();

        }

 

        class HAZELINEfactory : Factory //“夏士莲”洗发水工厂，继承抽象洗发水工厂

        {

            public override Shampoo createShampoo()

            {

                Console.Write("生产：");

                return new HAZELINE();

            }

        }

 

 

        class CLEARfactory : Factory //“清扬”洗发水工厂，继承抽象洗发水工厂

        {

            public override Shampoo createShampoo()

            {

                Console.Write("生产：");

                return new CLEAR();

            }

        }

 

        class LUXfactory : Factory  //“力士”洗发水工厂，继承抽象洗发水工厂

        {

            public override Shampoo createShampoo()

            {

                Console.Write("生产：");

                return new LUX();

            }

        }

 

        static void Main(string[] args)

        {

            Shampoo shampoo;

            Factory factory = new HAZELINEfactory();  //实例化“夏士莲”工厂

            shampoo = factory.createShampoo();        //“夏士莲”工厂只创造夏士莲洗发水

            shampoo.produce();

            factory = new CLEARfactory();             //实例化“清扬”工厂

            shampoo = factory.createShampoo();        //“清扬”工厂只创造清扬洗发水

            shampoo.produce();

            factory = new LUXfactory();               //实例化“力士”工厂

            shampoo = factory.createShampoo();        //“力士”工厂只创造力力士洗发水

            shampoo.produce();

        }

 

 

5．抽象描述

思路描述：把“共性”提取出来，根据各自的“个性”建立各自的继承共性的实现。

 

类结构图:

转载于:https://www.cnblogs.com/tjcjxy/archive/2010/10/21/1857886.html