O padrão simples de fábrica deveria ter sido introduzido no blog do padrão de fábrica, porque há uma certa semelhança com o padrão de estratégia, que é extraído aqui em um capítulo separado.
Padrão de fábrica simples
O processo de criação de uma instância com uma classe separada é a fábrica.
Código básico
#include <iostream> usando o namespace std; classe AbstractProduct { public : virtual ~ AbstractProduct () {} virtual void Operation () = 0 ; }; classe ProductA: public AbstractProduct { public : void Operation () {cout << "ProductA" << endl; } }; classe ProductB: public AbstractProduct { public : void Operation () {cout << "ProductB" << endl; } }; classe Factory { public: AbstractProduct * createProduct ( produto de char ) { AbstractProduct * ap = NULL; switch (produto) { case 'A': ap = novo ProductA (); quebrar ; case 'B': ap = novo ProductB (); quebrar ; } retornar ap; } }; int main () { Factory * f = new Factory (); AbstractProduct * apa = f-> createProduct ('A' ); apa -> Operação (); // ProductA AbstractProduct * apb = f-> createProduct ('B' ); apb -> Operação (); // ProductB delete apa; delete apb; excluir f; retornar 0 ; }
Fábrica de computação simples
classe OperationFactory { public : Operação createOperate ( operação de string ) { Operação oper = null ; switch (operar) { case " + " : oper = new OperationAdd (); quebrar ; case " - " : oper = new OperationSub (); quebrar ; case " * ": oper = new OperationMul (); quebrar ; case " / " : oper = new OperationDiv (); quebrar ; } return oper; } };
Comparação de modelo simples de fábrica e modelo estratégico
Consulte este diagrama UML para recuperar o padrão de estratégia que aprendi antes
Os dois parecem ser semelhantes?
A única diferença é a classe simples de fábrica e a classe Context.
O blog original é implementado em Java e, como não afeta a leitura e o entendimento, é copiado diretamente aqui sem modificação.
código de classe de fábrica simples eo contexto distinção de classe
classe simples de fábrica:
classe simples de fábrica:
classe pública OperationFactory { operação estática pública CreateOperate ( operação de string ) { Operação oper = null ; switch (operar) { case " + " : oper = new OperationAdd (); quebrar ; case " - " : oper = new OperationSub (); quebrar ; caso " * " : oper = new OperationMul (); quebrar ; case " / " : oper = new OperationDiv (); quebrar ; padrão : oper = new Operation (); quebrar ; } return oper; } }
A classe Context no padrão de estratégia:
contexto da classe { CashSuper csuper; public Context (CashSuper cs) { this .csuper = cs; } public double GetResult ( double money) { // chama o método de cobrança da estratégia específica da classe return csuper.acceptCash (money); } }
1. Primeiro, observe os parâmetros recebidos: o método CreateOperate na classe simple factory recebe uma string e retorna um objeto Operation e a classe Context precisa receber um objeto CashSuper quando ele é inicializado.
2. Na classe simples de fábrica, um objeto correspondente é criado de acordo com as condições recebidas, enquanto a classe Context recebe um objeto, e você pode chamar métodos para executar os métodos desse objeto.
Resumindo o padrão de fábrica simples e o padrão de estratégia
1. Em termos de tipos: o padrão de fábrica simples pertence ao padrão de criação, enquanto o padrão de estratégia pertence ao padrão de comportamento.
2. A seguir, veja um pequeno exemplo:
existem muitos tipos de machados, há uma fábrica especializada na produção de machados de várias necessidades.
Modo de fábrica:
1) De acordo com o objetivo que você dá para produzir eixos com diferentes usos, por exemplo, para cortar pessoas, a fábrica produz machados para cortar pessoas e, se você deseja registrar, você produz machados para registro.
2) Um tipo de objeto que produz comportamentos diferentes de acordo com alguns atributos que você devolve.
3) Concentre-se no
modo de estratégia de criação de objetos :
1) Use o machado produzido pela fábrica para fazer as coisas correspondentes, por exemplo, use o machado para cortar pessoas e use o machado para cortar madeira.
2) O método correspondente é executado de acordo com o objeto correspondente que você fornece.
3) A escolha do comportamento da atenção
3. Modelo simples de fábrica: de acordo com as condições da seleção do cliente, para ajudar os clientes a criar um objeto.
Modo de estratégia: o cliente fornece a ele um objeto criado e ajuda o cliente a fazer as coisas correspondentes.
Vantagens e desvantagens dos dois modelos
primeiro olhar para os dois modos de código de cliente:
// Cliente no modo de fábrica simples: Operação op; // Entrega para a classe de fábrica simples para criar o objeto op = OperationFactory.CreateOperate ( " + " ); op.StrNumberA = 10 ; op.StrNumberB = 20 ; // Chame o objeto gerado Método double result = op.GetResult (); Console.WriteLine (result);
// Cliente no modo de estratégia: total duplo = 0 ; private void btnOk_Click ( remetente do objeto , EventArgs e) { CashContext cc = null ; // o cliente cria a opção de objeto (cbxType.SelectedItem.ToString ()) { case : " Cobrança normal " : cc = novo CashContext ( novo CashNormal ()); break ; case : " Mais de 300 retorna 100 " : cc =new CashContext ( novo CashReturn ()); break ; case : " 20% off " : cc = new CashContext ( novo CashRebate ()); break ; } // Calcule a taxa cobrada pela estratégia específica e entregue-a à classe de contexto para executar o método correspondente , O cliente só precisa receber o valor retornado para duplicar acceptMoney = cc.GetResult (Convert.ToDouble (txtPrice.Text) * Convert.ToDouble (txtNum.Text)); // Calcular o custo total total + = acceptMoney; listBox1.Items .Add ( " Preço unitário: " + txtPrice.Text + "： ：" + TxtNum.Text + " " + comboBox1.SelectedItem.ToString () + " ： ：" + acceptMoney); lblResult.Text = total.ToString (); }
Ao comparar o código do cliente, verifica-se que o
padrão de fábrica simples: a criação do objeto é entregue à classe de fábrica simples. O cliente precisa apenas inserir as condições correspondentes e não é responsável pela criação do objeto, mas precisa que o cliente chame o método da classe de algoritmo. . Porém, quando você precisar adicionar uma nova classe de operação, como operação de raiz aberta, precisará modificar a classe de fábrica simples.
Modo de estratégia: a seleção e criação de objetos ainda precisam ser feitas por você, mas a responsabilidade de chamar métodos é dada à classe Context. Depois que uma nova estratégia precisa ser adicionada, o cliente precisa ser modificado.
Portanto, a deficiência do modelo simples de fábrica é que, quando a nova demanda aumenta, a classe da fábrica precisa ser modificada com frequência. Somente o modo de estratégia é usado.Quando novos requisitos aumentam, o cliente precisa ser modificado.O cliente ainda tem a responsabilidade de criar objetos e não reduz a pressão no cliente. Para usar esses dois modos juntos, você precisa modificar a classe Context, que não é perfeita de qualquer maneira.