23 patrones de diseño (3) - de modo creador

1. Definiciones

Un objeto complejo crea e indica su separación, usando el mismo proceso de creación puede crear diferentes representaciones (diferente instancia de los atributos de clase).

2, UML 图

3, la composición

• Categoría del producto (Producto) : generalmente categorías más complejas, a saber, para crear una instancia de clase de un proceso más complejo
• El creador de clases abstractas (IProductBuilder) : creador de clase de interfaz abstracta que define los pasos para crear objetos de diferentes productos para crear una clase puede implementar esta interfaz, el diseño de su propia realización
• Creator (ProductABuilder, ProductBBuilder) : responsable de crear la instancia específica del objeto encapsula el proceso de creación de la clase. No se agrupan generalmente en dos pasos, a saber, los pasos para crear el producto, y devolver los objetos creados
• categoría de director (director) : responsable de llamar al creador apropiada para crear productos que, en general, dirigir y creador de la categoría interactiva, el producto y no lo hace directamente interactúan

4, el código

// 复杂的对象，产品类
public class Product {
    private List<String> parts = new ArrayList<>();

  	// 需要添加多个组件才能创建产品
    public void addPart(String part) {
        this.parts.add(part);
    }

    public void show() {
        System.out.println("本产品所有组件有：" + parts.toString());
    }
}

// 抽象创建者
public interface IProductBuilder {
  	// 创建步骤
    void buildPart1();
    void buildPart2();
		// 获得创建好的产品
    Product getProduct();
}

// A产品的创建者
public class ProductABuilder implements IProductBuilder {
    private Product product = new Product();

    // 创建A产品的步骤1
    @Override
    public void buildPart1() {
        product.addPart("产品A-部件1");
    }

    // 创建A产品的步骤2
    @Override
    public void buildPart2() {
        product.addPart("产品A-部件2");
    }

    @Override
    public Product getProduct() {
        return product;
    }
}

// B产品的创建者
public class ProductBBuilder implements IProductBuilder {

    private Product product = new Product();

    // 创建产品B的步骤1
    @Override
    public void buildPart1() {
        product.addPart("产品B-部件1");
    }

    // 创建产品B的步骤2
    @Override
    public void buildPart2() {
        product.addPart("产品B-部件2");
    }

    @Override
    public Product getProduct() {
        return product;
    }
}

// 导演类，负责调用创建者生成对象
public class Director {
    public Product getProduct(IProductBuilder builder){
        builder.buildPart1();
        builder.buildPart2();
        return builder.getProduct();
    }
}

// 调用者
public class Main {
    public static void main(String[] args) {
        Director director = new Director();
        Product productA = director.getProduct(new ProductABuilder());
        Product productB = director.getProduct(new ProductBBuilder());

        productA.show();
        productB.show();
    }
}

El resultado:

本产品所有组件有：[产品A-部件1, 产品A-部件2]
本产品所有组件有：[产品B-部件1, 产品B-部件2]

5, las ventajas

• El paquete es bueno. El proceso de creación del paquete, la persona que llama no tiene que preocuparse acerca de un proceso de creación de objetos complejos
• Ampliando buena. Si un nuevo producto, sólo tiene que añadir un creador del producto, sin modificar el código existente

6, y la diferencia entre el modo de fábrica

Se pueden encontrar, el modo creador y el patrón de fábrica es muy similar, se utilizan para crear una instancia de objeto, la diferencia es más que un creador modo de categorías de consejeros .

En comparación con el patrón de la fábrica, el modo creador se utiliza principalmente para crear objetos más complejos . Debido a que el objeto se crea es más complejo, por lo que la necesidad de separar a cabo una clase separada, que el director de la clase que sea responsable de este proceso creado, y la clase de fábrica para crear objetos directamente.

7, escenarios de aplicación

Se utiliza principalmente para la creación de algunos de los objetos más complejos, los objetos dentro de la orden de construcción es generalmente estable , pero el objeto constructor parámetros / atributos serán diferentes. Por lo tanto, si se crea un objeto es más compleja, utilizando el patrón de la fábrica; si un objeto para crear una responsabilidad especial a modo de utilización creador.