1. Definition and UML Modeling Diagram

Separate the construction of a complex object from its representation, so that the same construction process can create different representations.

2. Usage Scenarios:

Multiple components or parts can be assembled into one object, but the resulting operation results are the same.

The product class is very complex, or different call sequences in the product class produce different effects.

Initializing an object is particularly complex, such as using multiple constructors, or having many parameters, all with default values.

3. Core Classes

  • (1) Abstract product class: computer.
  • (2) Builder: the abstract Builder, which standardizes the assembly of the product. Subclasses generally implement the specific assembly process.
  • (3) MacbookBuilder: the concrete Builder class, the class that specifically creates objects.
  • (4) Directror: unifies the assembly process.

Focusing on assembling a computer, mainly assembling the host, setting up the operating system, and setting up the monitor.

4. Specific Usage

4.1 Abstract Computer Class

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 Concrete Product Class MacBook

MacBook.java

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

4.3 Abstract Builder

Builder.java

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

4.4 Concrete Builder

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 Director Class, responsible for the specific construction of Computer

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 Specific Usage

Test.java

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

5. Summary

In order to flexibly construct complex objects, the object will have multiple member variables. When called externally, it is not necessary or convenient to create all member variables at once. In this case, using multiple constructors to build objects is difficult to maintain. At this point, the Builder design pattern solves this problem by creating objects in the build() method and passing in the builder. The builder maintains the member variables of the passed-in object.

Author: OneXzgj

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