[大话设计模式C++版] 第8章 雷锋依然在人间 —— 工厂方法模式

源码可以在这里找到 大话设计模式C++版

模拟大学生学雷锋

//main.cpp
class LeiFeng {
public:
    void Sweep() {
        cout << "扫地" << endl;
    }
    void Wash() {
        cout << "洗衣" << endl;
    }
    void BuyRice() {
        cout << "买米" << endl;
    }
};

class Undergraduate : public LeiFeng {};

int main(int argc, char *argv[])
{
    //一个大学生完成买米，扫地，洗衣
    LeiFeng* xueleifeng = new Undergraduate();
    xueleifeng->BuyRice();
    xueleifeng->Sweep();
    xueleifeng->Wash();
    
    //三个大学生完成买米，扫地，洗衣
    LeiFeng* student1 = new Undergraduate();
    student1->BuyRice();
    LeiFeng* student2 = new Undergraduate();
    student2->Sweep();
    LeiFeng* student3 = new Undergraduate();
    student3->Wash();

    return 0;
}

老人不关心来的人是谁，只需要知道是志愿者学雷锋就行

简单工厂生产雷锋

#include <iostream>

using namespace std;

class LeiFeng {
public:
    void Sweep() {
        cout << "扫地" << endl;
    }
    void Wash() {
        cout << "洗衣" << endl;
    }
    void BuyRice() {
        cout << "买米" << endl;
    }
};

class Undergraduate : public LeiFeng {};

class Volunteer : public LeiFeng {};

enum LeiFengType {
    UNDERGRADUATE = 0,
    VOLUNTEER
};

class SimpleFactory {
public:
    static LeiFeng* CreateLeiFeng(LeiFengType type) {
        LeiFeng* ret = nullptr;
        switch (int(type)) {
        case 0:
            ret = new Undergraduate();
            break;
        case 1:
            ret = new Volunteer();
            break;
        default:
            break;
        }
        return ret;
    }
};

int main(int argc, char *argv[])
{
    //如果要将下面三个大学生换成志愿者，需要修改三处
    LeiFeng* studentA = SimpleFactory::CreateLeiFeng(UNDERGRADUATE);
    studentA->BuyRice();
    LeiFeng* studentB = SimpleFactory::CreateLeiFeng(UNDERGRADUATE);
    studentB->Sweep();
    LeiFeng* studentC = SimpleFactory::CreateLeiFeng(UNDERGRADUATE);
    studentC->Wash();

    return 0;
}

工厂方法生产雷锋

#include <iostream>

using namespace std;

class LeiFeng {
public:
    void Sweep() {
        cout << "扫地" << endl;
    }
    void Wash() {
        cout << "洗衣" << endl;
    }
    void BuyRice() {
        cout << "买米" << endl;
    }
};

class Undergraduate : public LeiFeng {};

class Volunteer : public LeiFeng {};

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

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

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

int main(int argc, char *argv[])
{
    //如果要将下面三个大学生换成志愿者，只需要换掉工厂就行
    IFactory* factory = new UndergraduateFactory();
    LeiFeng* studentA = factory->CreateLeiFeng();
    LeiFeng* studentB = factory->CreateLeiFeng();
    LeiFeng* studentC = factory->CreateLeiFeng();

    studentA->BuyRice();
    studentB->Sweep();
    studentC->Wash();

    return 0;
}

小结

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

简单工厂模式下如果要增加一个新的功能，需要增加功能类文件，以及在简单工厂中增加相应的 case 条件，简单工厂违背了 开放-封闭原则

工厂方法模式新加功能需要新加功能类文件，并且需要一个增加相应的工厂类，继承与一个抽象工厂。工厂方法模式没有违背 开放-封闭原则

Factory Method工厂方法模式 [李建忠C++笔记]

• 通过“对象创建”模式绕开 new ，来避免对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。
• 典型模式
  • Factory Method
  • Abstract Factory
  • Prototype
  • Builder

动机（Motivation）

• 在软件系统中，经常面临着创建对象的工作；由于需求的变化，需要创建的对象的具体类型经常变化。
• 如何应对这种变化？如何绕过常规的对象创建方法（new），提供一种“封装机制”来避免客户程序和这种“具体对象创建工作”的紧耦合？

//Splitter.cpp
//抽象分割器
class ISplitter {
public:
	virtual void split() = 0;
	virtual ~ISplitter() {}
};

//具体分割器
class BinarySplitter : public ISplitter {};
class TxtSplitter : public ISplitter {};
class PictureSplitter : public ISplitter {};
class VideoSplitter : public ISplitter {};

//工厂基类
class SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() = 0;
	virtual ~SplitterFactory();
};

//具体工厂
class BinarySplitterFactory : public SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() {
		return new BinarySplitter();
	}
};
class TxtSplitterFactory : public SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() {
		return new TxtSplitter();
	}
};
class PictureSplitterFactory : public SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() {
		return new PictureSplitter();
	}
};
class VideoSplitterFactory : public SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() {
		return new VideoSplitter();
	}
};

//MainForm.cpp
class MainForm : public Form
{
	SplitterFactory* factory;  //工厂
public:
	MainForm(SplitterFactory* factory) {
		this->factory = factory;
	}
	
	void Button1_click() {
		//面向接口编程，对象要声明成抽象基类
		ISplitter* splitter = 
			factory->CreateSplitter();  //多态New
		splitter->split();
	}
};

模式定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟（目的：解耦，手段：虚函数）到子类。——《设计模式》GoF

要点总结

• Factory Method模式用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系（new）会导致软件的脆弱。
• Factory Method模式通过面向对象的手法，将所要创建的具体对象工作延迟到了子类，从而实现一种扩展（而非更改）的策略，较好地解决了这种紧耦合关系。
• Factory Method模式解决“单个对象”的需求变化。缺点在于要求创建方法/参数相同。