Forneça o link original https://blog.csdn.net/sinat_21107433/article/details/102616501
Idéias de padrão de método de fábrica
A ideia do padrão de design de fábrica simples determina que cada vez que um produto específico é adicionado, a composição interna do produto da fábrica precisa ser alterada. Por causa do princípio de abertura e fechamento, a ideia de abrir para o mundo externo, fechar para dentro e o modo de design do método de fábrica não são usados para criar todos os produtos específicos de uma maneira unificada. Diferentes fábricas precisam adicionar novos produtos para produtos diferentes. Ao adicionar novos produtos, você precisa adicionar os correspondentes. Fábrica.
Padrão de método de fábrica: defina uma interface para criar objetos, mas deixe a subclasse decidir qual classe instanciar. O padrão do método de fábrica atrasa a instanciação de uma classe para suas subclasses.
Estrutura padrão do método de fábrica
A partir da introdução do padrão de método de fábrica mencionado acima, pode-se ver que este padrão é composto pelos seguintes membros principais:
- Abstract Factory (AbstractFactory): a classe base de todas as classes de fábrica que produzem produtos específicos, fornecendo métodos públicos da classe de fábrica;
- Fábrica de Concreto (ConcreteFactory): produz produtos específicos
- Produto abstrato (AbstractProduct): a classe base de todos os produtos, fornecendo métodos públicos da classe do produto
- Produto de concreto (produto de concreto): categoria de produto específica
Exemplo de padrão de método de fábrica
O diagrama UML correspondente é o seguinte:
factorymethod.h
#include <iostream>
#include <string.h>
using namespace std;
//抽象产品类AbstractProduct
class AbstractSportProduct
{
public:
AbstractSportProduct() {
}
//抽象方法：
void printName(){
};
void play(){
};
};
//具体产品类Basketball
class Basketball : public AbstractSportProduct
{
public:
Basketball()
{
printName();
play();
}
//具体实现方法
void printName()
{
cout << "Get Basketball\n";
}
void play()
{
cout << "Play Basketball\n\n";
}
};
//具体产品类Football
class Football : public AbstractSportProduct
{
public:
Football()
{
printName();
play();
}
//具体实现方法
void printName()
{
cout << "Get Football\n";
}
void play()
{
cout << "Play Football\n\n";
}
};
//具体产品类Volleyball
class Volleyball : public AbstractSportProduct
{
public:
Volleyball()
{
printName();
play();
}
//具体实现方法
void printName()
{
cout << "Get Volleyball\n";
}
void play()
{
cout << "Play Volleyball\n\n";
}
};
//抽象工厂类
class AbstractFactory
{
public:
virtual AbstractSportProduct *getSportProduct() = 0;
};
//具体工厂类BasketballFactory
class BasketballFactory : public AbstractFactory
{
public:
BasketballFactory()
{
cout << "BasketballFactory\n";
}
AbstractSportProduct *getSportProduct()
{
cout << "Basketball";
return new Basketball();
}
};
//具体工厂类FootballFactory
class FootballFactory : public AbstractFactory
{
public:
FootballFactory()
{
cout << "FootballFactory\n";
}
AbstractSportProduct *getSportProduct()
{
cout << "Football";
return new Football();
}
};
//具体工厂类VolleyballFactory
class VolleyballFactory : public AbstractFactory
{
public:
VolleyballFactory()
{
cout << "VolleyballFactory\n";
}
AbstractSportProduct *getSportProduct()
{
cout << "Valleyball";
return new Volleyball();
}
};
factorymethod.cpp
#include <iostream>
#include "factorymethod.h"
using namespace std;
int main()
{
cout << "工厂方法模式\n\n";
//定义工厂类对象和产品类对象
AbstractFactory *fac = NULL;
AbstractSportProduct *product = NULL;
fac = new BasketballFactory();
product = fac->getSportProduct();
if (fac)
{
delete fac;
}
if (product) {
delete product;
}
fac = new FootballFactory();
product = fac->getSportProduct();
if (fac)
{
delete fac;
}
if (product) {
delete product;
}
fac = new VolleyballFactory();
product = fac->getSportProduct();
if (fac)
{
delete fac;
}
if (product) {
delete product;
}
return 0;
}
Resumo do Padrão de Método de Fábrica
Em resumo, pode-se ver que se você deseja praticar esportes, você precisa adicionar uma fábrica de acordo. Portanto, em comparação com o modelo de fábrica simples, o modelo com método de fábrica está mais de acordo com o princípio de abertura e fechamento.
vantagem:
- O método de fábrica é usado para criar os produtos solicitados pelo cliente e, ao mesmo tempo, ocultar do cliente os detalhes de uma categoria de produto específica a ser instanciada, e o usuário só precisa se preocupar com a fábrica correspondente ao produto solicitado;
- A fábrica decide independentemente quais produtos criar, e o processo de criação é encapsulado em objetos de fábrica específicos. O design polimórfico é a chave para o padrão do método de fábrica; quando
novos produtos são adicionados, não há necessidade de modificar o código original, o que aumenta o escalabilidade do sistema e em conformidade com o desenvolvimento. Princípio de fechamento.
Desvantagens:
- Ao adicionar novos produtos, você precisa adicionar novas fábricas de produtos ao mesmo tempo. O número de classes no sistema aumenta em pares, o que aumenta a complexidade do sistema. Mais classes precisam ser compiladas e executadas, o que aumenta a sobrecarga extra do sistema;
- Tanto as fábricas quanto os produtos introduzem camadas de abstração.As camadas de abstração (AbstractFactory e AbstractSportProduct) usadas no código do cliente aumentam o nível de abstração do sistema e a dificuldade de compreensão.
Ambiente aplicável:
- O cliente não precisa saber a classe do objeto que precisa criar;
- A classe abstrata fábrica especifica qual objeto criar por meio de suas subclasses (usando design polimórfico e o princípio da substituição de Richter)