设计模式（三） 工厂模式

摘要: 我们定义一个抽象的工厂类，然后派生出具体的各种产品工厂类，这样将类的实例化操作延迟到子类中完成，由子类来决定究竟实例化哪一个类。抽象化的结果使这种结构可以在不修改具体工厂类的情况下引进新的产品。这一特点使得工厂方法模式具有超越简单工厂模式的优越性。

#工厂模式#

说道工厂模式之前，我们先讲开放封闭原则，因为上一篇我们用简单工厂模式建立了我需要的几何体创建工厂，但是很麻烦的是，一旦我加入了新的几何体，我就不得不去修改我的几何体工厂逻辑，多了之后就会很麻烦，而且一旦几何体工厂出了问题，那就要面临着全线崩溃的局面了。

###开放封闭原则#

软件实体应该是可扩展，而不可修改的。也就是说，对扩展是开放的，而对修改是封闭的。
因此，开放封闭原则主要体现在两个方面：

对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。

对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改。

也就是说，理想状态是我可以拓展出任何我需要的东西，而不对已经写好的类进行任何修改。
显然，在简单工厂中添加新的几何体类型，是违背开放封闭原则的，因为需要修改我的几何体工厂逻辑，那么怎么办呢？我们用工厂模式。

###工厂模式要点#

我们定义一个抽象的工厂类，然后派生出具体的各种产品工厂类，这样将类的实例化操作延迟到子类中完成，由子类来决定究竟实例化哪一个类。抽象化的结果使这种结构可以在不修改具体工厂类的情况下引进新的产品。这一特点使得工厂方法模式具有超越简单工厂模式的优越性。

###代码如下#
Geometry类

class CGeometry {
public:
CGeometry() {}
~CGeometry() {}
//改变几何体大小
virtual bool ChangeSize() = 0;
//改变几何体颜色
virtual bool ChangeColor() = 0;
};

Cube类

class CCube :public CGeometry {
public:
CCube() { std::cout << "创建了一个正方体" << std::endl; }
~CCube() {}

virtual bool ChangeSize()
{
std::cout << "改变了正方体大小" << std::endl;
return true;
}
virtual bool ChangeColor()
{
std::cout << "改变了正方体颜色" << std::endl;
return true;
}
};

Cylinder类

class CCylinder :public CGeometry {
public:
CCylinder() { std::cout << "创建了一个圆柱体" << std::endl; }
~CCylinder() {}

virtual bool ChangeSize()
{
std::cout << "改变了圆柱体大小" << std::endl;
return true;
}
virtual bool ChangeColor()
{
std::cout << "改变了圆柱体颜色" << std::endl;
return true;
}
};

Sphere类

class CSphere :public CGeometry {
public:
CSphere() { std::cout << "创建了一个球体" << std::endl; }
~CSphere() {}

virtual bool ChangeSize()
{
std::cout << "改变了球体大小" << std::endl;
return true;
}
virtual bool ChangeColor()
{
std::cout << "改变了球体颜色" << std::endl;
return true;
}
};

GeometryFactory

class CGeometryFactory {
public:
CGeometryFactory() {}
~CGeometryFactory() {}
public:
virtual CGeometry* CreateGeometory() = 0;
};

CubeFactory类

class CCubeFactory :public CGeometryFactory {
public:
CCubeFactory() {}
~CCubeFactory() {}

public:
CGeometry* CreateGeometory()
{
return new CCube();
}
};

CylinderFactory类

class CCylinderFactory :public CGeometryFactory {
public:
CCylinderFactory() {}
~CCylinderFactory() {}

public:
CGeometry* CreateGeometory()
{
return new CCylinder();
}
};

SphereFactory类

class CSphereFactory :public CGeometryFactory {
public:
CSphereFactory() {}
~CSphereFactory() {}

public:
CGeometry* CreateGeometory()
{
return new CSphere();
}
};

客户端的一些使用

int main()
{
CGeometryFactory *m_Factory = new CCubeFactory();		//创建Cube工厂
CGeometry *m_Geometry = m_Factory->CreateGeometory();	//创建Cube对象
m_Geometry->ChangeColor();

m_Factory = new CCylinderFactory();				//创建Cylinder工厂
m_Geometry = m_Factory->CreateGeometory();		//创建Cylinder对象
m_Geometry->ChangeSize();

m_Factory = new CSphereFactory();				//创建Sphere工厂
m_Geometry = m_Factory->CreateGeometory();		//创建Sphere对象
m_Geometry->ChangeColor();

return 0;
}

这种情况下，当我想要添加新的几何体对象的时候，比如圆锥体，那么我只需要继承Geometry创建出一个Cone类，然后继承GeometeryFactory类创建一个ConeFactory类，这样就可以遵从开放封闭原则，在不改变已有类的情况下，拓展出新的几何体。