In-depth understanding of the three implementation methods of Java factory pattern

In-depth understanding of the three implementation methods of Java factory pattern

The factory pattern is a creational design pattern, which provides the best way to create objects. Separating the object creation process from the usage process can help us decouple the code and improve the maintainability and scalability of the code. In Java, the factory pattern has a wide range of applications. This article will introduce three implementation methods of Java factory pattern and provide specific code examples.

1. Simple Factory Pattern

Simple factory pattern is also called static factory pattern. Through a factory class, different instance objects are created according to different parameters. . It contains three roles: factory class, abstract product class and concrete product class.

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

// 抽象产品类
interface Product {
    void print();
}

// 具体产品类A
class ProductA implements Product {
    @Override
    public void print() {
        System.out.println("Product A");
    }
}

// 具体产品类B
class ProductB implements Product {
    @Override
    public void print() {
        System.out.println("Product B");
    }
}

// 工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        } else {
            throw new IllegalArgumentException("Invalid product type.");
        }
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.print();  // 输出：Product A
        
        Product productB = SimpleFactory.createProduct("B");
        productB.print();  // 输出：Product B
    }
}

In the above code, the abstract product class Product defines a printing method, and the specific product class ProductA and ProductB implement this method. The factory class SimpleFactory uses the static method createProduct to create the corresponding product object according to the incoming parameter type.

2. Factory Method Pattern

The factory method pattern is also called the factory pattern, which distributes the logic of creating products in the factory class to each specific factory in subcategories. It contains four roles: abstract factory class, concrete factory class, abstract product class and concrete product class.

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

// 抽象产品类
interface Product {
    void print();
}

// 具体产品类A
class ProductA implements Product {
    @Override
    public void print() {
        System.out.println("Product A");
    }
}

// 具体产品类B
class ProductB implements Product {
    @Override
    public void print() {
        System.out.println("Product B");
    }
}

// 抽象工厂类
interface Factory {
    Product createProduct();
}

// 具体工厂类A
class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

// 具体工厂类B
class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.print();  // 输出：Product A
        
        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.print();  // 输出：Product B
    }
}

In the above code, the abstract product class Product defines a printing method, and the specific product class ProductA and ProductB implement this method. The abstract factory class Factory defines an abstract method for creating products. The specific factory classes FactoryA and FactoryB respectively implement this method and create corresponding product objects.

3. Abstract Factory Pattern

The abstract factory pattern is an extension of the factory method pattern. It consists of multiple abstract product classes, multiple concrete product classes, It consists of an abstract factory class and multiple concrete factory classes. It provides an optimal way to create a family of related or interdependent objects.

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

// 抽象产品类A
interface ProductA {
    void print();
}

// 具体产品A1
class ProductA1 implements ProductA {
    @Override
    public void print() {
        System.out.println("Product A1");
    }
}

// 具体产品A2
class ProductA2 implements ProductA {
    @Override
    public void print() {
        System.out.println("Product A2");
    }
}

// 抽象产品类B
interface ProductB {
    void print();
}

// 具体产品B1
class ProductB1 implements ProductB {
    @Override
    public void print() {
        System.out.println("Product B1");
    }
}

// 具体产品B2
class ProductB2 implements ProductB {
    @Override
    public void print() {
        System.out.println("Product B2");
    }
}

// 抽象工厂类
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂类1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }
    
    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂类2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }
    
    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.print();  // 输出：Product A1
        
        ProductB productB1 = factory1.createProductB();
        productB1.print();  // 输出：Product B1
        
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.print();  // 输出：Product A2
        
        ProductB productB2 = factory2.createProductB();
        productB2.print();  // 输出：Product B2
    }
}

In the above code, the abstract product classes ProductA and ProductB respectively define a print Method, specific product classes ProductA1, ProductA2, ProductB1 and ProductB2 implement this method. The abstract factory class AbstractFactory defines two abstract methods for creating products. The concrete factory classes ConcreteFactory1 and ConcreteFactory2 respectively implement these two methods to create corresponding products. object.

Through the code examples of the above three implementation methods, we can have a deeper understanding of the application and implementation of the Java factory pattern. Depending on different scenarios and needs, choosing a suitable factory pattern can help us improve the maintainability and scalability of our code, thereby making our code more flexible and easier to maintain.

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