Java design Pattern 4--builder mode (builder)

This article address: http://www.cnblogs.com/archimedes/p/java-builder-pattern.html, reprint please indicate source address.

Builder mode

Separating the construction of a complex object from its representation allows the same build process to create different representations.

Overview

When the system is ready to provide users with an internally complex object, you can use the generator pattern, which allows you to construct objects incrementally, making the creation of objects more resilient. The key to the builder pattern is to divide the creation of one containing multiple component objects into several steps and encapsulate them in an interface called a generator.

Applicability

1. When creating complex objects, the algorithm should be independent of the parts of the object and how they are assembled.

2. When the construction process must allow the constructed object to have different representations.

Participants

1.BUILDER specifies an abstract interface for each part that creates a product object.

The 2.ConcreteBuilder implements the builder interface to construct and assemble individual parts of the product. Defines and clarifies the representation that it creates. Provides an interface for retrieving products.

3.Director constructs an object that uses the builder interface.

4.Product represents the complex object being constructed. ConcreteBuilder creates an internal representation of the product and defines its assembly process. Contains the classes that define the components that comprise the assembly, including the interfaces that assemble the parts into the final product.

Structure and use of builders ' patterns

The structure of the pattern consists of four roles:

• Products (product)

• Abstract Builder (builder)

• Specific generators (ConcreteBuilder)

• Conductor (director)

UML Class diagrams for schemas

Actual combat part

Example 1: Create a container that contains buttons, labels, and text box components. Different users have different requirements for containers, for example, some users want the container to contain only buttons and labels, and some users want the container to contain only buttons and text boxes. In addition, the user has different requirements for the order of components in the container, for example, some users require components to be left-to-right in the container in the order of the buttons, labels, text boxes, and some users require left-to-right sorting labels, text boxes, buttons.

Description and use of the structure of the pattern

1. Product: Panelproduct.java

import javax.swing.*;  Public class extends jpanel{   JButton button;    JLabel label;                   JTextField TextField;}

2. Abstract Builder (builder): Builer.java

  public  interface   builder{ abstract  void   Buildbutton ();  public  abstract  void   Buildlabel ();  public  abstract  void   Buildtextfield ();  public  abstract   JPanel Getpanel ();}  

3. Concrete Generator (ConcreteBuilder) _1: Concretebuilderone.java

Importjavax.swing.*; Public classConcretebuilderoneImplementsbuilder{Privatepanelproduct Panel; Concretebuilderone () {panel=Newpanelproduct (); }        Public voidBuildbutton () {Panel.button=NewJButton ("button"); }       Public voidBuildlabel () {Panel.label=NewJLabel ("label"); }       Public voidBuildtextfield () {} PublicJPanel Getpanel () {panel.add (Panel.button);           Panel.add (Panel.label); returnPanel; }}

3. Concrete Generator (ConcreteBuilder) _2: Concretebuildertwo.java

Importjavax.swing.*; Public classConcretebuildertwoImplementsbuilder{Privatepanelproduct Panel; Concretebuildertwo () {panel=Newpanelproduct (); }        Public voidBuildbutton () {Panel.button=NewJButton ("button"); }       Public voidBuildlabel () {} Public voidBuildtextfield () {Panel.textfield=NewJTextField ("TextField"); }       PublicJPanel Getpanel () {panel.add (Panel.textfield);            Panel.add (Panel.button); returnPanel; }} 

4. Conductor (director): Director.java

import javax.swing.*;  Public class director{    private  builder Builder;    Director (Builder builder) {       this. builder=Builder;    }       Public JPanel constructproduct () {       Builder.buildbutton ();       Builder.buildlabel ();       Builder.buildtextfield ();       JPanel Product=Builder.getpanel ();        return product;   

5. Application Application.java

Importjavax.swing.*; Public classapplication{ Public Static voidMain (String args[]) {Builder builder=NewConcretebuilderone (); Director Director=NewDirector (builder); JPanel Panel=director.constructproduct (); JFrame Frameone=NewJFrame ();       Frameone.add (panel); Frameone.setbounds (12,12,200,120);       Frameone.setdefaultcloseoperation (Jframe.dispose_on_close); Frameone.setvisible (true); Builder=NewConcretebuildertwo (); Director=NewDirector (builder); Panel=director.constructproduct (); JFrame Frametwo=NewJFrame ();       Frametwo.add (panel); Frametwo.setbounds (212,12,200,120);       Frametwo.setdefaultcloseoperation (Jframe.dispose_on_close); Frametwo.setvisible (true); }}

" Example 2": Building a man's class, making the construction and presentation separate

The class diagram looks like this:

Builder

 Public Interface Personbuilder {    void  buildhead ();     void buildbody ();     void buildfoot ();    Person Buildperson ();}

ConcreteBuilder

 Public classManbuilderImplementsPersonbuilder {person person;  PublicManbuilder () { person=NewMan (); } @Override Public voidBuildhead () {Person.sethead ("Build a man's head."); } @Override Public voidBuildbody () {Person.setbody ("Build a man's body."); } @Override Public voidBuildfoot () {Person.setfoot ("Build a man's foot."); } @Override PublicPerson Buildperson () {returnPerson ; }}

Director

 Public class Persondirector {    public person  Constructperson (Personbuilder pb) {        pb.buildhead ();        Pb.buildbody ();        Pb.buildfoot ();         return Pb.buildperson ();    }}

Product

 Public classPerson {PrivateString Head; PrivateString body; PrivateString Foot;  PublicString GetHead () {returnHead; }     Public voidSethead (String head) { This. Head =Head; }     PublicString GetBody () {returnbody; }     Public voidSetbody (String body) { This. BODY =body; }     PublicString Getfoot () {returnFoot; }     Public voidsetfoot (String foot) { This. Foot =Foot; }} Public classMansextendsPerson {}

Test

 Public class Test {    publicstaticvoid  main (string[] args) {        new persondirector ();         = Pd.constructperson (new  Manbuilder ());        System.out.println (Person.getbody ());        System.out.println (Person.getfoot ());        System.out.println (Person.gethead ());}    }

Benefits of Generator Mode

• The builder pattern encapsulates the construction of an object into a specific generator, and the user can get different representations of the object using different concrete generators.

• Control the construction of objects more finely and effectively. The builder breaks down the construction of the object into several steps, which makes the program more granular and effective in controlling the construction of the entire object.

• The generator mode decouples the object's construction from the creation of the object class, making the creation of objects more flexible and resilient.

• When adding a new concrete generator, you do not have to modify the code of the conductor, that is, the pattern satisfies the open-close principle.

You may also be interested in:

Java Design Pattern Series:

Java design mode 3--singleton mode (Singleton)

Java design Pattern 2--abstract Factory mode (Factory)

Java Design pattern (Factory method)

Introduction to Java Design Patterns 0--Design Patterns

Java design Pattern 4--builder mode (builder)