工厂模式

#include <stdio.h>
#include <iostream>
using namespace std;
class LeiFeng {
    
public:
    void Sweep(){cout<<"sweep"<<endl;}
    void Wash(){cout<<"wash"<<endl;}
    void BuyRice(){cout<<"byerice"<<endl;}
    
};

class Undergraduate:public LeiFeng {
};

class Volunteer: public LeiFeng {
};

class SampleFactory {
public:
    static LeiFeng * CreateLeiFeng(int type)
    {
        LeiFeng * result = NULL;
        switch (type) {
            case 1:
                result = new Undergraduate();
                break;
                case 2:
                result = new Volunteer();
                break;
            default:
                break;
        }
        return  result;
    }
};


class IFactory {
    
public:
    virtual ~IFactory(){};
    virtual LeiFeng * CreateLeiFeng() = 0;
};

class UndergraduateFactory:public IFactory {
    
public:
    LeiFeng * CreateLeiFeng(){
        return new Undergraduate();
    }
};

class VolunteerFactory:public IFactory{
    
public:
    LeiFeng * CreateLeiFeng(){
        return new Volunteer();
    }
};

void testLesson5(){
    //sample factory
    LeiFeng * student1 = SampleFactory::CreateLeiFeng(graduate);
    LeiFeng * student2 = SampleFactory::CreateLeiFeng(graduate);
    LeiFeng * student3 = SampleFactory::CreateLeiFeng(graduate);
    student1->Wash();
    student2->Sweep();
    student3->Wash();
    
    IFactory * factory = new UndergraduateFactory();
    LeiFeng * student = factory->CreateLeiFeng();
    student->BuyRice();
    student->Sweep();
    student->Wash();

}

重要概念

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑，根据客户端的选择条件动态实例化相关类，对客户端来说，去处了对产品的依赖

工厂方法模式，定义了一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到子类

好处就是能一次性改掉想改的东西，如果一个一个的去创建，那就比较蛋疼了