Abstract Factory Pattern Example in Java

From: AI Tools/OpenAI/Chatgpt

“

Perfect 👍 Let me give you a clean, copyright-free Abstract Factory Pattern Java example with explanation.

🏭 Abstract Factory Pattern Example in Java

Problem:

We want to create UI components (Button, Checkbox) for different operating systems (Windows and Mac). The client should be able to request them without worrying about which OS family is used.

Step 1: Define Product Interfaces

// Product A
interface Button {
    void paint();
}

// Product B
interface Checkbox {
    void check();
}

Step 2: Create Concrete Products

// Windows Variants
class WindowsButton implements Button {
    public void paint() {
        System.out.println("Rendering a Windows style Button");
    }
}

class WindowsCheckbox implements Checkbox {
    public void check() {
        System.out.println("Checking a Windows style Checkbox");
    }
}

// Mac Variants
class MacButton implements Button {
    public void paint() {
        System.out.println("Rendering a Mac style Button");
    }
}

class MacCheckbox implements Checkbox {
    public void check() {
        System.out.println("Checking a Mac style Checkbox");
    }
}

Step 3: Define Abstract Factory

interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

Step 4: Concrete Factories

class WindowsFactory implements GUIFactory {
    public Button createButton() {
        return new WindowsButton();
    }
    public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
}

class MacFactory implements GUIFactory {
    public Button createButton() {
        return new MacButton();
    }
    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}

Step 5: Client Code

public class AbstractFactoryDemo {
    public static void main(String[] args) {
        // Choose factory based on OS
        GUIFactory factory;

        String os = "Windows"; // could be detected dynamically

        if (os.equals("Windows")) {
            factory = new WindowsFactory();
        } else {
            factory = new MacFactory();
        }

        // Use factory to create related objects
        Button button = factory.createButton();
        Checkbox checkbox = factory.createCheckbox();

        // Work with products
        button.paint();
        checkbox.check();
    }
}

✅ Output (if OS = Windows)

Rendering a Windows style Button
Checking a Windows style Checkbox

✅ Output (if OS = Mac)

Rendering a Mac style Button
Checking a Mac style Checkbox

🔑 Key Points:

• Abstract Factory (GUIFactory) ensures we can switch between families of products easily.
• The client never directly instantiates WindowsButton or MacButton; it just asks the factory.
• This makes the code flexible, scalable, and easier to maintain.

👉 Would you like me to also prepare a simpler “real-life” Abstract Factory example (like 🍕 fast-food meal combos) so you can post something more fun and less technical on your blog?

“

From AI Tools/Open AI/ChatGPT

“

Perfect 👍 Here’s a copyright-free comparison table of the Builder Pattern vs Factory Pattern in Java, styled for easy posting on Facebook/Blog:

🏗️ Builder Pattern vs ⚙️ Factory Pattern in Java

✅ Quick Summary:

• Use Builder Pattern when you want to construct a complex object step by step.
• Use Factory Pattern when you want to simplify object creation and let a factory decide which subclass to instantiate.

👉 Would you like me to also prepare a real-world analogy (like food ordering 🍔 for Builder, and coffee shop ☕ for Factory) so your readers instantly understand the difference?

“

Observe the code below:

        ShapeFactory factory = new ShapeFactory();

        Shape shape1 = factory.getShape("circle");
        Shape shape2 = factory.getShape("square");
        Shape shape3 = factory.getShape("rectangle");

        shape1.draw();
        shape2.draw();
        shape3.draw();

We wanted to create objects such as shape1, shape2, and shape 3. We did not directly (create and) call the class for the required objects. We did not create or call a circle class, or a square class, or a rectangle class. We rather thought there was a factory class that could create objects based on our requirements. We asked the factory to create a circle object, then it gave us a circle object. In the same way, we asked for square and rectangle objects from the factory class, and the class returned us square and rectangular objects.

This is about: Factory Design Pattern: Examples are in Java

From AI Tools/OpenAI/Internet

“

Perfect 👍 — here’s a copyright-free write-up of the Factory Pattern in Java that matches the same style as the Builder Pattern post, so you can share both on Facebook or your blog.

⚙️ Java Design Patterns – Factory Pattern

🔹 Definition

The Factory Pattern is a creational design pattern that provides a way to create objects without exposing the creation logic to the client. Instead of directly calling a constructor, you use a factory method that decides which object to return.

🔹 Use Cases

You should use the Factory Pattern when:

• You want to delegate object creation to a central place.
• The exact type of object needed is determined at runtime.
• You want to reduce tight coupling between classes.
• Multiple subclasses share a common interface but have different implementations.

🔹 Advantages

✔️ Encapsulation of object creation logic.
✔️ Makes code easier to extend when adding new object types.
✔️ Promotes loose coupling (client depends on interface, not implementation).
✔️ Simplifies maintenance and testing.
✔️ Encourages code reuse.

🔹 Example in Java

// Product Interface
interface Shape {
    void draw();
}

// Concrete Products
class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing a Circle.");
    }
}

class Square implements Shape {
    public void draw() {
        System.out.println("Drawing a Square.");
    }
}

class Rectangle implements Shape {
    public void draw() {
        System.out.println("Drawing a Rectangle.");
    }
}

// Factory Class
class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) return null;
        switch (shapeType.toLowerCase()) {
            case "circle": return new Circle();
            case "square": return new Square();
            case "rectangle": return new Rectangle();
            default: return null;
        }
    }
}

// Usage
public class FactoryPatternExample {
    public static void main(String[] args) {
        ShapeFactory factory = new ShapeFactory();

        Shape shape1 = factory.getShape("circle");
        Shape shape2 = factory.getShape("square");
        Shape shape3 = factory.getShape("rectangle");

        shape1.draw();
        shape2.draw();
        shape3.draw();
    }
}

✅ Output:

Drawing a Circle.
Drawing a Square.
Drawing a Rectangle.

📌 In short:
The Factory Pattern lets you create objects without knowing their exact class. It simplifies code, promotes loose coupling, and makes it easier to manage different object types from a single point.

👉 Now that we have both Builder and Factory, would you like me to also prepare a comparison table (Builder vs Factory) in the same copyright-free format for FB/Blog? That way your readers can instantly see the differences.

“

Observe these two examples of Object Creation from the Student Class

Student student1 = new Student.Builder("Alice")
                                .age(12)
                                .grade("7th")
                                .email("alice@email.com")
                                .build();

Student student2 = new Student.Builder("Bob")
                                .grade("5th")
                                .build();

We did not call the constructor with the property values, but we built the object step by step with only the properties and values we needed.

This can be useful when we have classes with many properties, many properties/attributes are also optional or serve a specific purpose. Now, we can create an object dynamically with only the properties and values we need.

This is the Builder Design pattern.

From AI Tools/ OpenAI/Iternet

“Got it 👍 — here’s a copyright-free explanation of the Builder Pattern in Java that you can post directly on Facebook or your blog.

🏗️ Java Design Patterns – Builder Pattern

🔹 Definition

The Builder Pattern is a creational design pattern used to construct complex objects step by step. Instead of writing a long constructor with many parameters, the builder lets you create an object in a readable and flexible way.

🔹 Use Cases

You should use the Builder Pattern when:

• An object has many optional or mandatory fields.
• You want to avoid long constructors with many arguments.
• You need to make object creation more readable and less error-prone.
• The same object can be built in different configurations.

🔹 Advantages

✔️ Improves readability of code.
✔️ Makes objects immutable (if setters are avoided).
✔️ Reduces risk of errors when passing many arguments.
✔️ Allows step-by-step construction of objects.
✔️ Provides flexibility for creating different versions of the same object.

🔹 Example in Java

// Product class with Builder
class Student {
    private String name;
    private int age;
    private String grade;
    private String email;

    // Private constructor
    private Student(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.grade = builder.grade;
        this.email = builder.email;
    }

    // Static inner Builder class
    public static class Builder {
        private String name;
        private int age;
        private String grade;
        private String email;

        public Builder(String name) {  // mandatory field
            this.name = name;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public Builder grade(String grade) {
            this.grade = grade;
            return this;
        }

        public Builder email(String email) {
            this.email = email;
            return this;
        }

        public Student build() {
            return new Student(this);
        }
    }

    @Override
    public String toString() {
        return "Student: " + name + ", Age: " + age + ", Grade: " + grade + ", Email: " + email;
    }
}

// Usage
public class BuilderPatternExample {
    public static void main(String[] args) {
        Student student1 = new Student.Builder("Alice")
                                .age(12)
                                .grade("7th")
                                .email("alice@email.com")
                                .build();

        Student student2 = new Student.Builder("Bob")
                                .grade("5th")
                                .build();

        System.out.println(student1);
        System.out.println(student2);
    }
}

✅ Output:

Student: Alice, Age: 12, Grade: 7th, Email: alice@email.com
Student: Bob, Age: 0, Grade: 5th, Email: null

📌 In short:
The Builder Pattern is perfect when creating objects with many optional fields. It improves clarity, maintains immutability, and makes your code cleaner than using constructors with long parameter lists.