我们先看工厂模式的介绍
这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。
简单来说,使用了C++多态的特性,将存在继承关系的类,通过一个工厂类创建对应的子类(派生类)对象。在项目复杂的情况下,可以便于子类对象的创建。
工厂模式的实现方式可分别简单工厂模式、工厂方法模式、抽象工厂模式,每个实现方式都存在优和劣。
最近炒鞋炒的非常的火,那么以鞋厂的形式,一一分析针对每个实现方式进行分析。
ShoesFactory
):工厂模式的核心类,会定义一个用于创建指定的具体实例对象的接口。Shoes
):是具体产品类的继承的父类或实现的接口。NiKeShoes\AdidasShoes\LiNingShoes
):工厂类所创建的对象就是此具体产品实例。Shoes
为鞋子的抽象类(基类),接口函数为Show()
,用于显示鞋子广告。NiKeShoes
、AdidasShoes
、LiNingShoes
为具体鞋子的类,分别是耐克、阿迪达斯和李宁鞋牌的鞋,它们都继承于Shoes
抽象类。// 鞋子抽象类
class Shoes
{
public:
virtual ~Shoes() {}
virtual void Show() = 0;
};
// 耐克鞋子
class NiKeShoes : public Shoes
{
public:
void Show()
{
std::cout << "我是耐克球鞋,我的广告语:Just do it" << std::endl;
}
};
// 阿迪达斯鞋子
class AdidasShoes : public Shoes
{
public:
void Show()
{
std::cout << "我是阿迪达斯球鞋,我的广告语:Impossible is nothing" << std::endl;
}
};
// 李宁鞋子
class LiNingShoes : public Shoes
{
public:
void Show()
{
std::cout << "我是李宁球鞋,我的广告语:Everything is possible" << std::endl;
}
};
ShoesFactory
为工厂类,类里实现根据鞋子类型创建对应鞋子产品对象的CreateShoes(SHOES_TYPE type)
函数。enum SHOES_TYPE
{
NIKE,
LINING,
ADIDAS
};
// 总鞋厂
class ShoesFactory
{
public:
// 根据鞋子类型创建对应的鞋子对象
Shoes *CreateShoes(SHOES_TYPE type)
{
switch (type)
{
case NIKE:
return new NiKeShoes();
break;
case LINING:
return new LiNingShoes();
break;
case ADIDAS:
return new AdidasShoes();
break;
default:
return NULL;
break;
}
}
};
main
函数,先是构造了工厂对象,后创建指定类型的具体鞋子产品对象,创建了具体鞋子产品的对象便可直接打印广告。因为采用的是new
的方式创建了对象,用完了要通过delete
释放资源资源哦!int main()
{
// 构造工厂对象
ShoesFactory shoesFactory;
// 从鞋工厂对象创建阿迪达斯鞋对象
Shoes *pNikeShoes = shoesFactory.CreateShoes(NIKE);
if (pNikeShoes != NULL)
{
// 耐克球鞋广告喊起
pNikeShoes->Show();
// 释放资源
delete pNikeShoes;
pNikeShoes = NULL;
}
// 从鞋工厂对象创建阿迪达斯鞋对象
Shoes *pLiNingShoes = shoesFactory.CreateShoes(LINING);
if (pLiNingShoes != NULL)
{
// 李宁球鞋广告喊起
pLiNingShoes->Show();
// 释放资源
delete pLiNingShoes;
pLiNingShoes = NULL;
}
// 从鞋工厂对象创建阿迪达斯鞋对象
Shoes *pAdidasShoes = shoesFactory.CreateShoes(ADIDAS);
if (pAdidasShoes != NULL)
{
// 阿迪达斯球鞋广告喊起
pAdidasShoes->Show();
// 释放资源
delete pAdidasShoes;
pAdidasShoes = NULL;
}
return 0;
}
[root@lincoding factory]# ./simpleFactory
我是耐克球鞋,我的广告语:Just do it
我是阿迪达斯球鞋,我的广告语:Impossible is nothing
我是李宁球鞋,我的广告语:Everything is possible
ShoesFactory
):工厂方法模式的核心类,提供创建具体产品的接口,由具体工厂类实现。NiKeProducer\AdidasProducer\LiNingProducer
):继承于抽象工厂,实现创建对应具体产品对象的方式。Shoes
):它是具体产品继承的父类(基类)。NiKeShoes\AdidasShoes\LiNingShoes
):具体工厂所创建的对象,就是此类。ShoesFactory
抽象工厂类,提供了创建具体鞋子产品的纯虚函数。NiKeProducer
、AdidasProducer
、LiNingProducer
具体工厂类,继承持续工厂类,实现对应具体鞋子产品对象的创建。// 总鞋厂
class ShoesFactory
{
public:
virtual Shoes *CreateShoes() = 0;
virtual ~ShoesFactory() {}
};
// 耐克生产者/生产链
class NiKeProducer : public ShoesFactory
{
public:
Shoes *CreateShoes()
{
return new NiKeShoes();
}
};
// 阿迪达斯生产者/生产链
class AdidasProducer : public ShoesFactory
{
public:
Shoes *CreateShoes()
{
return new AdidasShoes();
}
};
// 李宁生产者/生产链
class LiNingProducer : public ShoesFactory
{
public:
Shoes *CreateShoes()
{
return new LiNingShoes();
}
};
main
函数针对每种类型的鞋子,构造了每种类型的生产线,再由每个生产线生产出对应的鞋子。需注意的是具体工厂对象和具体产品对象,用完了需要通过delete
释放资源。int main()
{
// ================ 生产耐克流程 ==================== //
// 鞋厂开设耐克生产线
ShoesFactory *niKeProducer = new NiKeProducer();
// 耐克生产线产出球鞋
Shoes *nikeShoes = niKeProducer->CreateShoes();
// 耐克球鞋广告喊起
nikeShoes->Show();
// 释放资源
delete nikeShoes;
delete niKeProducer;
// ================ 生产阿迪达斯流程 ==================== //
// 鞋厂开设阿迪达斯生产者
ShoesFactory *adidasProducer = new AdidasProducer();
// 阿迪达斯生产线产出球鞋
Shoes *adidasShoes = adidasProducer->CreateShoes();
// 阿迪达斯球鞋广喊起
adidasShoes->Show();
// 释放资源
delete adidasShoes;
delete adidasProducer;
return 0;
}
[root@lincoding factory]# ./methodFactory
我是耐克球鞋,我的广告语:Just do it
我是阿迪达斯球鞋,我的广告语:Impossible is nothing
ShoesFactory
):工厂方法模式的核心类,提供创建具体产品的接口,由具体工厂类实现。NiKeProducer
):继承于抽象工厂,实现创建对应具体产品对象的方式。Shoes\Clothe
):它是具体产品继承的父类(基类)。NiKeShoes\NiKeClothe
):具体工厂所创建的对象,就是此类。Clothe
和Shoes
,分别为衣服和鞋子的抽象产品类。NiKeClothe
和NiKeShoes
,分别是耐克衣服和耐克衣服的具体产品类。// 基类 衣服
class Clothe
{
public:
virtual void Show() = 0;
virtual ~Clothe() {}
};
// 耐克衣服
class NiKeClothe : public Clothe
{
public:
void Show()
{
std::cout << "我是耐克衣服,时尚我最在行!" << std::endl;
}
};
// 基类 鞋子
class Shoes
{
public:
virtual void Show() = 0;
virtual ~Shoes() {}
};
// 耐克鞋子
class NiKeShoes : public Shoes
{
public:
void Show()
{
std::cout << "我是耐克球鞋,让你酷起来!" << std::endl;
}
};
Factory
为抽象工厂,提供了创建鞋子CreateShoes()
和衣服产品CreateClothe()
对象的接口。NiKeProducer
为具体工厂,实现了创建耐克鞋子和耐克衣服的方式。// 总厂
class Factory
{
public:
virtual Shoes *CreateShoes() = 0;
virtual Clothe *CreateClothe() = 0;
virtual ~Factory() {}
};
// 耐克生产者/生产链
class NiKeProducer : public Factory
{
public:
Shoes *CreateShoes()
{
return new NiKeShoes();
}
Clothe *CreateClothe()
{
return new NiKeClothe();
}
};
main
函数,构造耐克工厂对象,通过耐克工厂对象再创建耐克产品族的衣服和鞋子对象。同样,对象不再使用时,需要手动释放资源。int main()
{
// ================ 生产耐克流程 ==================== //
// 鞋厂开设耐克生产线
Factory *niKeProducer = new NiKeProducer();
// 耐克生产线产出球鞋
Shoes *nikeShoes = niKeProducer->CreateShoes();
// 耐克生产线产出衣服
Clothe *nikeClothe = niKeProducer->CreateClothe();
// 耐克球鞋广告喊起
nikeShoes->Show();
// 耐克衣服广告喊起
nikeClothe->Show();
// 释放资源
delete nikeShoes;
delete nikeClothe;
delete niKeProducer;
return 0;
}
[root@lincoding factory]# ./abstractFactory
我是耐克球鞋,让你酷起来!
我是耐克衣服,时尚我最在行!
以上三种工厂模式,在新增产品时,都存在一定的缺陷。
那么有什么好的方法,在新增产品时,即不用修改工厂类,也不用新增具体的工厂类?
笔者在实际项目中看到一个封装性非常强的工厂类,在扩展新产品时,不需要修改工厂类,也不需要新增具体的工厂类,详细内容可以跳转至C++ 深入浅出工厂模式(进阶篇)阅读。