The factory design pattern creates objects centrally through a factory class, avoiding the client using new hard code to instantiate specific classes; 2. Define the abstract product Pizza, and the specific products CheesePizza, VeggiePizza and PepperoniPizza inherit it; 3. PizzaFactory returns the corresponding Pizza instance according to the input type; 4. The client creates objects through the factory and calls its methods to achieve loose coupling and creation logic encapsulation, which is convenient for expansion and maintenance. This implementation is a simple factory pattern, ending with a complete sentence.

Sure! The Factory design pattern is a creative pattern that provides a way to create objects without specifying the exact class of object that will be created. It promotes loose coupling by letting subclasses decide which class to instantiate.

Let's understand it with a simple real-world example: creating different types of pizzas .

? Problem

You want to create a Pizza object, but you don't want to hardcode whether it's a CheesePizza , VeggiePizza , or PepperoniPizza every time. You want a centralized way to create them based on input.

? Solution: Factory Pattern

We'll define:

• A common interface or superclass ( Pizza )
• Concrete classes ( CheesePizza , VeggiePizza )
• A PizzaFactory class that decides which pizza to create

Step-by-step Java Example

1. Define the Product (Pizza interface)

 // Pizza.java
abstract class Pizza {
    String name;

    void prepare() {
        System.out.println("Preparing " name);
    }

    void bake() {
        System.out.println("Baking " name);
    }

    void cut() {
        System.out.println("Cutting " name);
    }

    void box() {
        System.out.println("Boxing " name);
    }
}

2. Create Concrete Products

 // CheesePizza.java
class CheesePizza extends Pizza {
    public CheesePizza() {
        name = "Cheese Pizza";
    }
}

// VeggiePizza.java
class VeggiePizza extends Pizza {
    public VeggiePizza() {
        name = "Veggie Pizza";
    }
}

// PepperoniPizza.java
class PepperoniPizza extends Pizza {
    public PepperoniPizza() {
        name = "Pepperoni Pizza";
    }
}

3. Create the Factory

 // PizzaFactory.java
class PizzaFactory {
    public Pizza createPizza(String type) {
        if (type.equalsIgnoreCase("cheese")) {
            return new CheesePizza();
        } else if (type.equalsIgnoreCase("veggie")) {
            return new VeggiePizza();
        } else if (type.equalsIgnoreCase("pepperoni")) {
            return new PepperoniPizza();
        } else {
            System.out.println("Unknown pizza type: " type);
            return null;
        }
    }
}

4. Use the Factory in Main

 // Main.java
public class Main {
    public static void main(String[] args) {
        PizzaFactory factory = new PizzaFactory();

        Pizza pizza = factory.createPizza("cheese");
        if (pizza != null) {
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }
    }
}

Output:

 Preparing Cheese Pizza
Baking Cheese Pizza
Cutting Cheese Pizza
Boxing Cheese Pizza

? Key Benefits

• Loose Coupling : The client (Main) doesn't need to know how to create a pizza — just ask the factory.
• Easy to Extend : Add a new pizza? Just create a new class and update the factory (or better, use a map/config for zero code change).
• Encapsulates Object Creation : All creation logic lives in one place.

?? Note: Simple vs. Factory Method Pattern

This is the Simple Factory pattern (not to be confused with the more formal Factory Method pattern, which uses inheritance). But it's a great starting point to understand the idea.

If you want full flexibility (eg, different factories for different regions), you'd go further with the Factory Method or Abstract Factory patterns.

Basically, the Factory pattern says: “Don't use new everywhere — let a dedicated method or class decide what to create.”

The above is the detailed content of Can you explain the Factory design pattern with a simple example in Java?. For more information, please follow other related articles on the PHP Chinese website!