Some personal understanding of the Builder (creator mode) of the design pattern

The builder model is simple, but has always been trying to figure out why it should be designed so that the builder wants product rather than the director who knows the construction process. Just now Google to an article, finally clear. Here's a richardluo metaphor.

Simply put, it is as if I want a house to live, but I do not know how to cover (simple walls, low level), do not know how to design (build several rooms, several doors look good, higher level), so I need to find a bunch of migrant workers, they will drywall, but also to find a designer, he knows how to design, I also want to make sure that the migrant workers listen to the leadership of the designers, and the designers themselves do not work, just under the order, here to build a wall, here a door, so that the migrant workers started construction, finally, I can to the migrant workers to the House. In this process, the designer is nothing, except his in the mind of the design and command, so the house is also with the migrant workers to, remember!

The following is the code for Richardluo, and I added the corresponding comments according to his ideas.


1, define the worker interface , is to be able to complete the construction of the House task of the general requirements of the people.

Java code

1. Worker interface that defines the work done by each worker. They are responsible for the construction of specific components such as windows and floors.
2. At the same time because the house is built by migrant workers, so after the completion of the building by him to return the house to the landlord
3. Public interface Builder {
5. public void Makewindow ();
7. public void Makefloor ();
9. Public getroom ();
10. }

2, the definition of the designer, his duty is to direct the landlord assigned to his workers according to their own design intentions to build the house.

Java code

1. Designer. He knows how the house should be designed, but he does not build it himself, but directs the laborers to build it.
2. Public class Designer {
4. //directing migrant workers to work
5. Public void order (Builder builder) {
6. Builder.makewindow ();
7. Builder.makefloor ();
8. }
9. }

3, migrant workers , he is responsible for the implementation of specific things.

Java code

2. Migrant. Responsible for the construction of specific parts such as windows and floors.
4. At the same time because the house is built by migrant workers, so after the completion of the building by him to return the house to the landlord
6. Public class Mingong implements Builder {
8. private String window="";
10. private String floor="";
14. public void Makewindow () {
16. window=New String ("window");
18. }
22. public void Makefloor () {
24. floor=New String ("floor");
26. }
30. //House to homeowners
32. Public Getroom () {
34. if ((!window.equals (")) && (!floor.equals ( "))) {
36. System.out.println ("ready!");
38. return new Guest ();
40. }
42. else return null;
44. }
46. }

4, the landlord , is to hire people, to collect the house.

Java code

2. Homeowners. The task of the homeowner is to hire a migrant worker, a designer, and instruct the migrant worker to work with the designer. Finally from the migrant workers to collect the house.
4. Public class Client {
8. public static void Main (string[] args) {
10. Builder Mingong = new Mingong ();
12. Designer designer = new designer ();
14. Designer.order (Mingong);
16. Mingong.getroom ();
18. }
20. }

Well, I think that's probably clear. I wonder what you think? Or there is a better explanation for the application, please enlighten me.

Some personal understanding of the Builder (creator mode) of the design pattern (GO)