1 Descripción general
El patrón constructor se utiliza principalmente para "construir un objeto complejo paso a paso", donde "paso a paso" es un algoritmo estable, mientras que las distintas partes del objeto complejo cambian con frecuencia. Por lo tanto, el patrón de construcción se utiliza principalmente para resolver los requisitos cambiantes de la "parte del objeto". Esto permite un control más detallado sobre el proceso de construcción del objeto.
2 ejemplos
Tomando como ejemplo la producción de teléfonos móviles, cada teléfono móvil se divide en Pantalla, CPU y Batería. Ahora se producirán dos tipos de teléfonos móviles: Apple y Samsung.
manzana:
Copie el código de código de la siguiente manera:
paquete org.scott.builder.before.use;
importar java.util.ArrayList;
importar java.util.List;
/**
* @autor Scott
* @versión 2013-11-20
* @descripción
*/
ApplePhone de clase pública {
Lista<String> partes = new ArrayList<String>();
crear CPU nula pública() {
parts.add("TAZA: Qualcomm");
}
crear pantalla pública vacía() {
parts.add("PANTALLA: JDI");
}
crear batería pública vacía () {
parts.add("BATERÍA: DeSai");
}
espectáculo público vacío(){
System.out.print("Información del componente del producto:");
para (parte de cadena: partes){
System.out.print(parte + "/t");
}
}
}
Samsung:
Copie el código de código de la siguiente manera:
paquete org.scott.builder.before.use;
importar java.util.ArrayList;
importar java.util.List;
/**
* @autor Scott
* @versión 2013-11-20
* @descripción
*/
clase pública SamsungPhone {
Lista<String> partes = new ArrayList<String>();
crear CPU nula pública() {
parts.add("TAZA: MTK");
}
crear pantalla pública vacía() {
parts.add("PANTALLA: Samsung");
}
crear batería pública vacía () {
parts.add("BATERÍA: DeSai");
}
espectáculo público vacío(){
System.out.print("Información del componente del producto:");
para (parte de cadena: partes){
System.out.print(parte + "/t");
}
}
}
Cliente de prueba:
Copie el código de código de la siguiente manera:
paquete org.scott.builder.before.use;
/**
* @autor Scott
* @versión 2013-11-20
* @descripción
*/
prueba de constructor de clase pública {
iPhone ApplePhone estático privado = nuevo ApplePhone();
SamsungPhone estático privado samPhone = nuevo SamsungPhone();
principal vacío estático público (String args []) {
iphone.createCPU();
iphone.createScreen();
iphone.createBattery();
iphone.mostrar();
samPhone.createCPU();
samPhone.createScreen();
samPhone.createBattery();
samPhone.show();
}
}
¿Encontraste algún problema? Es decir, cada proceso de producción de teléfonos móviles es el mismo. Para ser precisos, los nombres de los procesos son los mismos, pero el procesamiento específico de cada proceso es diferente. procesamiento de cada cambio de proceso, de esto, podemos extraer lo inalterable, "sin cambios para hacer frente a todos los cambios", y entregar el cambio a productos específicos.
¿Cómo hacerlo específicamente? Esta vez el modo Constructor resulta útil.
Primero, echemos un vistazo a la interfaz del teléfono:
Copie el código de código de la siguiente manera:
paquete org.scott.builder.after.use;
importar java.util.ArrayList;
importar java.util.List;
/**
* @autor Scott
* @versión 2013-11-20
* @descripción
*/
clase abstracta pública Teléfono {
Lista protegida<String> partes = nueva ArrayList<String>();
agregar vacío público (parte de cadena) {
partes.add(parte);
}
espectáculo público vacío(){
System.out.print("Información del componente del producto:");
para (parte de cadena: partes){
System.out.print(parte + "/t");
}
}
}
Categoría de teléfono móvil de Apple:
Copie el código de código de la siguiente manera:
paquete org.scott.builder.after.use;
/**
* @autor Scott
* @versión 2013-11-20
* @descripción
*/
ApplePhone de clase pública extiende Phone{
}
Categoría de teléfono móvil Samsung:
Copie el código de código de la siguiente manera:
paquete org.scott.builder.after.use;
/**
* @autor Scott
* @versión 2013-11-20
* @descripción
*/
SamsungPhone de clase pública extiende el teléfono {
}
Luego defina un constructor de interfaz para el paso de producción:
Copie el código de código de la siguiente manera:
paquete org.scott.builder.after.use;
/**
* @autor Scott
* @versión 2013-11-20
* @descripción
*/
Constructor de interfaz pública {
CPU de construcción pública vacía();
pantalla de compilación pública vacía();
batería de compilación pública vacía();
Teléfono público getPhone();
}
Constructor para iPhone:
Copie el código de código de la siguiente manera:
paquete org.scott.builder.after.use;
/**
* @autor Scott
* @versión 2013-11-20
* @descripción
*/
la clase pública ApplePhoneBuilder implementa Builder{
Teléfono privado teléfono = nuevo ApplePhone();
@Anular
CPU de construcción pública vacía () {
teléfono.add("TAZA: Qualcomm");
}
@Anular
pantalla de compilación pública vacía () {
teléfono.add("PANTALLA: JDI");
}
@Anular
batería de compilación pública vacía () {
teléfono.add("BATERÍA: DeSai");
}
@Anular
teléfono público getPhone() {
devolver el teléfono;
}
}
Constructor para teléfonos móviles Samsung:
Copie el código de código de la siguiente manera:
paquete org.scott.builder.after.use;
/**
* @autor Scott
* @versión 2013-11-20
* @descripción
*/
la clase pública SamsungPhoneBuilder implementa Builder{
Teléfono privado teléfono = nuevo SamsungPhone();
@Anular
CPU de construcción pública vacía () {
teléfono.add("TAZA: MTK");
}
@Anular
pantalla de compilación pública vacía () {
teléfono.add("PANTALLA: Samsung");
}
@Anular
batería de compilación pública vacía () {
teléfono.add("BATERÍA: DeSai");
}
@Anular
teléfono público getPhone() {
devolver el teléfono;
}
}
Director que guía la producción específica de teléfonos móviles:
Copie el código de código de la siguiente manera:
paquete org.scott.builder.after.use;
/**
* @autor Scott
* @versión 2013-11-20
* @descripción
*/
Director de clase pública {
constructor privado constructor;
Director público(Constructor constructor){
this.builder = constructor;
}
construcción vacía pública(){
constructor.buildCPU();
constructor.buildScreen();
constructor.buildBattery();
}
}
Finalmente escribe una clase de prueba:
Copie el código de código de la siguiente manera:
paquete org.scott.builder.after.use;
/**
* @autor Scott
* @versión 2013-11-20
* @descripción
*/
prueba de constructor de clase pública {
Generador estático privado iPhoneBuilder = nuevo ApplePhoneBuilder();
Generador estático privado samPhoneBuilder = nuevo SamsungPhoneBuilder();
público estático vacío principal (String [] argumentos) {
Director director = nuevo Director (iPhoneBuilder);
director.construct();
Teléfono teléfono = iPhoneBuilder.getPhone();
System.out.println("iphone");
teléfono.mostrar();
director = nuevo Director(samPhoneBuilder);
director.construct();
teléfono = samPhoneBuilder.getPhone();
System.out.println("/nsamSung");
teléfono.mostrar();
}
}
Resultados de ejecución:
Copie el código de código de la siguiente manera:
iPhone
Información de la pieza del producto: COPA: Qualcomm PANTALLA: JDI BATERÍA: DeSai
Samsung
Información de pieza del producto: COPA: MTK PANTALLA: Samsung BATERÍA: DeSai
Las dos clases de entidad Phone aquí están vacías. Si este es el caso, entonces se pueden omitir. Si también se puede omitir la interfaz Phone, solo quedan las clases de implementación Director, Builder y Builder específicas. Además, la clase ApplePhone y la clase SamsungPhone son dos clases relacionadas. Son marcas de teléfonos móviles diferentes. Si encuentra dos o más clases que no están muy relacionadas, no es necesario que exista la interfaz pública Phone. Entonces, ¿cómo determinar el valor de retorno del método getPhone () especificado en la interfaz del Generador?
Independientemente de si el tipo de valor devuelto es ApplePhone o SamsungPhone, surgirán problemas porque los tipos de resultados devueltos no son uniformes. En este momento, Phone se puede definir como una interfaz vacía (una interfaz que no contiene ningún método) y luego dejar que estas clases de productos específicas que no tienen relación entre sí implementen esta interfaz. Luego, el tipo de valor de retorno de getPhone (. ) método especificado en la interfaz del Constructor. Sigue siendo un tipo de Teléfono, lo que resuelve el problema. Sin embargo, en este caso, no es necesario utilizar el modo Constructor.