Este artigo descreve o modelo de fábrica do Java Design Pattern. Compartilhe -o para sua referência, como segue:
1. Fábrica simples
Vamos pensar em uma pergunta primeiro. Quando escrevemos programas, haverá essa situação. O objeto A precisa chamar o método do objeto B. No momento, geralmente usamos a nova palavra-chave para criar uma instância B e, em seguida, chamar o método da instância B. A desvantagem dessa abordagem é que o método da classe A chama diretamente o nome da classe da classe B (esse método também é chamado de acoplamento codificado). Uma vez que o sistema precisa ser refatorado: quando a classe C precisa ser usada em vez de classe B, o programa precisa modificar o código da Classe A. Se 100 ou 10.000 classes no aplicativo forem codificadas, 100 ou 10.000 locais precisam ser modificados, o que é obviamente uma coisa muito terrível.
Olhando para esse problema de outra perspectiva: para um objeto já A, ele só precisa chamar o método do objeto B e não se importa com o processo de implementação e criação do objeto B, considere deixar a classe B implementar uma interface ib, enquanto a classe A só é que a Classe e a Classe IB e a classe IB e a classe A e a classe A e a classe A e a classe é que a classe A e a classe A e a classe é que a classe A e a classe A e a classe A e a classe A e a classe A e a classe A e a classe A e a classe é que a classe A. Chamando a fábrica ibfactory para obter instâncias do IB. Através do design acima: se você precisar usar a Classe C em vez da Classe B, só precisará permitir que a classe C implemente a interface IB e reescreva o código de implementação para criar uma instância de IB na fábrica ibFactory, para que a fábrica possa gerar uma instância C. Esse método de design de entregar objetos de várias classes a classes de fábrica para geração é chamado de padrão simples de fábrica.
Aqui está o código para um padrão simples de fábrica:
/*** Modo de fábrica simples* Interface comum que requer instâncias de objeto produzidas por fábrica* interface do estilo de cabelo* @Author Administrator**/interface pública cabelos {/*** desenhe penteado*/public void draw ();); System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Righthair implementa cabelos {@Override public void Draw () { System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Administrador * */public class Hairtest {public static void main (string [] args) {fábrica de cabelo = new Hairfactory ();Como você pode ver, se você deseja alterar o canhoto gerado em Hairtest para Righthair, só precisa modificar a implementação do método Gethair em HairFactory.
A vantagem de usar o modo simples de fábrica é que ele separa o chamador de objeto e o processo de criação de objetos. Quando o chamador de objeto precisa de um objeto, ele pode solicitá-lo diretamente da fábrica, evitando assim o chamador de objeto e a classe de implementação do objeto sendo acoplada de maneira codificada para melhorar a manutenção e a escalabilidade do sistema. Obviamente, o modelo de fábrica também tem uma pequena falha. Quando o produto é modificado, a classe de fábrica também precisa ser modificada de acordo. Aqui você pode usar o modelo de política para resolvê -lo. A seguir, o código.
interface pública Belbuilder { / *** Faça o penteado* @return* / public hair gethair ();} classe pública Lefthairbuilder implementa o Hairbuilder {@Override Public Hair Gethair () {return New Lefthair (); }} classe pública Rightthairbuilder implementa Hairbuilder {@Override Public Hair Gethair () {return New Righthair (); }} classe pública HairFactory {Private Hairbuilder Belbuilder; Hairfactory public (Belbuilder Hairbuilder) {this.HairBuilder = Hairbuilder; } public void SethairBuilder (Belbuilder Hairbuilder) {this.HairBuilder = Hairbuilder; } public hair gethair () {return hairbuilder.gethair (); }} classe pública Hairtest {public static void main (string [] args) {// Bandela Builder Builder = new LefthairBuilder (); Builder Builder = New RighthairBuilder (); HairFactory Factory = New HairFactory (construtor); Cabelo = Factory.gethair (); Hair.Draw (); }}A vantagem dessa abordagem é que não há mais necessidade de modificar a classe de fábrica e abstrair a lógica da criação na fábrica de acordo com diferentes estratégias. Quais objetos o programa precisa criar? Basta passar o construtor correspondente para a fábrica de rede.
2. Método da fábrica
No modelo simples de fábrica, o sistema usa a classe de fábrica para produzir todas as instâncias do produto, e a classe de fábrica decide qual classe de instâncias produzir, ou seja, a classe de fábrica é responsável por todos os julgamentos lógicos, criação de instâncias e outro trabalho.
Se você não deseja fazer julgamentos lógicos na classe de fábrica, o programa pode fornecer fábricas diferentes para diferentes categorias de produtos e diferentes classes de fábrica produzem produtos diferentes, sem fazer julgamentos lógicos complexos na classe de fábrica. Isso é um pouco semelhante ao modelo simples de fábrica combinado com o modelo de estratégia acima. A diferença é que o primeiro possui apenas uma fábrica, enquanto a última exige várias fábricas. Abaixo está o código para o padrão de método de fábrica.
/*** Padrão do método da fábrica* Interface comum necessária para ser implementada por instâncias de objetos produzidos pela fábrica* @author Administrator**/Public Interface Person {public void drawPerson ();} classe pública implementa a pessoa {@Override public void drawPerson () { System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @Author Administrator */Public Womenfactory implementa o Pessoal {@Override Public Pessoa GetPerson () {Return New Women (); Factory.getPerson ();A característica típica desse tipo é que ele produz seus produtos correspondentes de acordo com diferentes fábricas no código do cliente, e não há necessidade de colocar toda a lógica complexa na classe de fábrica para julgar. Há uma falha óbvia nesta implementação, que é que o cliente está associado à classe de fábrica.
3. Fábrica abstrata
Usando a arquitetura de design acima do método de fábrica, o código do cliente é separado com sucesso da classe de implementação do objeto chamado, mas traz outro acoplamento: o código do cliente é acoplado a diferentes classes de fábrica. Para resolver esse problema de acoplamento, considere adicionar uma classe de fábrica para gerar instâncias de fábrica e separar a fábrica do cliente para produzir produtos. Esse método de design é chamado de modelo de fábrica abstrato. Abaixo está o código para o padrão de fábrica abstrato
/*** Padrão de fábrica abstrato* Factory produtora Pessoal* @Author Administrator**/public class PersonFactoryFactory {public static PersonFactory getPersonFactory (String Type) {if (type.equalsignorecase ("Man")) {retornar new ManFactory (); } else {return New WomenFactory (); }}}/** * Classe de teste do cliente * @Author Administrator * */public class Pessotest {public static void main (string [] args) {fábrica pessoal = personfactoryFactory.getPersonFactory ("Man"); Pessoa pessoa = fábrica.getPerson (); pessoa.DrawPerson (); }}Para mais conteúdo relacionado ao Java, os leitores interessados neste site podem visualizar os tópicos: "Estrutura de dados Java e tutorial de algoritmo", "Resumo da operação Java Dom Node Tips", "Resumo de Dicas de Operação de Arquivos e Diretórios de Java" e "Resumo das dicas de operação do Java Cache"
Espero que este artigo seja útil para a programação Java de todos.