el modo de patrón de diseño del constructor (Modo Bulider) y el Ejemplo Código Explicación

En primer lugar, la definición y las características del constructor de modelos

　　Definición del modo de constructor (Builder): se refiere a la estructura de un objeto complejo y su separación representación, de modo que el mismo proceso de construcción pueda crear diferentes representaciones, tal patrón de diseño se conoce como el Builder. Perteneciente a la Builder 创建型patrón de diseño, es un objeto complejo en una pluralidad de objetos simples, usando una pluralidad de objetos simples paso a paso para la construcción de un objeto complejo. Llegará a ser aislado y no disfrazada, que parte del producto es el mismo, pero cada parte es la flexibilidad de elección.

　　La principal ventaja de este modo es como sigue:

• Cada constructores específicos son independientes, es propicio para la expansión del sistema.
• El cliente no tiene que conocer los detalles de la composición interna del producto, fácil de controlar los detalles del riesgo.

　　La desventaja es la siguiente:

• Parte del producto debe ser el mismo, lo que limita su uso.
• Si los cambios internos en la complejidad del producto, el modelo se incrementará mucho la categoría constructor.

　　Focus Builders (Constructor) el modo y el patrón de la fábrica diferente: constructor modelo se centra en el proceso de ensamblaje de piezas, y el método de pago fábrica patrón más atención al proceso de creación de piezas , pero ambos se pueden combinar.

En segundo lugar, la estructura y la aplicación de la modalidad creador

　　Modo Builder (constructor) se compone de cuatro elementos del producto, constructor abstracto, constructores de hormigón, los comandantes, y ahora tenemos que analizar la estructura y la implementación básica.

　　1. Estructura Modelo

　　El papel principal del modo Builder (Constructor) son los siguientes.

• función del producto (Producto): Es un objeto complejo que contiene varios componentes, dentro y fuera para crear sus diversos componentes por un constructor particular.
• Builder Resumen (Builder): Es un método abstracto incluye la creación de varios subcomponentes de la interfaz del producto, típicamente también contienen un proceso producto complejo devuelve getResult ().
• constructor específica (Concrete Builder): Interface Builder lograr, lograr método específico de la creación de los diversos componentes de productos complejos.
• Director (director): se llama la construcción parcial y métodos de montaje constructor objeto de crear objetos complejos, que no implicaban productos específicos de mando que.

　　Código es el siguiente:

　　Línea de productos, que comprende una pluralidad de componentes de objetos complejos A, B, C:

clase de productos 
{ 
    privada Cadena Parta;
    privada Parte B de cuerdas;
    privada PARTC cadena;
    pública  vacío setPartA (String Parta) 
    { 
        este .partA = Parta; 
    } 
    Pública  vacío setPartB (String Parte B) 
    { 
        este .partB = Parte B; 
    } 
    Pública  vacío setPartC (String PARTC) 
    { 
        este .partC = PARTC; 
    } 
    Pública  vacío show () 
    { 
        // 显示产品的特性
    } 
}

　　constructor Resumen: crear un producto que contiene un método abstracto varios sub-componentes.

abstracta  clase Constructor 
{ 
    // crear el producto objetos 
    protegidos del producto = nuevo nuevo producto ();
     pública  abstracta  vacío buildPartA ();
     pública  abstracta  vacío buildPartB ();
     pública  abstracta  vacío buildPartC ();
     // devuelve el producto objeto 
    público Producto getResult () 
    { 
        volver Producto; 
    } 
}

　　Constructores específicos: constructores se dieron cuenta de la interfaz abstracta.

público  de clase ConcreteBuilder extiende Constructor 
{ 
    público  vacío buildPartA () 
    { 
        product.setPartA ( "建造Parte A" ); 
    } 
    Pública  vacío buildPartB () 
    { 
        product.setPartA ( "建造Parte B" ); 
    } 
    Pública  vacío buildPartC () 
    { 
        product.setPartA ( "建造Parte C" ); 
    } 
}

　　Commander: llamada al método se completa constructor para crear objetos complejos.

clase director 
{ 
    privado constructor del constructor;
    público director (Constructor Constructor) 
    { 
        este .builder = constructor; 
    } 
    // 产品构建与组装方法
    pública constructo del producto () 
    { 
        builder.buildPartA (); 
        builder.buildPartB (); 
        builder.buildPartC (); 
        volver builder.getResult (); 
    } 
}

　　categorías de clientes:

público  de clase de cliente 
{ 
    públicas  estáticas  void main (String [] args) 
    { Constructor Constructor
         = nueva ConcreteBuilder (); 
        Director director = nuevo director (constructor); 
        Producto = director.construct (); 
        presentacion de producto(); 
    } 
}

Tres aplicación escena, el modo de

　　modo Builder (Constructor) para crear un objeto complejo, las diversas partes de sus productos a menudo se enfrentan con cambios dramáticos, pero el algoritmo de combinación de ellos es relativamente estable, por lo que se utiliza a menudo en las siguientes situaciones.

• Crear objetos más complejos compuestos por una pluralidad de miembros, cada miembro frente a un cambio complejo, pero el orden de la construcción es estable entre los miembros.
• Crear objetos complejos componentes independientes del algoritmo del objeto y sus métodos de montaje, es decir, el proceso de generación y el producto final son representación independiente.

Extended cuatro modos

　　Modo Builder (constructor) se puede cambiar según sea necesario en el proceso de solicitud, si las categorías de productos creados sólo uno, sólo un constructor específico, entonces se puede omitir el constructor abstracto, e incluso el papel del comandante omitido. La combinación de un curso:

público  de clase del curso { 

    privada Cadena coursename;
    privada coursePPT cadena;
    privada courseVideo cadena;
    privada courseArticle cadena; 



    pública de golf (CourseBuilder CourseBuilder) {
         este .courseName = courseBuilder.courseName;
        este .coursePPT = courseBuilder.coursePPT;
        este .courseVideo = courseBuilder.courseVideo;
        este .courseArticle = courseBuilder.courseArticle; 

    } 


    @ Override 
    pública Cadena toString () {
         retorno"Curso {" + 
                "coursename = '" + coursename + '\'' + 
                "coursePPT = '" + coursePPT + '\'' + 
                "courseVideo = '" + courseVideo + '\'' + 
                ", courseArticle = '" + courseArticle + '\'' + 
                '}' ; 
    } 

    Pública  estática  clase CourseBuilder {
         privada Cadena coursename;
        privada coursePPT cadena;
        privada courseVideo cadena;
        privada courseArticle cadena;


        Nombre del curso;
            devolver  este ; 
        } 


        Pública CourseBuilder buildCoursePPT (String coursePPT) {
             este .coursePPT = coursePPT;
            devolver  este ; 
        } 

        Pública CourseBuilder buildCourseVideo (String courseVideo) {
             este .courseVideo = courseVideo;
            devolver  este ; 
        } 

        Pública CourseBuilder buildCourseArticle (String courseArticle) {
             este .courseArticle = courseArticle;
            devolver  esta  ;
        }

         Pública acumulación de golf (a) {
             devolver  nuevo golf ( este ); 
        } 

    } 
}

　　uso:

público  de clase Test {
     públicas  estáticas  void main (String [] args) { 
        golf, golf = nueva nueva Course.CourseBuilder () 
                .buildCourseName ( "Diseñar el modo Java" ) 
                .buildCoursePPT ( "el patrón de diseño de Java del PPT" ) 
                .buildCourseVideo ( "el patrón de diseño de Java video " ) 
                .buildCourseArticle ( " los patrones de diseño Java papeles " ) .build (); 

        System.out.println (Carrera,); 
    } 
}