contente
Padrão de Fábrica Simples (Padrão de Fábrica Estático) Fábrica Simples
Método de Fábrica Padrão Método de Fábrica
padrão de fábrica
Função : Realiza a separação entre criador e chamador e nos ajuda a instanciar objetos.
Essência central : instancia objetos com fábricas em vez de novas operações
Selecionaremos a classe de implementação e criaremos objetos para gerenciamento e controle unificados, desacoplando assim o chamador de nossa classe de implementação
O padrão de fábrica é um padrão de desacoplamento típico
Satisfazer os sete princípios da POO:
Princípio aberto-fechado
Princípio de Inversão de Dependência
Lei de Deméter (pese bem)
Classificação:
Padrão de fábrica simples: usado para gerar qualquer produto na mesma estrutura hierárquica (para novos produtos adicionados, o código existente precisa ser estendido).
Padrão de método de fábrica: usado para gerar produtos fixos na mesma estrutura hierárquica (suporta adicionar qualquer produto).
Abstract Factory Pattern: Crie outras fábricas em torno de uma superfábrica.
Cenários aplicáveis : Como um padrão de criação de classe, o padrão de método de fábrica pode ser usado em qualquer lugar que objetos complexos precisem ser gerados. Uma coisa a notar é que objetos complexos são adequados para usar o padrão de fábrica, enquanto objetos simples, especialmente objetos que podem ser criados apenas por new , não precisam usar o padrão de fábrica. Quando o sistema precisa ter melhor escalabilidade, o modo fábrica pode ser considerado, e diferentes produtos são montados com diferentes fábricas de implementação.
De fato, o Creational Pattern abstrai o processo de instanciação de uma classe e pode separar a criação e uso de objetos em módulos de software .
O padrão criacional fornece ao designer de software o máximo de flexibilidade possível em termos do que criar (O que) , quem cria (Quem) e quando criar (Quando) .
Padrão de Fábrica Simples (Padrão de Fábrica Estático) Fábrica Simples
É criar uma classe de fábrica para criar instâncias de algumas classes que implementam a mesma interface.
As funções no padrão de fábrica simples são: fábrica, produto, cliente. Veja o seguinte exemplo:
Primeiro podemos olhar para o diagrama de classes
O código de implementação específico é o seguinte:
Criar uma interface de carro
public interface Car {
public void name();
}
Escreva duas classes de implementação
public class WuLing implements Car{
@Override
public void name() {
System.out.println("五菱宏光");
}
}
public class Tesla implements Car{
@Override
public void name() {
System.out.println("特斯拉");
}
}
Criar uma classe de fábrica
public class CarFactory{
public static Car getCar(String car) {
if(car.equals("五菱")) {
return new WuLing();
}else if(car.equals("特斯拉")) {
return new Tesla();
}else {
return null;
}
}
}faça um teste
public class Comsumer {
public static void main(String[] args){
Car car1 = CarFactory.getCar("五菱");
Car car2 = CarFactory.getCar("特斯拉");
car1.name();
car2.name();
}
}O resultado da saída:
Não preciso me preocupar com a forma como o carro ficou, só preciso fornecer um nome e tirá-lo da fábrica.
Podemos sentir claramente as desvantagens desse modo. Se agora queremos adicionar uma classe de implementação da interface Car e adicionar um carro Volkswagen, devemos modificar o método getCar() na fábrica, que viola o princípio aberto-fechado. .
Claro, podemos modificar os métodos na classe de fábrica e obter o que precisamos sem precisar inserir parâmetros.
public class CarFactory{
public static Car getWuLing(){
return new WuLing();
}
public static Car getTesla(){
return new Tesla();
}
}Na verdade, isso não atende às nossas necessidades, ainda precisamos modificar o código, mas ele não será modificado na lógica do código como o método anterior.
Problemas com o padrão de fábrica simples:
viola o princípio aberto-fechado
Violando o princípio de distribuição de responsabilidade de alta coesão, toda a lógica de criação é centralizada em uma classe de fábrica
Método de Fábrica Padrão Método de Fábrica
O padrão de método de fábrica é um desacoplamento adicional do padrão de fábrica simples, que é equivalente a dividir a classe de fábrica simples que seria enorme devido ao código de negócios em classes de fábrica individuais, para que o código não seja acoplado à mesma classe. dentro.
Embora o padrão de método de fábrica e o padrão de fábrica simples criem objetos por meio de fábricas, a maior diferença entre eles é que o padrão de método de fábrica está completamente em conformidade com o " princípio aberto-fechado " do design.
Basta observar o exemplo:
O código específico é implementado da seguinte forma:
A interface do carro, a classe Tesla e a classe WuLing permanecem inalteradas
Criar interface de fábrica de carros
public interface CarFactory{
public Car getCar();
}Crie a classe de implementação TeslaFactory factory class e WuLingFactory da interface de fábrica de automóveis
public class TeslaFactory implements CarFactory{
@Override
public Car getCar(){
return new Tesla();
}
}
public class WuLingFactory implements CarFactory{
@Override
public Car getCar(){
return new WuLing();
}
}teste final
public class Comsumer {
public static void main(String[] args){
Car car1 = new WuLingFactory.getCar();
Car car2 = new TeslaFactory.getCar();
car1.name();
car2.name();
}
}Como o exemplo dado aqui não envolve o problema de parâmetros, nosso sentimento não é muito óbvio, imagine, e se houver muitos parâmetros na classe Tesla ou classe WuLing? Este método é amigável para os consumidores, não precisamos nos importar como o carro é feito, seu método de fábrica correspondente o instanciará, só precisamos chamar o método na fábrica.
Aqui eu acho que o fluxograma do deus louco pode ser mais claro (adicionar camada)
O padrão de método de fábrica pode ser usado nas seguintes situações:
Uma classe não conhece a classe dos objetos de que precisa.
Uma classe especifica qual objeto criar por meio de suas subclasses
vantagem:
Um chamador que deseja criar um objeto precisa apenas saber seu nome.
Alta escalabilidade, se você deseja adicionar um produto, basta estender uma classe de fábrica.
A implementação específica do produto é blindada e o chamador se preocupa apenas com a interface do produto.
deficiência:
Cada vez que um produto é adicionado, uma classe concreta e uma fábrica de implementação de objetos precisam ser adicionadas, o que dobra o número de classes no sistema, aumenta a complexidade do sistema até certo ponto e também aumenta a dependência das classes concretas do sistema . Isso não é uma coisa boa.
Padrão abstrato de fábrica
O padrão de fábrica abstrato é relativo ao padrão de método de fábrica, ou seja, o padrão de método de fábrica é para uma série de produtos, enquanto o padrão de fábrica abstrato é para várias séries de produtos.
Definição : O padrão de fábrica abstrata fornece uma interface para criar uma série de objetos relacionados ou interdependentes sem especificar suas classes concretas. O padrão de fábrica abstrata é uma fábrica de fábricas
Eu pessoalmente acho que isso significa adicionar outra camada, é claro, esta é apenas a minha opinião pessoal.
Antes de contar o caso, precisamos conhecer os dois conceitos de família de produtos e nível de produto:
Vejamos agora um caso específico:
Primeiro crie a interface do telefone e a interface do roteador
//手机产品接口
public interface IPhoneProduct {
void start();
void shutdown();
void callup();
void sendSMS();
}
//路由器产品接口
public interface IRouterProduct {
void start();
void shutdown();
void openWifi();
void setting();
}Em seguida, crie duas classes de implementação de interfaces de celular: celular Xiaomi e celular Huawei
//小米手机
public class XiaoMiPhone implements IPhoneProduct{
@Override
public void start() {
System.out.println("开启小米手机");
}
@Override
public void shutdown() {
System.out.println("关闭小米手机");
}
@Override
public void callup() {
System.out.println("小米手机打电话");
}
@Override
public void sendSMS() {
System.out.println("小米手机发短信");
}
}
//华为手机
public class HuaWeiPhone implements IPhoneProduct{
@Override
public void start() {
System.out.println("开启华为手机");
}
@Override
public void shutdown() {
System.out.println("关闭华为手机");
}
@Override
public void callup() {
System.out.println("华为手机打电话");
}
@Override
public void sendSMS() {
System.out.println("华为手机发短信");
}
}Crie classes de implementação para duas interfaces de roteador: roteador Xiaomi e roteador Huawei
//小米路由器
public class XiaoMiRouter implements IRouterProduct {
@Override
public void start() {
System.out.println("启动小米路由器");
}
@Override
public void shutdown() {
System.out.println("关闭小米路由器");
}
@Override
public void openWifi() {
System.out.println("小米路由器打开WiFi");
}
@Override
public void setting() {
System.out.println("小米路由器设置");
}
}//华为路由器
public class HuaWeiRouter implements IRouterProduct {
@Override
public void start() {
System.out.println("启动华为路由器");
}
@Override
public void shutdown() {
System.out.println("关闭华为路由器");
}
@Override
public void openWifi() {
System.out.println("华为路由器打开WiFi");
}
@Override
public void setting() {
System.out.println("华为路由器设置");
}
}Escreva uma fábrica de produtos abstratos para fabricar
//抽象产品工厂
public interface IProductFactory {
//生产手机
IPhoneProduct iphoneProduct();
//生产路由器
IRouterProduct irouterProduct();
}Criar uma classe de implementação para uma fábrica de produtos abstrata
//小米工厂
public class XiaoMiFactory implements IProductFactory {
@Override
public IPhoneProduct iphoneProduct() {
return new XiaoMiPhone();
}
@Override
public IRouterProduct irouterProduct() {
return new XiaoMiRouter();
}
}
//华为工厂
public class HuaWeiFactory implements IProductFactory {
@Override
public IPhoneProduct iphoneProduct() {
return new HuaWeiPhone();
}
@Override
public IRouterProduct irouterProduct() {
return new HuaWeiRouter();
}
}Escreva um teste de cliente:
public class Client {
public static void main(String[] args) {
System.out.println("**********华为系列***********");
//华为工厂
HuaWeiFactory huaweiFactory = new HuaWeiFactory();
IPhoneProduct huaweiPhone = huaweiFactory.iphoneProduct();
huaweiPhone.start();
huaweiPhone.callup();
}
}resultado da operação:
Cenários aplicáveis: O cliente (camada de aplicativo) não depende dos detalhes de como a instância da classe do produto é criada e implementada. Enfatiza que uma série de objetos de produtos relacionados (pertencentes à mesma família de produtos) são usados em conjunto para criar objetos que exigem muito código repetitivo para fornecer uma biblioteca de classes de produtos, todos os produtos aparecendo com a mesma interface, para que o cliente não depende da implementação específica
vantagem:
Isolamento de código de produtos específicos na camada de aplicação, sem necessidade de se preocupar com os detalhes de criação
Crie uma família de produtos juntos
deficiência:
Especifica todos os conjuntos de produtos possíveis que podem ser criados e a dificuldade de expansão de novos produtos na família de produtos;
Aumenta a abstração e a dificuldade de compreensão do sistema
resumo
Padrão de Fábrica Simples: Embora não esteja de acordo com os princípios de design até certo ponto, na verdade é o mais usado
Padrão de método de fábrica: Estenda adicionando novas classes de fábrica sem modificar as classes existentes
Abstract Factory Pattern: Você não pode adicionar produtos, você pode adicionar famílias de produtos
(Piada: Não há nada que não possa ser resolvido adicionando uma camada)
Ao final do estudo, devemos saber uma coisa claramente, ou seja, não colocar a carroça na frente dos bois. Aprendemos padrões de projeto para projetar melhor o software, não para usar um determinado padrão de projeto.