Separate the construction of a complex object from its representation so that the same construction process can create different representations.



Source Code

/**
 * The interface Product defines interface to create parts of the
 * Product.
 */
public interface Builder {

    /**
     * Construct part of the complex Product.
     */
    public void buildPart();

    /**
     * Construct the Product.
     *
     * @return the constructed product
     */
    public Product getProduct();
}

/**
 * The ConcreteBuilder is the product of a concrete builder.
 *
 */
public class ConcreteBuilder implements Product {
}


/**
 * The ConcreteBuilderBuilder creates and assembles parts of
 * the Product.
 *
 */
public class ConcreteBuilderBuilder implements Builder {

    /**
     * Reference to Product being constructed
     */
    private ConcreteBuilder concreteBuilder;

    /**
     * Construct part of the complex Product.
     */
    public void buildPart() {
        // put your code here
    }

    /**
     * Construct the Product.
     *
     * @return the constructed product
     */
    public Product getProduct() {
        return concreteBuilder;
    }
}


/**
 * The ConcreteBuilderClient initialized the Director with a
 * Concrete Bulder to create the Product and gets result from the Builder.
 *
 */
public class ConcreteBuilderClient {

    /**
     * Use the Builder to create the Product.
     */
    public void createProduct() {
        ConcreteBuilderBuilder builder = new ConcreteBuilderBuilder();
        new Director(builder).construct();
        Product product = builder.getProduct();
    }
}


/**
* The class Director manages Product creation using Builder.
*/
public class Director {

    /**
     * Reference to Builder currently used
     */
    private Builder builder;

    /**
     * Create a new Director instance.
     *
     * @param builder the builder which will create the product
     */
    public Director(Builder builder) {
        this.builder = builder;
    }

    /**
     * Construct the Product using the Builder.
     */
    public void construct() {
        builder.buildPart();
    }
}


/**
 * The interface Product defines a complex object that is
 * constructed part-by-part with Builder.

 */
public interface Product {
}






comments powered by Disqus

You might like also

No Thumbnail was found
You do not create your objects but describe (using cofiguration file) how they should be created and wired together in code. A container (for ex: in case of Spring framework, the IOC container) is then responsible for hooking it all up. In a typical IOC scenario, the container creates all the objects, wires them together by setting the necessary properties, and determines when methods will be invoked. The three implementation pattern types for IOC are: Type 1 Services need to …
4744 Days ago
Type Safe Enumeration
Create a class that approximates an equivalent Pascal enumeration or C enum. A specific enumeration will be represented by a class with specific instances corresponding to each element of the enumerations and public static final fields to access the instances.Existing in Java Tiger 1.5Elements are ordered and comparableEnumeration elements are serializableEnumeration element Name lookup is supportedMethods sequencing is includedSource Code/** * Type Safe Enumeration: Colors elements: Red, Blue, Green, Yellow, White */ public final class Colors implements Comparable, Serializable /** …
5201 Days ago
Singleton
Ensure a class only has one instance, and provide a global point of access to it. Statically Initialized The singleton class is implemented by defining a static field that is statically initialized (that is, the field is initialized when the class is initialized). This has the advantage that invocations of the method used to access the singleton do not incur the overhead of checking whether or not the instance has been created. Dynamically Initialized The singleton class is implemented by …
5201 Days ago
Dynamic polymorphic abstract factory
This package contains a dynamic polymorphic factory... New class can be add dynamically to the factory... even during runtime (dynamic)Factory methods are in a separate class as virtual functions. (polymorphism)Different types of factories can be subclassed from the basic factory.. (abstract)Useful iin case of licence problem, since Concrete classes are created at runtime, and only need to reside in classpath (If they are not present the code still compile). Below, the example show multiple authorization and autorisation scheme, that can …
5201 Days ago
Prototype
Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.Source Code/** * Declares interface for cloning itself. * @role __Prototype */ public interface Prototype /** * Implements an operation for cloning itself. */ public class ConcretePrototype1 implements Prototype public Prototype createCopy() } /** * Implements an operation for cloning itself. */ public class ConcretePrototype1 implements Prototype public Prototype createCopy() } …
5208 Days ago
Abstract factory
Provide an interface for creating families of related or dependent objects without specifying their concrete classes.Source Code/** * Abstract factory declares an interface for operations that create abstract * product objects. * * @role __Factory */ public interface AbstractFactory /** * Abstract factory declares an interface for operations that create abstract * product objects. * * @role __Factory */ public interface AbstractFactory /** * Abstract product - an interface for a type of Product object. * * @role __Product * …
5208 Days ago