In-depth discussion on the implementation and application of Java factory pattern

Detailed explanation of the principles and applications of Java factory pattern

Factory pattern is a commonly used design pattern, which is used to create objects and encapsulate the creation process of objects . There are many ways to implement the factory pattern in Java, the most common of which are the simple factory pattern, the factory method pattern and the abstract factory pattern. This article will introduce the principles and applications of these three factory patterns in detail, and give corresponding code examples.

1. Simple Factory Pattern
The simple factory pattern is the simplest and most commonly used factory pattern. It uses a factory class to return different instantiated objects based on the parameters passed in. The core idea of ​​the simple factory pattern is to encapsulate the object creation process so that the caller does not need to care about the object creation details.

A simple example is given below. Suppose we have a calculator class Calculator, which has the functions of addition and subtraction:

public class Calculator {
    public double add(double a, double b) {
        return a + b;
    }
    
    public double subtract(double a, double b) {
        return a - b;
    }
}

We can use the simple factory pattern to create Calculator Instance of:

public class CalculatorFactory {
    public static Calculator createCalculator() {
        return new Calculator();
    }
}

Then use this factory class in the client code to create an instance of Calculator:

public class Client {
    public static void main(String[] args) {
        Calculator calculator = CalculatorFactory.createCalculator();
        double result = calculator.add(1.0, 2.0);
        System.out.println(result);
    }
}

Through the above code, we can see that using the simple factory pattern, the client code There is no need to call new Calculator() directly to create an instance of Calculator. Instead, create an instance by calling the static method of CalculatorFactory. The advantage of this is that the client code only needs to know how to use the Calculator's functions and does not need to care about its specific creation process.

2. Factory method pattern
The factory method pattern encapsulates the object creation process in the factory interface, and the specific creation steps are implemented by specific factory classes. In the factory method pattern, each concrete factory class is only responsible for creating specific product objects.

The following is an implementation example of the factory method pattern. Suppose we have a pizza shop that provides different types of pizza, such as CheesePizza and PepperoniPizza:

First, we define a pizza interface:

public interface Pizza {
    void prepare();
    void bake();
    void cut();
    void box();
}

Then, we define a specific pizza class:

public class CheesePizza implements Pizza {
    @Override
    public void prepare() {
        System.out.println("Preparing Cheese Pizza");
    }
    
    @Override
    public void bake() {
        System.out.println("Baking Cheese Pizza");
    }
    
    @Override
    public void cut() {
        System.out.println("Cutting Cheese Pizza");
    }
    
    @Override
    public void box() {
        System.out.println("Boxing Cheese Pizza");
    }
}

public class PepperoniPizza implements Pizza {
    @Override
    public void prepare() {
        System.out.println("Preparing Pepperoni Pizza");
    }
    
    @Override
    public void bake() {
        System.out.println("Baking Pepperoni Pizza");
    }
    
    @Override
    public void cut() {
        System.out.println("Cutting Pepperoni Pizza");
    }
    
    @Override
    public void box() {
        System.out.println("Boxing Pepperoni Pizza");
    }
}

Next, we define a pizza factory interface:

public interface PizzaFactory {
    Pizza createPizza();
}

Then, we implement two specific pizza factory classes respectively :

public class CheesePizzaFactory implements PizzaFactory {
    @Override
    public Pizza createPizza() {
        return new CheesePizza();
    }
}

public class PepperoniPizzaFactory implements PizzaFactory {
    @Override
    public Pizza createPizza() {
        return new PepperoniPizza();
    }
}

Finally, use the pizza factory in the client code to create an instance of pizza:

public class Client {
    public static void main(String[] args) {
        PizzaFactory pizzaFactory = new CheesePizzaFactory();
        Pizza pizza = pizzaFactory.createPizza();
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
    }
}

Through the above code, we can see that using the factory method pattern, the client code only needs Care about the type of pizza factory and call its creation method to create the corresponding pizza object. In this way, when adding a new type of pizza, you only need to add a specific pizza class and the corresponding pizza factory class without modifying the client code.

3. Abstract Factory Pattern
The abstract factory pattern is an extension of the factory method pattern. It defines a set of related or dependent factory interfaces through the abstract factory class. The specific factory class implements these interfaces and based on Different needs produce different products.

The following is an implementation example of the abstract factory pattern. Suppose we have a computer factory that can produce computers of different brands, such as Dell computers and Lenovo computers:

First, we define the computer interface and specific Computer class:

public interface Computer {
    void use();
}

public class DellComputer implements Computer {
    @Override
    public void use() {
        System.out.println("Using Dell computer");
    }
}

public class LenovoComputer implements Computer {
    @Override
    public void use() {
        System.out.println("Using Lenovo computer");
    }
}

Then, we define the abstract computer factory interface:

public interface ComputerFactory {
    Computer createComputer();
}

Next, we implement the specific computer factory class respectively:

public class DellComputerFactory implements ComputerFactory {
    @Override
    public Computer createComputer() {
        return new DellComputer();
    }
}

public class LenovoComputerFactory implements ComputerFactory {
    @Override
    public Computer createComputer() {
        return new LenovoComputer();
    }
}

Finally, in Abstract factories are used in client code to create computer instances of different brands:

public class Client {
    public static void main(String[] args) {
        ComputerFactory dellComputerFactory = new DellComputerFactory();
        Computer dellComputer = dellComputerFactory.createComputer();
        dellComputer.use();

        ComputerFactory lenovoComputerFactory = new LenovoComputerFactory();
        Computer lenovoComputer = lenovoComputerFactory.createComputer();
        lenovoComputer.use();
    }
}

Through the above code, we can see that using the abstract factory pattern, the client code only needs to know how to use the abstract factory class and the actual Product interface, without caring about specific factory classes and product implementation details. In this way, if you need to add a new computer brand, you only need to add a specific computer class and the corresponding computer factory class without modifying the client code.

Summary:
This article introduces in detail the principles and applications of the factory pattern in Java, including the simple factory pattern, factory method pattern and abstract factory pattern. The simple factory pattern is suitable for creating a single type of object; the factory method pattern is suitable for creating a group of objects with an inheritance relationship; the abstract factory pattern is suitable for creating a group of objects with an associated relationship. By using the factory pattern, we can encapsulate the object creation process, making the client code more concise and easier to maintain and expand the code.

The above is the detailed content of In-depth discussion on the implementation and application of Java factory pattern. For more information, please follow other related articles on the PHP Chinese website!