1. Definición y diagrama de modelado UML

Separar la construcción de un objeto complejo de su representación, de modo que el mismo proceso de construcción pueda crear diferentes representaciones.

2. Escenarios de uso:

Varios componentes o piezas se pueden ensamblar en un objeto, pero los resultados de ejecución producidos son los mismos.

La clase de producto es muy compleja, o los diferentes órdenes de llamada dentro de la clase de producto producen diferentes efectos.

Inicializar un objeto es especialmente complejo, como usar múltiples métodos de construcción, o si hay muchos parámetros y todos tienen valores predeterminados.

3. Clases principales

  • (1) Clase de producto abstracta Computer.
  • (2) Builder abstracto: estandariza el ensamblaje del producto; generalmente las subclases implementan el proceso de ensamblaje específico.
  • (3) MacbookBuilder: clase Builder concreta, la clase que crea objetos específicos.
  • (4) Director: unifica el proceso de ensamblaje.

Tomando como ejemplo el ensamblaje de una computadora, principalmente se ensambla la torre (host), se configura el sistema operativo y se configura el monitor.

4. Uso específico

4.1 Clase abstracta de computadora Computer

Computer.java

public abstract class Computer { protected String mBoard; protected String mDisplay; protected String mOs; protected Computer(){ } public void setBoard(String board){ mBoard=board; } public void setDisplay(String display) { this.mDisplay = display; } public abstract void setOs() ; @Override public String toString() { return "Computer{" + "mBoard='" + mBoard + '\'' + ", mDisplay='" + mDisplay + '\'' + ", mOs='" + mOs + '\'' + '}'; } }

4.2 Clase de producto concreta MacBook

MacBook.java

public class MacBook extends Computer{ protected MacBook() { } @Override public void setOs() { mOs="Mac OS X 12"; } }

4.3 Builder abstracto

Builder.java

public abstract class Builder { abstract void buildBoard(String board); abstract void buildDisplay(String display); abstract void buildOs(); abstract Computer build(); }

4.4 Builder concreto

MacBookBuilder.java

public class MacBookBuilder extends Builder { private Computer mComputer=new MacBook(); @Override void buildBoard(String board) { mComputer.setBoard(board); } @Override void buildDisplay(String display) { mComputer.setDisplay(display); } @Override void buildOs() { mComputer.setOs(); } @Override Computer build() { return mComputer; } }

4.5 La clase Director, responsable de construir Computer concretamente.

Director.java

public class Director { Builder mBuilser=null; public Director(Builder builer) { this.mBuilser = builer; } public void construct(String board,String display){ mBuilser.buildDisplay(display); mBuilser.buildBoard(board); mBuilser.buildOs(); } }

4.6 Uso específico

Test.java

public class Test { public static void main(String[] args){ Builder builder=new MacBookBuilder(); Director pcDirector=new Director(builder); pcDirector.construct("Placa base Intel","Monitor Retina"); Computer computer = builder.build(); System.out.println(computer.toString()); } }

5. Resumen

Para construir objetos complejos de manera flexible, el objeto tendrá múltiples variables miembro. Cuando se llama desde el exterior, no es necesario o no es conveniente crear todas las variables miembro de una sola vez. En este caso, usar múltiples métodos de construcción para construir el objeto es difícil de mantener. Aquí el patrón de diseño Builder resuelve este problema: se crea el objeto en el método buid() y se pasa el builder; en este builder se mantienen las variables miembro del objeto pasado.

Autor: OneXzgj

Enlace: https://www.jianshu.com/p/f958ba891467