Builder Blueprint Pattern Inward Coffee - Illustration Tutorial

Builder blueprint pattern inwards Java is a creational pattern i.e. used to practise objects, similar to factory method blueprint pattern which is also creational blueprint pattern. Before learning whatsoever blueprint pattern I advise abide by out the work a detail blueprint pattern solves. Its been good said necessity is woman nurture on invention. learning blueprint pattern without facing work is non that effective, Instead if y'all own got already faced issues than its much easier to empathise blueprint pattern too larn how its solve the issue. In this Java blueprint pattern tutorial nosotros volition showtime come across what work Builder blueprint pattern solves which volition give roughly insight on when to role builder blueprint pattern inwards Java, which is also a popular blueprint pattern interview question too and thus nosotros volition come across instance of Builder blueprint pattern too pros too cons of using Builder pattern inwards Java. 

What work Builder pattern solves inwards Java

overloaded constructor for unlike form of cake too thus in that place volition live many constructor too fifty-fifty worst they volition convey many parameter.

Problems:

1) besides many constructors to maintain.

2) fault prone because many fields has same type e.g. sugar too and butter are inwards cups thus instead of two loving cup carbohydrate if y'all overstep two loving cup butter, your compiler volition non complain only volition acquire a buttery cake amongst virtually no carbohydrate amongst high terms of wasting butter.

You tin move partially solve this work yesteryear creating Cake too and thus adding ingredients only that volition impose roughly other work of leaving Object on inconsistent the world during building, ideally cake should non live available until its created. Both of these work tin move live solved yesteryear using Builder blueprint pattern inwards Java. Builder blueprint pattern non solely improves readability only also reduces conduct chances of fault yesteryear adding ingredients explicitly too making object available 1 time fully constructed. 

By the means in that place are many blueprint pattern tutorial already in that place inwards similar Decorator pattern tutorial and  Observer pattern inwards Java. If y'all haven’t read them already too thus its worth looking.

Example of Builder Design pattern inwards Java

We volition role same instance of creating Cake using Builder blueprint pattern inwards Java. hither nosotros own got static nested builder class within Cake which is used to practise object.

Guidelines for Builder blueprint pattern inwards Java

1) Make a static nested shape called Builder within the shape whose object volition live build yesteryear Builder. In this instance its Cake.

2) Builder shape volition own got just same laid of fields equally master copy class.

3) Builder shape volition let on method for adding ingredients e.g. sugar() inwards this example. each method volition provide same Builder object. Builder volition live enriched amongst each method call.

4) Builder.build() method volition re-create all builder patch values into actual shape too provide object of Item class.

5) Item shape (class for which nosotros are creating Builder) should own got private constructor to practise its object from build() method too preclude outsider to access its constructor.

public class BuilderPatternExample {
 
    public static void main(String args[]) {
     
        //Creating object using Builder pattern inwards java
        Cake whiteCake = new Cake.Builder().sugar(1).butter(0.5).  eggs(2).vanila(2).flour(1.5). bakingpowder(0.75).milk(0.5).build();
     
        //Cake is ready to swallow :)
        System.out.println(whiteCake);
    }
}

class Cake {

    private final double sugar;   //cup
    private final double butter;  //cup
    private final int eggs;
    private final int vanila;     //spoon
    private final double flour;   //cup
    private final double bakingpowder; //spoon
    private final double milk;  //cup
    private final int cherry;

    public static class Builder {

        private double sugar;   //cup
        private double butter;  //cup
        private int eggs;
        private int vanila;     //spoon
        private double flour;   //cup
        private double bakingpowder; //spoon
        private double milk;  //cup
        private int cherry;

        //builder methods for setting property
        public Builder sugar(double cup){this.sugar = cup; return this; }
        public Builder butter(double cup){this.butter = cup; return this; }
        public Builder eggs(int number){this.eggs = number; return this; }
        public Builder vanila(int spoon){this.vanila = spoon; return this; }
        public Builder flour(double cup){this.flour = cup; return this; }
        public Builder bakingpowder(double spoon){this.sugar = spoon; return this; }
        public Builder milk(double cup){this.milk = cup; return this; }
        public Builder cherry(int number){this.cherry = number; return this; }
     
     
        //return fully build object
        public Cake build() {
            return new Cake(this);
        }
    }

    //private constructor to enforce object creation through builder
    private Cake(Builder builder) {
        this.sugar = builder.sugar;
        this.butter = builder.butter;
        this.eggs = builder.eggs;
        this.vanila = builder.vanila;
        this.flour = builder.flour;
        this.bakingpowder = builder.bakingpowder;
        this.milk = builder.milk;
        this.cherry = builder.cherry;      
    }

    @Override
    public String toString() {
        return "Cake{" + "sugar=" + carbohydrate + ", butter=" + butter + ", eggs=" + eggs + ", vanila=" + vanila + ", flour=" + flour + ", bakingpowder=" + bakingpowder + ", milk=" + milk + ", cherry=" + cherry + '}';

    }
 
}

Output:
Cake{sugar=0.75, butter=0.5, eggs=2, vanila=2, flour=1.5, bakingpowder=0.0, milk=0.5, cherry=0}

Builder blueprint pattern inwards Java – Pros too Cons

Live everything Builder pattern also has roughly disadvantages, only if y'all expect at below, advantages clearly outnumber disadvantages of Builder blueprint pattern. Any means hither are few advantages too disadvantage of Builder blueprint pattern for creating objects inwards Java.

Advantages:

1) to a greater extent than maintainable if number of fields required to practise object is to a greater extent than than four or 5.

2) less error-prone equally user volition know what they are passing because of explicit method call.

3) to a greater extent than robust equally solely fully constructed object volition live available to client.

Disadvantages:

1) verbose too code duplication equally Builder needs to re-create all fields from Original or Item class.

When to role Builder Design pattern inwards Java

Builder Design pattern is a creational pattern too should live used when number of parameter required inwards constructor is to a greater extent than than manageable commonly four or at most 5. Don't confuse amongst Builder too Factory pattern in that place is an obvious divergence betwixt Builder too Factory pattern, equally Factory tin move live used to practise unlike implementation of same interface only Builder is tied upward amongst its Container shape too solely returns object of Outer class.

That's all on Builder blueprint pattern inwards Java. nosotros own got seen why nosotros quest Builder pattern , what work it solves, Example of builder blueprint pattern inwards Java too finally when to role Builder patter amongst pros too cons. So if y'all are non using telescoping constructor pattern or own got a alternative non to role it than Builder pattern is means to go.

Further Learning
10 Object oriented blueprint principles Java programmer should know

10 interview questions on Singleton pattern inwards Java

How to practise Thread-safe shape inwards Java

Why String is lastly inwards Java

How substring method industrial plant inwards Java

Difference betwixt HashMap too HashSet inwards Java