设计模式之工厂方法模式

场景：大学生和志愿者都学雷锋做好事，不排除将来有别的职业的人（工人，老师等）也加入到学雷锋的行业

简单工厂实现：

//一个雷锋公共类，具体方法房子公共类里面
    class LeiFeng
    {
        public void Sweep()
        {

        }
        public void Wash()
        {

        }
        public void BuyRice()
        {

        }
    }
    //学雷锋的大学生
    class Undergraduate : LeiFeng { }

    //学雷锋的志愿者
    class Volunteer : LeiFeng { }

    class Factory
    {
        public static LeiFeng CreateFactory(int type)
        {
            LeiFeng model = null;
            //简单工厂弊端，现在是大学生和志愿者做好事，需要其他类型时，需要修改工厂，破坏了开闭原则
            switch (type)
            {
                case 1:
                    model = new Undergraduate();
                    break;
                case 2:
                    model = new Volunteer();
                    break;
                //再增加别的需要单独修改
            }
            return model;
        }
    }

 static void Main(string[] args)
        {
            //被帮助的人不需要知道是谁做了好事，只知道是学雷锋就行了
            //无论是1，还是2，都是做好事的人
            LeiFeng studentA = Factory.CreateFactory(1);
            studentA.Sweep();

            LeiFeng personA = Factory.CreateFactory(2);
            personA.Wash();
        }

缺乏扩展性，如果增加工人也来学雷锋，需要先增加一个工人类，然后再修改工厂。
简单工厂最大的优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相应的类，对客户端来说，去除了与具体产品的依赖。

工厂方法模式：

//一个雷锋公共类，具体方法房子公共类里面
    class LeiFeng
    {
        public void Sweep()
        {

        }
        public void Wash()
        {

        }
        public void BuyRice()
        {

        }
    }
    //学雷锋的大学生
    class Undergraduate : LeiFeng { }

    //学雷锋的志愿者
    class Volunteer : LeiFeng { }

    //新增一个职业时： 学雷锋的工人
    class Worker:LeiFeng{ }
    //雷锋工厂
    interface IFactory
    {
        LeiFeng CreateLeiFeng();
    }
    //学雷锋的大学生 的工厂
    class UndergraduateFactory : IFactory
    {
        public LeiFeng CreateLeifeng()
        {
            return new Undergraduate(); //实现接口，对应指定的大学生类
        }
    }
    //社区志愿者 的工厂
    class VolunteerFactory : IFactory
    {
        public LeiFeng CreateLeifeng()
        {
            return new Volunteer(); //实现接口，对应指定的志愿者类
        }
    }
    //新增一个职业时：新增一个工厂
    class WorkerFactory : IFactory
    {
        public LeiFeng CreateLeifeng()
        {
            return new Worker();
        }
    }

 static void Main(string[] args)
        {
            //在客户端选择要使用的子类工厂，从而避免了增加CASE语句的问题
            //大学生来帮助
            IFactory factory = new UndergraduateFactory();
            //被帮助的人只知道是被雷锋帮助了，并不需要具体知道是大学生，还是工人，还是志愿者
            LeiFeng person = factory.CreateLeiFeng();
            person.Sweep();

            //志愿者来帮助
            IFactory factoryVolunteer = new VolunteerFactory();
            LeiFeng person2 = factoryVolunteer.CreateLeiFeng();
            person2.Wash();
        }

总结：工厂模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行，如果想要增加功能，那么需要增加工厂并且修改客户端。一定程度上缓解了耦合度。工厂模式是简单工厂的进一步抽象和推广。

缺点：每增加一个产品，就需要对应增加一个产品工厂的类。