In-depth analysis of Java factory pattern: implementation of three creational design patterns

Factory Pattern is a commonly used creational design pattern that provides a way to encapsulate object creation for higher flexibility and maintainability. . In Java programming, the factory pattern is often used to create objects of different types without exposing the specific logic of creating the objects.

This article will provide an in-depth analysis of the Java factory pattern and discuss the three implementation methods of the factory pattern.

1. Simple Factory Pattern
Simple Factory Pattern is one of the most basic and common factory patterns. It implements the creation of objects through a factory class, and encapsulates the creation process of specific objects in the factory class.

The following is a sample code of a simple factory pattern:

public class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new IllegalArgumentException("Invalid product type: " + type);
        }
    }
}

public interface Product {
    void operation();
}

public class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("This is product A.");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("This is product B.");
    }
}

// Client
public class Main {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        Product productB = SimpleFactory.createProduct("B");

        productA.operation();
        productB.operation();
    }
}

In the above code, SimpleFactory is a factory class that creates specific product objects based on the passed in parameter type. Then, the client gets the required product object by calling the static method createProduct of SimpleFactory. By using the factory pattern, the client can separate the creation process of specific product objects from the client code, providing higher flexibility and maintainability.

But the disadvantage of the simple factory pattern is that if you want to add a new product type, you need to modify the code of the factory class. This violates the "open-closed principle", which is open to extension and closed to modification.

2. Factory Method Pattern
Factory Method Pattern is a more flexible factory pattern. It defines an abstract factory interface and allows specific factory classes to implement the interface. to create different types of product objects.

The following is a sample code of the factory method pattern:

public interface Factory {
    Product createProduct();
}

public class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// Client
public class Main {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Factory factoryB = new ConcreteFactoryB();

        Product productA = factoryA.createProduct();
        Product productB = factoryB.createProduct();

        productA.operation();
        productB.operation();
    }
}

In the above code, Factory is an abstract factory interface that defines a method for creating product objects. ConcreteFactoryA and ConcreteFactoryB are specific factory classes, respectively responsible for creating specific product objects. The client obtains the required product object by instantiating a specific factory class and then calling its createProduct method.

The advantage of the factory method pattern compared to the simple factory pattern is that by introducing the factory interface and specific factory classes, the system can be expanded and new product types can be added without modifying the existing code. At the same time, the factory method pattern also satisfies the "open-closed principle".

3. Abstract Factory Pattern
The Abstract Factory Pattern is a creational design pattern that provides an interface for creating a series of related or interdependent objects without specifying specific classes. .

The following is a sample code of the abstract factory pattern:

public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

public interface ProductA {
    void operationA();
}

public interface ProductB {
    void operationB();
}

public class ConcreteProductA1 implements ProductA {
    @Override
    public void operationA() {
        System.out.println("This is product A1.");
    }
}

public class ConcreteProductA2 implements ProductA {
    @Override
    public void operationA() {
        System.out.println("This is product A2.");
    }
}

public class ConcreteProductB1 implements ProductB {
    @Override
    public void operationB() {
        System.out.println("This is product B1.");
    }
}

public class ConcreteProductB2 implements ProductB {
    @Override
    public void operationB() {
        System.out.println("This is product B2.");
    }
}

// Client
public class Main {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractFactory factory2 = new ConcreteFactory2();

        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();

        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();

        productA1.operationA();
        productB1.operationB();

        productA2.operationA();
        productB2.operationB();
    }
}

In the above code, AbstractFactory is an abstract factory interface that defines a series of methods for creating product objects. ConcreteFactory1 and ConcreteFactory2 are specific factory classes, respectively responsible for creating a series of related product objects. ProductA and ProductB are abstract product interfaces that define methods of product objects. ConcreteProductA1, ConcreteProductA2, ConcreteProductB1 and ConcreteProductB2 are specific product classes, which are respectively responsible for implementing the methods defined by the abstract product interface.

The advantage of the abstract factory pattern is that the product creation code can be hidden in a specific factory class. The client only needs to care about the abstract factory interface and does not need to care about the specific factory and product implementation. At the same time, the abstract factory pattern also satisfies the "open-closed principle".

Summary
The factory pattern is a common design pattern for creating objects and is widely used in Java programming. This article analyzes three implementation methods of the factory pattern: simple factory pattern, factory method pattern and abstract factory pattern. Different implementation methods are suitable for different scenarios, and the appropriate factory model can be selected according to specific needs.

The factory pattern provides higher flexibility and maintainability by encapsulating the object creation process, and satisfies the "open-closed principle". It is a recommended design pattern that can be used to improve the scalability and maintainability of your code.

The above is the detailed content of In-depth analysis of Java factory pattern: implementation of three creational design patterns. For more information, please follow other related articles on the PHP Chinese website!