Design Patterns: Builder Pattern
Category Programming Techniques
1. Definition and UML Modeling Diagram
Separating the construction of a complex object from its representation, allowing the same construction process to create different representations.
2. Usage Scenarios:
Multiple parts or components can be assembled into an object, but the resulting operation yields the same outcome.
The product class is very complex, or different call orders in the product class produce different effects.
Initializing an object is particularly complex, such as using multiple constructors, or there are many parameters, and all have default values.
3. Core Classes
(1) Abstract product class computer.
(2) Builder abstract Builder, which standardizes the assembly of the product, and is usually implemented by subclasses for the specific assembly process.
(3) MacBookBuilder a concrete Builder class, the class that specifically creates the object.
(4) Director a class that unifies the assembly process.
The main focus is on assembling a computer, mainly assembling the mainframe, setting the operating system, and setting the display.
4. Specific Usage
4.1 Abstract Computer Class 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 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
To flexibly construct complex objects that have multiple member variables, it is not necessary or convenient to create all member variables at once when called externally. In this case, using multiple constructors to build the object is difficult to maintain. At this time, the Builder design pattern solves this problem by creating the object in the build() method and passing in the builder, which maintains the member variables of the passed-in object.
>
Author: OneXzgj
Link: https://www.jianshu.com/p/f958ba891467
**Click to Share Notes
-
-
-