Builder Design pattern - Real Time Example [Beverage]

Master Software Architecture & Clean Code!

Subscribe to Ram N Java for clean code, design pattern implementations, and practical Java tutorials!

SUBSCRIBE NOW

Understanding the Beverage Builder Concept

The Builder Design Pattern is a creational pattern designed to construct complex objects step by step. When preparing custom beverages (such as tea or coffee), the preparation process involves configuring multiple attributes—water volume, milk ratio, sugar levels, and beverage powder.

Rather than using long constructors with numerous parameters (the telescoping constructor anti-pattern), the Builder pattern separates the construction steps from the beverage representation. This allows the same assembly sequence to produce diverse beverage recipes cleanly and flexibly.

Complete Java Code Walkthrough

Here is an end-to-end, object-oriented Java implementation demonstrating how to prepare different beverages using the Builder pattern:

// 1. Product Class
class Beverage {
    private int water;
    private int milk;
    private int sugar;
    private String powderType;

    public void setWater(int water) { this.water = water; }
    public void setMilk(int milk) { this.milk = milk; }
    public void setSugar(int sugar) { this.sugar = sugar; }
    public void setPowderType(String powderType) { this.powderType = powderType; }

    @Override
    public String toString() {
        return "Beverage [Water=" + water + "ml, Milk=" + milk + "ml, Sugar=" + sugar + " spoons, Powder=" + powderType + "]";
    }
}

// 2. Builder Interface
interface BeverageBuilder {
    void buildWater();
    void buildMilk();
    void buildSugar();
    void buildPowder();
    Beverage getBeverage();
}

// 3. Concrete Builder: Tea
class TeaBuilder implements BeverageBuilder {
    private Beverage beverage = new Beverage();

    @Override
    public void buildWater() { beverage.setWater(100); }

    @Override
    public void buildMilk() { beverage.setMilk(50); }

    @Override
    public void buildSugar() { beverage.setSugar(2); }

    @Override
    public void buildPowder() { beverage.setPowderType("Tea Leaves"); }

    @Override
    public Beverage getBeverage() { return this.beverage; }
}

// 4. Concrete Builder: Coffee
class CoffeeBuilder implements BeverageBuilder {
    private Beverage beverage = new Beverage();

    @Override
    public void buildWater() { beverage.setWater(50); }

    @Override
    public void buildMilk() { beverage.setMilk(150); }

    @Override
    public void buildSugar() { beverage.setSugar(1); }

    @Override
    public void buildPowder() { beverage.setPowderType("Roasted Coffee Powder"); }

    @Override
    public Beverage getBeverage() { return this.beverage; }
}

// 5. Director Class
class BeverageMaker {
    private BeverageBuilder builder;

    public BeverageMaker(BeverageBuilder builder) {
        this.builder = builder;
    }

    public void brewBeverage() {
        builder.buildWater();
        builder.buildMilk();
        builder.buildSugar();
        builder.buildPowder();
    }

    public Beverage getBeverage() {
        return builder.getBeverage();
    }
}

// 6. Client Application
public class BeverageBuilderDemo {
    public static void main(String[] args) {
        // Brew Tea
        BeverageBuilder teaBuilder = new TeaBuilder();
        BeverageMaker teaMaker = new BeverageMaker(teaBuilder);
        teaMaker.brewBeverage();
        Beverage cupOfTea = teaMaker.getBeverage();
        System.out.println("Ready: " + cupOfTea);

        // Brew Coffee
        BeverageBuilder coffeeBuilder = new CoffeeBuilder();
        BeverageMaker coffeeMaker = new BeverageMaker(coffeeBuilder);
        coffeeMaker.brewBeverage();
        Beverage cupOfCoffee = coffeeMaker.getBeverage();
        System.out.println("Ready: " + cupOfCoffee);
    }
}

Key Architectural Benefits

• Step-by-Step Encapsulation: Complex object assembly is isolated into explicit steps instead of bloated constructors.
• Separation of Concerns: The Beverage product holds data, while the concrete builder holds configuration details, and the director manages the workflow.
• Consistency & Extensibility: Adding a new drink type (such as GreenTeaBuilder) requires zero modifications to existing classes or the client orchestration code.

Watch More Related Design Pattern Tutorials

• Builder Design Pattern in Action: Making Animal Toys
• Builder Design Pattern: Overview and Basics
• Builder Design Pattern: Class Diagram Explained

---

Click here to watch in Youtube : https://www.youtube.com/watch?v=6T52yw1PpGs

Click the below Image to Enlarge

Builder Design pattern - Real Time Example [Beverage]

See also:

Builder Design Pattern - Introduction

Builder Design pattern - Real Time Example [Meal Package]

Builder Design pattern - Real Time Example [Animal Toys]

Builder Design Pattern - Class Diagram

Builder Design Pattern - Sequence Diagram

Builder Design Pattern - Implementation [Beverage]

Builder Design Pattern - Implementation [Animal Toy]

Builder Design Pattern - KeyPoints

All Design Patterns Links