设计模式——工厂方法

设计模式——工厂方法

  (1）目的：可以在不改动核心代码的情况下，添加新的产品（易扩展），实现依赖倒置。将类的实例化延迟到其子类。

（2）如何实现： 

     1.创建一个产品类基类（Product），具体产品类（ConcreteProduct）继承于产品类。

     2.创建一个抽象工厂类(Creator)，具体的工厂(ConcreteCreator)继承于Creator，抽象工厂类定义一个虚函数接口，具体工厂类重写这个接口在接口内创建具体产品类。

（3）优点：

    1.扩展类的功能是不需要修改已有代码，完全实现了开放-封闭原则。

（4）缺点：

   1.没当新增一个新产品时，要在具体工厂类和具体产品类中各新增一个类，开发量较大。

   2.具体实例化哪一个类交给客户端去判断。

│  add_factory.cpp
│  add_factory.h
│  add_operation.cpp
│  add_operation.h
│  calculate_factory.cpp
│  calculate_factory.h
│  main.cpp
│  multiply_factory.cpp
│  multiply_factory.h
│  multiply_operation.cpp
│  multiply_operation.h
│  operation_factory.cpp
│  operation_factory.h

operation_factory.h（Product）

#pragma once
class OperationFactory
{
public:
	int a;
	int b;
public:
	OperationFactory() = default;
	OperationFactory(int, int);
	int virtual GetResult()=0;
};

operation_factory.cpp

#include "operation_factory.h"
OperationFactory::OperationFactory(int num1, int num2)
{
	a = num1;
	b = num2;
}

add_operation.h（ConcreteProduct）

#include "operation_factory.h"
class AddOperation :
    public OperationFactory
{
public:
    AddOperation() = default;
    AddOperation(int, int);
    int GetResult() override;
};

add_operation.cpp

#include "add_operation.h"
AddOperation::AddOperation(int num1, int  num2)
{
	a = num1;
	b = num2;
}
int AddOperation::GetResult()
{
	return a + b;
}

multiply_operation.h（ConcreteProduct）

#pragma once
#include "operation_factory.h"
class MultiplyOperation :
    public OperationFactory
{
public:
    MultiplyOperation() = default;
    MultiplyOperation(int, int);
    int GetResult() override;
};

multiply_operation.cpp

#include "multiply_operation.h"
MultiplyOperation::MultiplyOperation(int num1, int  num2)
{
	a = num1;
	b = num2;
}
int MultiplyOperation::GetResult()
{
	return a * b;
}

calculate_factory.h(Creator)

#pragma once
#include "operation_factory.h"
class CalculateFactory
{
	public:
	virtual OperationFactory* GetSpecificOperation(int,int) = 0;
};

calculate_factory.cpp

#include "calculate_factory.h"

add_factory.h(ConcreteCreator)

#pragma once
#include "calculate_factory.h"
#include "add_operation.h"
class AddFactory :
    public CalculateFactory
{
    public:
    OperationFactory* GetSpecificOperation(int,int) override;
};

add_factory.cpp

#include "add_factory.h"
OperationFactory* AddFactory::GetSpecificOperation(int num1,int num2)
{
	return new AddOperation(num1, num2);
}

 multiply_factory.h(ConcreteCreator)

#pragma once
#include "calculate_factory.h"
class MultiplyFactory :
    public CalculateFactory
{
    public:
    OperationFactory* GetSpecificOperation(int, int) override;
};

multiply_operation.cpp

#include "multiply_factory.h"
#include "multiply_operation.h"
OperationFactory* MultiplyFactory::GetSpecificOperation(int num1, int num2)
{
	return new MultiplyOperation(num1, num2);
}

main.cpp（客户端）

#include<iostream>
#include "add_factory.h"
#include "multiply_factory.h"

int main()
{
    int num1 = 2;
    int num2 = 9;
    CalculateFactory* factory_add =new AddFactory();
    CalculateFactory* factory_mul = new MultiplyFactory();
    OperationFactory* plus = factory_add->GetSpecificOperation(num1, num2);
    OperationFactory* mul = factory_mul->GetSpecificOperation(num1, num2);
    std::cout << plus->GetResult() << std::endl;
    std::cout << mul->GetResult() << std::endl;
}