工厂模式

工厂模式

解决什么问题？

? 为了机能代码只关注机能的实现，而不耦合 是谁 拥有这些机能, 下面这段代码就绝不应该出现在客户侧，每一次新增机能或者删除机能客户侧都需要改动，耦合很高

if( type == "yellow" ) {
	return new Yellow_cocolr;
}
else if( type == "bulue" ) {
	return new Bulue_cocolr;
}

1. 使用简单工厂

? 严格来说这并不是一个工厂模式，只不过使用其他类将上述代码，以一个Factory的身份封装起来，之后对象变更不会影响客户端，但是还是会影响Factory类，相当于把恶心的事情给Factory，个人觉得对象的封装 耦合，其实就是把复杂的事情一步一步分离，每个人都负责一些事情，但是绝不多负责

? 比如你需要开发一个语音平台，需要语音引擎，语音引擎需要提供识别、Asr、nlu等功能，首先面临的就是创建引擎，那么你如何创建呢？在主控制器中 if else？

class EngineAdaptor{
public:
    void run(string type) {
        shared_ptr<Engine> engine = createEngine(type);
        engine.recognize();
        engine.getAsr();
	}
}
class EngineFactory{
public:
	static shared_ptr<Engine> createEngine(string type) {
        if( type == "Iflytek") {
            return new IflytekEngine();
		}
        else if( type == "Nuance") {
            return new NuanceEngine();
		}
        else {
        	return new EngineNull();    
		}
	}
}

上面的其实就是最常用的解耦方式，用一个Factory类根据不同参数类型创建不同的类。Factory类创建方法静态代表不创建Factory类，非静态代表Factory类本身还需要扩展，可以有不同种别的Factory

2. 工厂模式

遵循开放扩展原则，父类中将创建具体对象的任务交给子类，父类实现功能，子类实现创建机能对象的任务，本质其实就是多态，只不过解决的是创建机能对象职责的多态。

比如你要建立一个本地和云端两种状态机，主控制器需要一个rootState来进行开始的执行

class StateMachine {
public:
	virtual State* GetRootState() = 0;
}
class LocalStateMachine : public StateMachine {
public:
	virtual State* GetRootState() {
        return new LocalState();
	}
}    
class CloudStateMachine : public StateMachine {
public:
	virtual State* GetRootState() {
    	return new CloudState();
	}
}     
    
    

实际上就是 父类实现机能 子类重写实现具体创建者，具体调度看主控制器的

3. 涉及到的 依赖倒置原则

1. 原则为：依赖抽象，不依赖具体类

   高层组件依赖抽象，低层组件依赖抽象

   在自己编程的时候就应该确定每个类的职责，职责不是说自己负责的事情，还有的是依赖的类(抽象), 肯定是越少和实际类接触越好

2. 回到状态机那个例子，我们一般思考问题都是自顶向上，需要一个状态机控制流程，然后有两种local和cloud类型，然后根据需要创建。那么反过来呢，我们有local和cloud两种状态机，那么自然而然抽象出一个父类状态机，然后高层组件就依赖于这个抽象，这个抽象由子类工厂创建具体类型

3. 不要变量持有具体类

   不要让类派生自具体的类，要不是抽象要不是接口，要不毫无意义

   不要覆盖基类中已经实现的方法

4. 抽象工厂模式

? 这个模式主要创建模块族，通俗点说这个模式有点类似简单工厂模式的泛化

? 使用工厂决定子类中每个模块的类型

? 从例子来说，上面的状态机例子，现在我们已经知道自己需要local/cloud状态机了，那么state内部也是分模块的，比如handle、action等，这里我说的是不同种类的 handle以及action一起组成的state，那么就需要针对于 handle action 来一个stateProductFamily

当然需要一个小抽象

class stateProductFamilyFactory {
public:
	virtual Handle createHandle() = 0;
    virtual Action createAction() = 0;
}

class rootStateProductFamilyFactory : public stateProductFamilyFactory {
public:
    virtual Handle createHandle() {
        return new rootHandle();
    }
    virtual Action createAction() {
        return new rootAction();
    }
}

class endStateProductFamilyFactory : public stateProductFamilyFactory {
public:
    virtual Handle createHandle() {
        return new endHandle();
    }
    virtual Action createAction() {
        return new endAction();
    }
}

class LocalState : public State {
public:
    LocalState(stateProductFamilyFactory factory) {
        mfactory = factory;
        mHandle = mfactory.createHandle();
        mAction = mfactory.createAction();
	}
private:
	stateProductFamilyFactory mfactory;
}

5. 工厂和抽象工厂的比较

1. 工厂使用多态，抽象工厂使用组合
2. 工厂只需要一个方法，抽象工厂需要很多方法，来创建各个对象族
3. 最常用的还是简单工厂

工厂模式

原文：https://www.cnblogs.com/chaohacker/p/14862784.html