Trama
Después de que Guangjun abrió la tienda de té con leche, el siguiente paso fue comprar maquinaria y materiales.
Para la máquina de bebidas, hay dos opciones ante sus ojos. Una es la "máquina de bebidas tipo grifo", que se ve así:
La otra es la máquina de té con leche "tipo elaboración", que es la siguiente:
Lo pensó y eligió el segundo.
Dijo: Para el primer tipo de máquina, si desea agregar un nuevo producto, solo puede agregar otro cubo. Es problemático. No sé si esta máquina puede agregar otro cubo. La máquina de té con leche es más amigable. Solo necesita agregar los ingredientes. Mézclelo, revuélvalo, caliéntelo / refrigérelo y véndalo. Puede producir cualquier producto nuevo que se le ocurra.
¿Está por aquí? No, no, no, nuestro Guangjun no es tonto. Solo vender té con leche no puede satisfacerlo. Decidió comprar una máquina de hamburguesas, una máquina de salchichas, té con leche, hamburguesas y salchichas en el otro lado, las hamburguesas tienen sed y sed. Pida una taza de té con leche, el té con leche solo es aburrido, solo pida una hamburguesa, la hamburguesa no está llena y algunas salchichas.
En este momento, descubrió que si estas máquinas están dispersas y cuando el flujo de pasajeros es grande, correrán y se agotarán. ¿Cómo puede ser? Absolutamente no permitido, así que compró otro banco de trabajo.
¡Es un fantasma de negocios! !
Patrón de método de fábrica
La primera mitad de esta historia es un escenario de implementación del patrón del método de fábrica.
¿Cuál es el patrón del método de fábrica?
Defina una interfaz para crear objetos y deje que las subclases decidan qué clase instanciar. Los métodos de fábrica retrasan la instanciación de una clase a sus subclases.
Si Guang Jun compraba la máquina de Coca-Cola frente a él, entonces la lista de bebidas sería restringida e inflexible. Pero compró la segunda máquina de té con leche, por lo que solo necesita verter los materiales en la máquina y dejar el resto a la máquina. Si desea producir algún producto nuevo, simplemente cambie algunas materias primas.
Veamos un diagrama de clases del patrón del método de fábrica:
Código
#include<iostream>
using namespace std;
//奶茶主类
class Milk {
public:
virtual void set_taste() = 0;//设置口味
virtual void add_burdening() = 0;//加料
};
//双皮奶
class custard :public Milk {
public:
void set_taste() {
cout << "草莓味双皮奶" << endl; }
void add_burdening() {
cout << "加珍珠" << endl; }
};
//珍珠奶茶
class pearl :public Milk {
public:
void set_taste() {
cout << "香草味珍珠奶茶" << endl; }
void add_burdening() {
cout << "加椰果" << endl; }
};
//拿铁
class coffee :public Milk {
public:
void set_taste() {
cout << "拿铁" << endl; }
void add_burdening() {
cout << "不加料" << endl; }
};
//巧克力瑞纳冰
class ruinaice :public Milk {
public:
void set_taste() {
cout << "巧克力瑞纳冰" << endl; }
void add_burdening() {
cout << "加奶油" << endl; }
};
//所有饮品定义完毕，接下来定义一台机器
//template<class T>
class abstractMachin {
public:
virtual void createMilk(Milk *c) = 0;
};
//机器具体实现
//template<class T>
class Machin :public abstractMachin {
public:
void createMilk(Milk *c) {
c->set_taste();
c->add_burdening();
}
};
//现在材料有了，机器也有了，是时候做奶茶了
class Boss {
//老板就是那个main()
};
int main() {
//初始化一个机器
abstractMachin* am = new Machin();
//先做瑞纳冰
Milk* ruina = new ruinaice();
am->createMilk(ruina);
return 0;
}
Patrón de fábrica abstracto
Lo que es el patrón de fábrica abstracto, su definición también es muy abstracta: proporcionar una interfaz para crear un grupo de objetos relacionados o interdependientes, y no es necesario especificar sus clases específicas.
Aquí, diagrama de clases general:
No hay mucho que decir, es demasiado abstracto, veamos la imagen en nuestra historia (banco de trabajo == máquina abstracta):
Puede considerar el uso de plantillas para clases abstractas y echar un vistazo a la implementación del código:
#include<iostream>
using namespace std;
//奶茶主类
class Milk {
public:
virtual void set_taste() = 0;//设置口味
virtual void add_burdening() = 0;//加料
};
//双皮奶
class custard :public Milk {
public:
void set_taste() {
cout << "草莓味双皮奶" << endl; }
void add_burdening() {
cout << "加珍珠" << endl; }
};
//珍珠奶茶
class pearl :public Milk {
public:
void set_taste() {
cout << "香草味珍珠奶茶" << endl; }
void add_burdening() {
cout << "加椰果" << endl; }
};
//拿铁
class coffee :public Milk {
public:
void set_taste() {
cout << "拿铁" << endl; }
void add_burdening() {
cout << "不加料" << endl; }
};
//巧克力瑞纳冰
class ruinaice :public Milk {
public:
void set_taste() {
cout << "巧克力瑞纳冰" << endl; }
void add_burdening() {
cout << "加奶油" << endl; }
};
//汉堡主类
class humberger {
public:
virtual void add_burdening() = 0;//加料
};
//牛肉堡
class beef :public humberger {
public:
void add_burdening() {
cout << "不加辣" << endl; }
};
//鸡腿堡
class chicken :public humberger {
public:
void add_burdening() {
cout << "微辣" << endl; }
};
//香辣堡
class piquancy :public humberger {
public:
void add_burdening() {
cout << "巨辣" << endl; }
};
//接下来定义一个工作台
template<class T1, class T2>
class abstractMachin {
public:
virtual void createMilk(T1* c) = 0;
virtual void createHumb(T2* c) = 0;
};
//工作台具体实现
template<class T1,class T2>
class Machin :public abstractMachin<T1,T2> {
public:
void createMilk(T1* c) {
c->set_taste();
c->add_burdening();
}
void createHumb(T2* c) {
c->add_burdening();
}
};
int main()
{
//初始化一个工作台
abstractMachin<Milk,humberger>* am = new Machin<Milk,humberger>();
//先做瑞纳冰
Milk* ruina = new ruinaice();
am->createMilk(ruina);
//再来个牛肉堡
abstractMachin<Milk,humberger>* bm = new Machin<Milk,humberger>();
beef* bf = new beef();
bm->createHumb(bf);
return 0;
}
Bueno.
No es fácil de crear, es una buena costumbre recopilarlo fácilmente.
