Breaking News: Grepper is joining You.com. Read the official announcement!

What is the difference between Builder design pattern and Factory design pattern?

Add Answer

Pragya Keshap answered on February 10, 2023 Popularity 5/10 Helpfulness 6/10

answer What is the difference between Builder design pattern and Factory design pattern?

What is the difference between Builder design pattern and Factory design pattern?

Comment

Both Factory and Builder patterns are creational design patterns.

They are similar in nature but Factory pattern is a simplified generic

version of Builder pattern.

We use Factory pattern to create different concrete subtypes of an

Object. The client of a Factory may not know the exact subtype. E.g.

If we call createDrink() of a Factory, we may get Tea or Coffee

drinks.

We can also use Builder pattern to create different concrete

subtypes of an object. But in the Builder pattern the composition of

the object can be more complex. E.g. If we call createDrink() for

Builder, we can getCappuccino Coffee with Vanilla Cream and

Sugar, or we can get Latte Coffee with Splenda and milk cream.

So a Builder can support creation of a large number of variants of

an object. But a Factory can create a broader range of known

subtypes of an object

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;
    
    public static class Builder {
        // Required parameters
        private final int servingSize;
        private final int servings;
        
        // Optional parameters - initialized to default values
        private int calories = 0;
        private int fat = 0;
        private int carbohydrate = 0;
        private int sodium = 0;
        
        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }
        
        public Builder calories(int val) {
            calories = val;
            return this;
        }
        
        public Builder fat(int val) {
            fat = val;
            return this;
        }
        
        public Builder carbohydrate(int val) {
            carbohydrate = val;
            return this;
        }
        
        public Builder sodium(int val) {
            sodium = val;
            return this;
        }
        
        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }
    
    private NutritionFacts(Builder builder) {
        servingSize = builder.servingSize;
        servings = builder.servings;
        calories = builder.calories;
        fat = builder.fat;
        sodium = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
    
    public static void main(String[] args) {
        NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8)
                .calories(100).sodium(35).carbohydrate(27).build();
    }
}

https://stalk-calvin.github.io/blog/2016/10/15/builder-pattern.html

Popularity 5/10 Helpfulness 6/10 Language java

Source: Grepper

Tags: between builder difference factory java

Link to this answer
Share Copy Link

Contributed on Feb 10 2023

Pragya Keshap

0 Answers Avg Quality 2/10

What is the difference between Builder design pattern and Factory design pattern?

Contents

More Related Answers

What is the difference between Builder design pattern and Factory design pattern?

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.