设计模式：Factory Method(工厂模式)

意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实例化延迟到子类，这样做的目的就是为了解耦。

暂无理解，先贴代码

Color.h

#pragma once
class Color
{
public:
    virtual void colorfun()=0;
    virtual ~Color() {};
};
//抽象基类

ColorFactory.h

#pragma once
#include"Color.h"
class ColorFactory
{
public:
    virtual Color *  CreatColor()=0;
    virtual ~ColorFactory() {};
};
//工厂基类
//注意不要说是抽象工厂，抽象工厂是设计模式中的一个模式

Red.h

#pragma once
#include "Color.h"
#include<iostream>
using namespace std;
class Red :
    public Color
{
public:
    virtual void colorfun();
};
//具体类

Blue.h

#pragma once
#include "Color.h"
#include<iostream>
using namespace std;
class Blue :
    public Color
{
public:
    virtual void colorfun();
};
//具体类

Yellow.h

#pragma once
#include "Color.h"
#include<iostream>
using namespace std;
class Yellow :
    public Color
{
public:
    virtual void colorfun();
};
//具体类

RedFactory.h

#pragma once
#include "ColorFactory.h"
#include"Red.h"
class RedFactory :
    public ColorFactory
{
public:
    virtual Color *  CreatColor() ;
};
//具体工厂类

BlueFactory.h

#pragma once
#include "ColorFactory.h"
#include"Blue.h"
class BlueFactory :
    public ColorFactory
{
public:
    virtual Color * CreatColor();
};
//具体工厂类

YellowFactory.h

#pragma once
#include "ColorFactory.h"
#include"Yellow.h"
class YellowFactory :
    public ColorFactory
{
public:
    virtual Color * CreatColor();
};
//具体工厂类

TestMethod.h

#pragma once
#include"Color.h"
#include"ColorFactory.h"
class TestMethod
{
    ColorFactory * factory;
public:
    TestMethod(ColorFactory * factory);
    void MethodTest();
};

 

对应的cpp文件

Color.cpp

#include "Color.h"

ColorFactory..cpp

#include "ColorFactory.h"

Red.cpp

#include "Red.h"

void Red::colorfun()
{
    cout << "这是Redfactory创建的red对象"<<endl;
}

Blue.cpp

#include "Blue.h"

void Blue::colorfun()
{
    cout << "这是BlueFactory创建的Blue对象"<<endl;
}

Yellow.cpp

#include "Yellow.h"

void Yellow::colorfun()
{
    cout << "这是YellowFactory创建的Yellow对象"<<endl;
}

RedFactory.cpp

#include "RedFactory.h"

Color * RedFactory::CreatColor()
{
    return new Red();
}

BlueFactory.cpp

#include "BlueFactory.h"

Color * BlueFactory::CreatColor()
{
    return new Blue();
}

YellowFactory.cpp

#include "YellowFactory.h"

Color * YellowFactory::CreatColor()
{
    return new Yellow();
}

TestMethod.cpp

#include "TestMethod.h"

TestMethod::TestMethod(ColorFactory * factory)
{
    this->factory = factory;
}

void TestMethod::MethodTest()
{
    Color * myColor = factory->CreatColor();
    myColor->colorfun();
}

最后是main()函数

#include <iostream>
#include"TestMethod.h"
#include"ColorFactory.h"
#include"RedFactory.h"
#include"BlueFactory.h"
#include"YellowFactory.h"
int main()
{
    RedFactory *red=new RedFactory;
    BlueFactory *blue = new BlueFactory;
    YellowFactory *yellow = new YellowFactory;

    TestMethod * redtest = new TestMethod(red);
    TestMethod * bluetest = new TestMethod(blue);
    TestMethod * yellowtest = new TestMethod(yellow);

    redtest->MethodTest();
    bluetest->MethodTest();
    yellowtest->MethodTest();
}

最后的输出结果为：

这是Redfactory创建的red对象
这是BlueFactory创建的Blue对象
这是YellowFactory创建的Yellow对象