Easy Tutorial
❮ Working Process Of The Compiler Android Tutorial Bitmap1 ❯

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

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

Cancel

-

-

-

❮ Working Process Of The Compiler Android Tutorial Bitmap1 ❯