设计模式笔记之工厂方法模式

同上一篇，难免有错误，希望各位大牛及时指出~

这个模式类似于简单工厂的改良版。

大体的模型分四个：两个工厂，一个工厂基类（接口抽象具体都行？），一个几成基类的具体工厂类，产品同上一个。

这个模式的好处就在于new出产品的工厂方法不止在一个工厂类里面，而是每一个具体工厂类对应一个具体的产品，使得在添加删除产品的时候只需要添加删除类即可。

但是这个模式的缺点就是由于工厂产品类一定是成对出现的，所以占用空间，而且当产品很多的时候，会出现很多对工厂产品的类。

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

namespace ConsoleTempCS
{
    class Program
    {
        interface logger//产品接口 后面的产品都将继承这个接口
        {
            void writer();
        }
        class logger1 : logger//产品1
        {
            public void writer()//实现接口
            {
                Console.WriteLine("logger1 write()");
            }

        }
        class logger2 : logger//产品2
        {
            public void writer()//实现接口
            {
                Console.WriteLine("logger2 write()");
            }
        }
        interface factory//工厂接口，所有工厂都将继承这个接口
        {
            logger CreateLogger();
        }
        class factory1 : factory//工厂1，对应生产产品1
        {
            public logger CreateLogger()//生成产品1
            {
                logger1 l = new logger1();
                return l;
            }
        }
        class factory2 : factory//工厂2，对应生产产品2
        {
            public logger CreateLogger()//生成产品2
            {
                logger2 l = new logger2();
                return l;
            }
        }
        static void Main(string[] args)//客户测试端
        {
            factory f;
            logger l;
            f = new factory1();//这里选择工厂1
            l = f.CreateLogger();
            l.writer();
        }
    }
}

隐藏工厂方法，既在工厂类中添加一个方法，该方法中调用CreateLogger方法和产品的writer()方法。

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

namespace ConsoleTempCS
{
    class Program
    {
        interface logger//产品接口 后面的产品都将继承这个接口
        {
            void writer();
        }
        class logger1 : logger//产品1
        {
            public void writer()//实现接口
            {
                Console.WriteLine("logger1 write()");
            }

        }
        class logger2 : logger//产品2
        {
            public void writer()//实现接口
            {
                Console.WriteLine("logger2 write()");
            }
        }
        abstract class factory//不在设为接口的原因是 既然要隐藏CreateLogger方法就要把该方法属性设为protected 所以接口不再适用
        {
            abstract protected logger CreateLogger();
            abstract public void writer();
        }
        class factory1 : factory//工厂1，对应生产产品1
        {
            logger1 l;
            protected override logger CreateLogger()//生成产品1
            {
                logger1 l = new logger1();
                return l;
            }
            public override void writer()
            {
                l = CreateLogger() as logger1;
                l.writer();
            }
        }
        class factory2 : factory//工厂2，对应生产产品2
        {
            logger2 l;
            protected override logger CreateLogger()//生成产品2
            {
                logger2 l = new logger2();
                return l;
            }
            public override void writer()
            {
                l=CreateLogger() as logger2;
                l.writer();
            }
        }
        static void Main(string[] args)//客户测试端
        {
            factory f;
            f = new factory1();//这里选择工厂1
            f.writer();
        }
    }
}

这个模式的好处就在于new出产品的工厂方法不止在一个工厂类里面，而是每一个具体工厂类对应一个具体的产品，使得在添加删除产品的时候只需要添加删除类即可，无需更改父类，与简单工厂方法相同的是，客户无需知道产品的类名，只要知道工厂即可。

但是这个模式的缺点就是由于工厂产品类一定是成对出现的，所以占用空间，而且当产品很多的时候，会出现很多对工厂产品的类。