Basic concepts and principles of Java-based factory pattern

Basic concepts and principles of factory pattern in Java

Factory pattern is a common design pattern that aims to create objects through a common interface, and There is no need to know the specific implementation details. This pattern can provide us with a more flexible and extensible code structure. In Java, there are many ways to implement the factory pattern, including simple factory pattern, factory method pattern and abstract factory pattern.

1. Simple Factory Pattern

The simple factory pattern is the most basic form of the factory pattern, which creates objects through a factory class. This factory class usually contains a static method to create different object instances based on different parameters. The following is a simple example:

public class SimpleFactory {
    public static Product createProduct(String type) {
        if(type.equals("A")) {
            return new ConcreteProductA();
        } else if(type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

public interface Product {
    void doSomething();
}

public class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("Product A do something.");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("Product B do something.");
    }
}

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

        Product productB = SimpleFactory.createProduct("B");
        productB.doSomething();
    }
}

In the above code, SimpleFactory is a simple factory class that creates corresponding product objects based on the parameters passed in. Product is an abstract interface that defines the basic behavior of product objects. ConcreteProductA and ConcreteProductB are specific product classes and implement the Product interface respectively.

2. Factory method pattern

The factory method pattern is an improvement on the simple factory pattern. It moves specific product creation to their respective factory classes. . This pattern implements object creation by defining an abstract factory interface and multiple concrete factory classes. The following is an example:

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();
    }
}

public class Main {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.doSomething();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.doSomething();
    }
}

In the above code, Factory is an abstract factory interface that defines the method for creating products. ConcreteFactoryA and ConcreteFactoryB are specific factory classes that create ConcreteProductA and ConcreteProductB product objects respectively.

3. Abstract Factory Pattern

The abstract factory pattern is a further extension of the factory method pattern, which creates a set of related or dependent products. This pattern provides an abstract factory interface and multiple concrete factory classes, each factory class is responsible for creating a set of related products. The following is an example:

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 doSomething();
}

public class ConcreteProductA1 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("ProductA1 do something.");
    }
}

public class ConcreteProductA2 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("ProductA2 do something.");
    }
}

public interface ProductB {
    void doSomething();
}

public class ConcreteProductB1 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("ProductB1 do something.");
    }
}

public class ConcreteProductB2 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("ProductB2 do something.");
    }
}

public class Main {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.doSomething();
        ProductB productB1 = factory1.createProductB();
        productB1.doSomething();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.doSomething();
        ProductB productB2 = factory2.createProductB();
        productB2.doSomething();
    }
}

In the above code, AbstractFactory is an abstract factory interface that defines methods for creating multiple products. ConcreteFactory1 and ConcreteFactory2 are specific factory classes that create a set of product objects ProductA and ProductB respectively. ProductA and ProductB are abstract product interfaces that define the basic behavior of the product. ConcreteProductA1, ConcreteProductA2, ConcreteProductB1 and ConcreteProductB2 are specific product classes, which implement ProductA and ## respectively. #ProductBInterface.

The factory pattern can help us create objects through a unified interface, separate the creation and use of objects, and provide a more flexible and decoupled code structure. By rationally using the factory pattern, we can improve the maintainability and scalability of the code.

The above is the detailed content of Basic concepts and principles of Java-based factory pattern. For more information, please follow other related articles on the PHP Chinese website!