The builder pattern for Java design patterns

This article continues to introduce the builder model of the 23 design pattern series. Definition: Builder mode: Separates the construction of a complex object from its representation so that the same build process can create different representations. Practical scope 1, when the algorithm to create complex objects should be independent of the object's components and the way they are assembled. 2, when the construction process must allow the constructed object to have different representations. Role in this design pattern, there are several roles: 1, Builder: Specify an abstract interface for each part that creates a product object. 2. ConcreteBuilder: Implements the builder interface to construct and assemble the individual parts of the product, defines and clarifies the representations it creates, and provides an interface for retrieving the product. 3. Director: Constructs an object that uses the Builder interface to guide the build process. 4. Product: Represents the complex object being constructed. ConcreteBuilder creates an internal representation of the product and defines its assembly process, which contains the classes that define the constituent parts, including the interfaces that assemble the parts into the final product. Role Builder: [Java]View PlainCopy print?

1. Public interface Personbuilder {
2. void Buildhead ();
3. void Buildbody ();
4. void Buildfoot ();
5. Person Buildperson ();
6. }

Role ConcreteBuilder: [Java]View PlainCopyprint?

2. Public class Manbuilder implements Personbuilder {
4. person person;
6. Public Manbuilder () {
8. person = New Mans ();
10. }
12. public void Buildbody () {
14. Person.setbody ("building a man's body");
16. }
18. public void Buildfoot () {
20. Person.setfoot ("building a man's foot");
22. }
24. public void Buildhead () {
26. Person.sethead ("Building a man's head");
28. }
30. Public person Buildperson () {
32. return person;
34. }
36. }

Role ConcreteBuilder: [Java]View PlainCopy print?

2. Public class Womanbuilder implements Personbuilder {
4. person person;
6. Public Womanbuilder () {
8. person = new Woman ();
10. }
12. public void Buildbody () {
14. Person.setbody ("Building a Woman's body");
16. }
18. public void Buildfoot () {
20. Person.setfoot ("Build a woman's foot");
22. }
24. public void Buildhead () {
26. Person.sethead ("Build a woman's head");
28. }
30. Public person Buildperson () {
32. return person;
34. }
36. }

Role Director: [Java]View PlainCopyprint?

1. Public class Persondirector {
2. Public person Constructperson (Personbuilder pb) {
3. Pb.buildhead ();
4. Pb.buildbody ();
5. Pb.buildfoot ();
6. return Pb.buildperson ();
7. }
8. }

Role Product: [Java]View PlainCopyprint?

2. Public class Person {
4. Private String head;
6. private String body;
8. private String foot;
12. Public String GetHead () {
14. return head;
16. }
18. public void Sethead (String head) {
20. this.head = head;
22. }
24. Public String GetBody () {
26. return body;
28. }
30. public void Setbody (String body) {
32. this.body = body;
34. }
36. Public String Getfoot () {
38. return foot;
40. }
42. public void Setfoot (String foot) {
44. this.foot = foot;
46. }
48. }
50. Public class Mans extends person {
52. Public Mans () {
54. System.out.println ("Start building men");
56. }
58. }
60. Public class Woman extends person {
62. Public Woman () {
64. System.out.println ("Start building women");
66. }
68. }

Test: [Java]View PlainCopyprint?

2. Public class test{
4. public static void Main (string[] args) {
6. Persondirector PD = new Persondirector ();
8. Person Womanperson = Pd.constructperson (new Manbuilder ());
10. Person Manperson = Pd.constructperson (new Womanbuilder ());
12. }
14. }

The builder model can evolve in many forms during use: if there is only one concrete object to be built, the abstract builder and director can be omitted, allowing ConcreteBuilder to play the role of mentor and builder, Even ConcreteBuilder can be put into product. In the "Effective Java" book, the second article mentions "when encountering multiple constructor parameters to consider the builder", in fact, the builder here is the builder mode, but the inside of the four characters are put into the specific product inside. The above example, if only a man, evolved as follows: [Java]View PlainCopyprint?

2. Public class Man {
4. Private String head;
6. private String body;
8. private String foot;
12. Public String GetHead () {
14. return head;
16. }
18. public void Sethead (String head) {
20. this.head = head;
22. }
24. Public String GetBody () {
26. return body;
28. }
30. public void Setbody (String body) {
32. this.body = body;
34. }
36. Public String Getfoot () {
38. return foot;
40. }
42. public void Setfoot (String foot) {
44. this.foot = foot;
46. }
48. }

[Java]View PlainCopy print?

2. Public class manbuilder{
4. Mans Man;
6. Public Manbuilder () {
8. man = New Man ();
10. }
12. public void Buildbody () {
14. Man.setbody ("building a man's body");
16. }
18. public void Buildfoot () {
20. Man.setfoot ("building a man's foot");
22. }
24. public void Buildhead () {
26. Man.sethead ("Building a man's head");
28. }
30. Public Mans Builderman () {
32. Buildhead ();
34. Buildbody ();
36. Buildfoot ();
38. return man;
40. }
42. }

Test: [Java]View PlainCopy print?

1. Public class test{
2. public static void Main (string[] args) {
3. Manbuilder builder = new Manbuilder ();
4. Mans man = Builder.builderman ();
5. }
6. }

More Design Patterns: 23 design Mode Series

jason0539

Blog: http://blog.csdn.net/jason0539 (reprint please indicate the source)

Sweep code Follow me public number

The builder pattern for Java design patterns