[Notas do padrão de design] Padrão de fábrica

Introdução:

Um dos padrões de projeto mais usados ​​em java.

Pertence ao modo de criação. Fornece uma maneira ideal de criar objetos.

No padrão de fábrica, a criação de um objeto não expõe a lógica de criação ao cliente e aponta para o objeto recém-criado usando uma interface comum.

Objetivo: Definir uma interface para criar um objeto e deixar suas subclasses decidirem qual classe de fábrica instanciar. O padrão de fábrica adia a criação para subclasses.

Resolvendo o problema: o problema da seleção de interface

Quando usar: ao planejar explicitamente a criação de diferentes instâncias sob diferentes condições

Como resolver: deixe sua subclasse implementar a interface de fábrica e retornar um produto abstrato

Código chave:

class Factory{
   接口 get接口(参数){

    if(参数 is a){
      return new A();
   }else if...
}
}

Exemplo: Se você precisa de um carro, você pode buscá-lo diretamente na fábrica, independentemente de como o carro é feito

vantagem:

① Se o chamador quiser criar um objeto, ele só precisa saber o nome.

②Alta escalabilidade, se você quiser adicionar um produto. Basta estender uma classe de fábrica.

③Proteja a implementação específica do produto, e o chamador se preocupa apenas com a interface do produto

deficiência:

Cada vez que um produto é adicionado, uma fábrica específica de implementação de classe e objeto precisa ser adicionada, 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 de classes específicas no sistema.

cenas a serem usadas:

①Gravador de log : O registro pode ser gravado no disco rígido local, hora do sistema, servidor remoto, etc. O usuário pode escolher onde gravar o log.

②Acesso ao banco de dados : quando o usuário não sabe apenas que tipo de banco de dados o sistema usa no final, e quando o banco de dados pode ser alterado.

③ Para projetar uma estrutura para conectar a um servidor , são necessários três protocolos, "POP3", "IMAP" e "HTTP", que podem ser usados ​​como classes de produto para implementar uma interface em conjunto.

Precauções:

O padrão de método de fábrica pode ser usado em qualquer lugar que objetos complexos precisem ser gerados.

Mas objetos simples, especialmente objetos que podem ser criados apenas por novos, não precisam usar o padrão de fábrica.

============================

Código:

Crie uma interface de forma:

public interface shape {
    void draw();
}

Uma classe de implementação que implementa a interface Shape:

public class Rectangle implements shape {
    @Override
    public void draw() {
        System.out.println("rectangle draw");
    }
}

public class Circle implements shape{
    @Override
    public void draw() {
        System.out.println("circle draw");
    }
}

public class Squre implements shape{
    @Override
    public void draw() {
        System.out.println("square draw");
    }
}

Crie uma fábrica que gere objetos de classe de entidade com base nas informações fornecidas

public class ShapeFatory {
    public shape getShape(String shapeType){
        if(shapeType==null)return null;
        if(shapeType.equalsIgnoreCase("circle")){
            return new Circle();
        }else if(shapeType.equalsIgnoreCase("rectangle")){
            return new Rectangle();
        }else if(shapeType.equalsIgnoreCase("square")){
            return new Squre();
        }
        return null;
    }
}

public class FactoryPatternDemo {
    public static void main(String[] args) {
        //创建一个工厂
        ShapeFatory shapeFatory=new ShapeFatory();
        //获取Circle对象
        shape shape1=shapeFatory.getShape("circle");
        shape1.draw();
        //获取Rectangle对象
        shape shape2=shapeFatory.getShape("rectangle");
        shape2.draw();
        //获取squre对象
        shape shape3=shapeFatory.getShape("square");
        shape3.draw();
    }
}