一.为什么需要工厂模式
当我们在拥有了大量类的时候，一旦我们需要具体对象，就需要手动控制new出不同的对象。我们可以针对这一步骤抽象化，创建一个根据要求返回我们需要的具体对象的工厂。这样就能通过统一的方式获得不同的对象
二.不用工厂模式
假设我们拥有一个披萨店，我们需要根据客户不同的订单提供不同的披萨。首先不使用工厂模式，我们就能得到这样的代码
#include <iostream>
#include <string>
class Pizza {
public:
virtual void prepare() = 0;
virtual void bake() = 0;
virtual void cut() = 0;
virtual void box() = 0;
};
//不同种类的披萨
class CheesePizza: public Pizza {
void prepare()
{
std::cout << "准备芝士" << std::endl;
};
void bake()
{
std::cout << "烤芝士" << std::endl;
};
void cut()
{
std::cout << "切芝士" << std::endl;
};
void box()
{
std::cout << "装盒" << std::endl;
};
};
class GreekPizza: public Pizza {
void prepare()
{
std::cout << "。。。" << std::endl;
};
void bake()
{
std::cout << "。。。" << std::endl;
};
void cut()
{
std::cout << "。。。" << std::endl;
};
void box()
{
std::cout << "。。。" << std::endl;
};
};
class PepperoniPizza: public Pizza {
void prepare()
{
std::cout << "。。。" << std::endl;
};
void bake()
{
std::cout << "。。。" << std::endl;
};
void cut()
{
std::cout << "。。。" << std::endl;
};
void box()
{
std::cout << "。。。" << std::endl;
};
};
std::unique_ptr<Pizza> orderPizza(std::string type)
{
std::unique_ptr<Pizza> pizza = nullptr;
if (type == "cheese")
{
pizza = std::make_unique<CheesePizza>();
}
else if (type == "greek")
{
pizza = std::make_unique<GreekPizza>();
}
else if (type == "pepperoni")
{
pizza = std::make_unique<PepperoniPizza>();
}
pizza->prepare();
pizza->bake();
pizza->cut();
pizza->box();
return pizza;
};三.使用简单工厂模式
能看到假若我们想要对具体类型的披萨进行调整是很困难的。我们将工厂引入，单独用一个函数创建对象。就可以得到这样的代码。通过统一的createPizza函数获得不同的披萨对象
#include "Pizza.hpp"
#include <string>
class SimplePizzaFactory
{
public:
std::unique_ptr<Pizza> createPizza(const std::string& type)
{
std::unique_ptr<Pizza> pizza = nullptr;
if (type == "cheese")
{
pizza = std::make_unique<CheesePizza>();
}
else if (type == "pepperoni")
{
pizza = std::make_unique<PepperoniPizza>();
}
else if (type == "clam")
{
pizza = std::make_unique<ClamPizza>();
}
else if (type == "veggie")
{
pizza = std::make_unique<VeggiePizza>();
}
return pizza;
}
};
这样结合工厂模式就可以得到如下的披萨店的代码。
#include "SimplePizzaFactory.hpp"
#include "Pizza.hpp"
#include <string>
class PizzaStore
{
SimplePizzaFactory factory;
public:
PizzaStore(SimplePizzaFactory factory)
{
this->factory = factory;
}
std::unique_ptr<Pizza> orderPizza(std::string type)
{
std::unique_ptr<Pizza> pizza = nullptr;
pizza = factory.createPizza(type);
if (pizza != nullptr)
{
pizza->prepare();
pizza->bake();
pizza->cut();
pizza->box();
}
else
{
std::cout << "不是可提供的披萨" << std::endl;
}
return pizza;
}
};
这样就可以通过字符串自动判断并生成对应的对象。也有利于我们增加新的披萨种类。但是对于更改已有披萨的设计仍然不是很方便。
四.工厂模式
我们想让每种不同的披萨对象拥有更多的弹性。我们可以将这一弹性功能下放到PizzaStore实现。也就是让子类运行时根据输入决定做什么披萨，怎么做披萨。我们需要提供多种不同类型的PizzaStore，并根据不同的方法创建不同的披萨类型。
首先提供披萨店的接口和披萨的接口
#include "Pizza.hpp"
#include <string>
class PizzaStore
{
public:
std::unique_ptr<Pizza> orderPizza(std::string type);
virtual std::unique_ptr<Pizza> makePizza(std::string type) = 0;
};
class Pizza
{
public:
std::string name;
std::string dough;
std::string sauce;
std::vector<std::string> toppings;
const std::string& getName() const
{
return this->name;
}
virtual void prepare() const
{
std::cout << "准备 " + getName() << std::endl;
std::cout << "准备面团..." << std::endl;
std::cout << "添加酱汁..." << std::endl;
std::cout << "添加配料: " << std::endl;
for (auto& topping : this->toppings)
{
std::cout << " " + topping + "\n";
}
}
virtual void bake() const
{
std::cout << "350 度 烤 25 分钟 "<< std::endl;
}
virtual void cut() const
{
std::cout << "切分披萨"<< std::endl;
}
virtual void box() const
{
std::cout << "披萨装盒" << std::endl;
}
virtual ~Pizza() = default;
};有了披萨店的接口和披萨的接口，我们就能创建出不同种类的披萨商店贩卖不同种类的披萨。
首先创建出不同类型的披萨。并将其装载在披萨店内。
#include "Pizza.hpp"
class NYStylePepperoniPizza: public Pizza
{
public:
NYStylePepperoniPizza()
{
name = "NY style pepperoni pizza";
dough = "。。。面";
sauce = "。。。酱";
toppings.push_back("。。。e");
toppings.push_back("。。。");
toppings.push_back("。。。");
toppings.push_back("。。。");
toppings.push_back("。。。");
toppings.push_back("。。。");
}
};
#include "Pizza.hpp"
#include "PizzaStore.hpp"
class NYPizzaStore: public PizzaStore
{
public:
std::unique_ptr<Pizza> makePizza(std::string type)
{
std::unique_ptr<Pizza> pizza = nullptr;
if (type == "cheese")
{
pizza = std::make_unique<NYStyleCheesePizza>();
}
else if (type == "pepperoni")
{
pizza = std::make_unique<NYStylePepperoniPizza>();
}
return pizza;
}
};
这样披萨店的工厂会拥有更好的弹性，能更利于增加新的披萨，由于每个商店都拥有一个特有的披萨类，也利于披萨类本身的更改。
披萨本身和披萨店本身是平行的关系，披萨是产品类，披萨商店是创建者
工厂模式定义：定义了一个创建对象的接口，但让子类决定实例化哪个类。
本质就是工厂接口创建出工厂实例，调用产品接口实现出产品实例。
五.工厂模式应有的对象依赖关系
依赖抽象不依赖具体类，应该让依赖倒置。高层组件的类例如（pizzastore）依赖具体实现类例如（具体pizza类）。
六.抽象工厂模式
对于上面的工厂模式的披萨而言，原料都是固定好的，不利于修改，而抽象工厂模式利于提供大量家族相关对象，就比如上面的披萨原料。我们可以通过抽象工厂来改造披萨的原料。首先获得我们新的pizza虚接口，跟工厂模式没有什么变化。
class Pizza
{
public:
std::string name;
Dough dough;
Sauce sauce;
std::vector<std::string> toppings;
const std::string& getName() const
{
return this->name;
}
virtual void prepare() const //抽象工厂的重点是这个函数
{
std::cout << "准备 " + getName() << std::endl;
std::cout << "准备面团..." << std::endl;
std::cout << "添加酱汁..." << std::endl;
std::cout << "添加配料: " << std::endl;
for (auto& topping : this->toppings)
{
std::cout << " " + topping + "\n";
}
}
virtual void bake() const
{
std::cout << "350 度 烤 25 分钟 "<< std::endl;
}
virtual void cut() const
{
std::cout << "切分披萨"<< std::endl;
}
virtual void box() const
{
std::cout << "披萨装盒" << std::endl;
}
virtual ~Pizza() = default;
};主要的变化是我们将用到工厂内的组件也就是工厂家族，具体的实现过程抽象工厂实现。首先看一下批量获取相关原料的工厂接口。
class PizzaIngredientFactory
{
public:
virtual Dough CreatDough() = 0;
virtual Cheese CreatCheese() = 0;
.
.
.
};我们可以根据不同的披萨商店，形成不同的具体原材料工厂实例
class NYStylePepperoniPizza: public PizzaIngredientFactory
{
Dough createDough()
{
return new ThinCrustDough();
}
Cheese createCheese()
{
return new MarinaraCheese();
}
.
.
.
}我们用一个例子来实现。我们让披萨制作阶段运行时调整，通过原材料工厂获取不同的原材料
#include "Pizza.hpp"
class NYStylePepperoniPizza: public Pizza
{
PizzaIngredientFactory _ingFact;
public:
NYStylePepperoniPizza(PizzaIngredientFactory ingFact) //通过工厂元素获取原料
{
this._ingFact = ingFact;
}
void prepare() //通过原料工厂批量获取对象
{
dough = _ingFact.createDough();
sauce = _ingFact.createsauce();
cheese = _ingFact.createcheese();
}
};
最后我们需要更改披萨商店调用原材料工厂
#include "Pizza.hpp"
#include "PizzaStore.hpp"
class NYPizzaStore: public PizzaStore
{
public:
std::unique_ptr<Pizza> makePizza(std::string type)
{
std::unique_ptr<Pizza> pizza = nullptr;
PizzaIngredientFactory idFact = new NYPizzaIngredientFactory (); //拿到原材料工厂
if (type == "cheese")
{
pizza = NYStyleCheesePizza(idFact); //通过不同的工厂加工生成不同的披萨
}
else if (type == "pepperoni")
{
pizza = NYStylePepperoniPizza(idFact);
}
return pizza;
}
};
这样就实现了不同工厂通过抽象工厂获得批量不同的元素，生成对应的披萨。
总结：通过引进一个抽象工厂提供了为披萨家族创建家族。此工厂提供接口，我们通过这个接口获取对象。我们可以通过更换工厂获得不同的行为。
抽象工厂提供一个接口来创建相关或依赖对象的家族，而不需要提供具体类
七.对比工厂模式和抽象工厂
抽象工厂通过对象组合创建对象，通过提供一个抽象接口，规定如何生产相关产品，工厂方法通过子类创建对象。
抽象工厂用于提供大批量相关产品家族。
工厂用于从具体的实例化解耦。
抽象工厂往往会在具体实例化使用工厂模式
抽象工厂缺点：添加新产品意味着改变接口。
总结：
抽象工厂提供一个接口，用于创建相关依赖对象的家族，而不必指定它们的具体类。依靠对象组合实现，子类创建在工厂接口暴露的方法中实现。抽象工厂的意图是创建相关对象家族，不必依赖具体类
工厂方法，定义一个创建对象的接口，但让子类决定哪个类实例化，工厂方法让一个类延迟实例化到子类。工厂方法依赖继承，对象创建被委托给子类，子类实现工厂方法来创建对象。工厂方法的意图是允许类延迟实例化
扫一扫
1031
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
