Design Pattern: Builder mode

definition: separates the construction of a complex object from its representation so that the same build process can create different representations.

Type: Create class Mode

Class Diagram:

Four elements

• Product class: generally is a more complex object, that is, the process of creating objects is more complex, generally there will be more code volume. In this class diagram, the product class is a concrete class, not an abstract class. In practical programming, a product class can consist of an abstract class with its different implementations, or it can consist of multiple abstract classes and their implementations.
• Abstract Builder: The purpose of introducing abstract builders is to bring the concrete process of construction into its subclasses. This makes it easier to expand. There are generally at least two abstract methods, one for building products and one for returning products.
• Builder: Implement all the non-implemented methods of an abstract class, typically two tasks: build a product, and return to a well-formed product.
• Director class: responsible for invoking the appropriate builder to build the product, the Director class is generally not related to the product class, and direct interaction with the Director class is the Builder class. Generally speaking, the Director class is used to encapsulate the variable parts of the program.

Code implementation

[Java]View Plaincopy

2. Class Product {
4. private String name;
6. private String type;
8. public void Showproduct () {
10. System.out.println ("name:" +name);
12. SYSTEM.OUT.PRINTLN ("model:" +type);
14. }
16. public void SetName (String name) {
18. this.name = name;
20. }
22. public void SetType (String type) {
24. this.type = type;
26. }
28. }
32. Abstract class Builder {
34. public abstract void Setpart (String arg1, string arg2);
36. public Abstract Product getproduct ();
38. }
40. Class ConcreteBuilder extends Builder {
42. Private Product Product = new product ();
46. Public Product getproduct () {
48. return product;
50. }
54. public void Setpart (String arg1, String arg2) {
56. Product.setname (ARG1);
58. Product.settype (ARG2);
60. }
62. }
66. Public class Director {
68. Private Builder builder = new ConcreteBuilder ();
70. Public Product getaproduct () {
72. Builder.setpart ("BMW car","X7");
74. return builder.getproduct ();
76. }
78. Public Product getbproduct () {
80. Builder.setpart ("Audi car","Q5");
82. return builder.getproduct ();
84. }
86. }
88. Public class Client {
90. public static void Main (string[] args) {
92. Director Director = new Director ();
94. Product Product1 = Director.getaproduct ();
96. Product1.showproduct ();
100. Product product2 = Director.getbproduct ();
102. Product2.showproduct ();
104. }
106. }

The advantages of the builder model

First, the builder pattern is well encapsulated. Using builder mode can effectively encapsulate changes, in the case of using builder mode, the general product class and the builder class are more stable, so encapsulating the main business logic in the Director class can achieve better stability overall.

Second, the builder pattern is easy to scale. If there is a new requirement, it can be done by implementing a new builder class, basically without modifying the code that has been tested before, so there is no risk to the original functionality.

The difference between builder mode and factory model

As we can see, the builder pattern is very similar to the factory model, and in general, the builder model is only a "director class" role that is more than the factory model. In the class diagram of the builder pattern, if the director class is seen as the client of the final call, then the rest of the diagram can be seen as a simple factory pattern.

The builder pattern is typically used to create more complex objects than the factory model, because the object creation process is more complex, so the object creation process is independent of the new class-The Director class. In other words, the factory pattern is to encapsulate the entire creation of objects in the factory class, which is provided by the factory class to the client, and the builder's model typically only provides for the construction of individual components in the product class, and the concrete construction process is delivered to the Director class. The Director class is responsible for assembling individual components into products according to specific rules, and then delivering the assembled product to the client.

Summarize

The builder pattern is similar to the factory model, they are both builder models and the applicable scenarios are similar. In general, if the construction of the product is complex , then use the factory model, if the product is more complex to build, then use the builder mode.

Design Pattern: Builder mode