1, Definition
The Factory Method pattern defines an interface for creating objects and lets subclasses decide which class to instantiate. Factory methods delay instantiation of a class to its subclasses.

2, Usage scenario
Based on the simple factory mode, the factory method mode gives the choice of judgment logic to the client, so that the client can decide which specific factory class to use. This is the disadvantage of factory method compared with simple factory mode. In this case, you need to know what specific factory classes are in advance. Compared with the straightforward new object, you don't need to remember the specific product class. The server hides the creation details of the specific product class. In the specific factory class, you don't have to create the specific product class. You can also do some other things, which is in line with the object-oriented encapsulation.

The simple factory mode plus products needs to modify the internal judgment logic, which violates the opening and closing principle in the six modes of design mode, that is, it is open to expansion and closed to modification. The factory method mode plus products only needs to add corresponding specific factory objects, which conforms to the opening and closing principle, which is one of the advantages of the factory method mode. Personal view: the factory method pattern is suitable for the scenario where specific product objects are often replaced (i.e. added and deleted), and takes advantage of this advantage. For example, you are a designer when the clothing season changes. When the new products are put on the shelves and new products are added, the boss chooses a new factory. The sales merchant only needs to obtain new products from the factory. The old products are taken off the shelves and the contract with the old factory expires. That's it.

3, Role analysis
After the internal logic judgment of the factory role in the simple factory mode is handed over to the client, the details of the created object are encapsulated to the specific factory classes, which inherit from a common interface. Simple factory mode can be viewed: simple factory mode.

The factory method mode has the following four roles:

Abstract factory role (IFactory): the public interface of a specific factory, which defines the products returned by the factory method
Concrete factory role (ConcreteFactoryImpl): inherit the factory public interface, implement factory methods, and return specific product instances during runtime
Abstract product role (IProduct)
Specific product role (ConcreteProductImpl)
4, Code example
The code example still uses the operation of addition, subtraction, multiplication and division. Like the simple factory mode, it only splits the factory class SimpleFactory into abstract factory classes and concrete factory classes. The simple factory mode can be viewed as: simple factory mode.

Abstract factory role (IOperationFactory.java):

public interface IOperationFactory {
	public IOperation createOperation();
}

Abstract concrete factory object public interface.

Specific factory roles (AddOperationFactoryImpl.java, SubOperationFactoryImpl.java, MulOperationFactoryImpl.java, DivOperationFactoryImpl.java):

// Addition plant
public class AddOperationFactoryImpl implements IOperationFactory {

	@Override
	public IOperation createOperation() {
		return new AddOperationImpl();
	}

}
// Subtraction factory
public class SubOperationFactoryImpl implements IOperationFactory {

	@Override
	public IOperation createOperation() {
		return new SubOperationImpl();
	}

}
//  Multiplication factory
public class MulOperationFactoryImpl implements IOperationFactory {

	@Override
	public IOperation createOperation() {
		return new MulOperationImpl();
	}

}
//  Division factory
public class DivOperationFactoryImpl implements IOperationFactory {

	@Override
	public IOperation createOperation() {
		return new DivOperationImpl();
	}

}

Each specific factory object corresponds to a specific product object.

Abstract product role (IProduct.java):

public interface IOperation {
	public int getResult(int a, int b);
}

Specific product roles (AddOperationImpl.java, SubOperationImpl.java, MulOperationImpl.java, DivOperationImpl.java):

// Addition implementation class
public class AddOperationImpl implements IOperation{

	@Override
	public int getResult(int a, int b) {
		return a + b;
	}

}
// Subtraction implementation class
public class SubOperationImpl implements IOperation {
	
	@Override
	public int getResult(int a, int b) {
		return a - b;
	}
}
// Multiplication implementation class
public class MulOperationImpl implements IOperation {

	@Override
	public int getResult(int a, int b) {
		return a * b;
	}

}
// Division implementation class
public class DivOperationImpl implements IOperation {

	@Override
	public int getResult(int a, int b) {
		return a / b;
	}

}

Test class (FactoryMethodTest.java):

public class FactoryMethodTest {
	
	public static void main(String[] args) {
		int a = 999, b = 888;
		// plus
		// Create a specific factory
		IOperationFactory operationFactory = new AddOperationFactoryImpl();
		// Create specific products
		IOperation operation = operationFactory.createOperation();
		// Call the functions of specific products
		int result = operation.getResult(a, b); // 1887
		System.out.println(result);
		
		// reduce
		operationFactory = new SubOperationFactoryImpl();
		operation = operationFactory.createOperation();
		result = operation.getResult(a, b); // 111
		System.out.println(result);
		
		// ride
		operationFactory = new MulOperationFactoryImpl();
		operation = operationFactory.createOperation();
		result = operation.getResult(a, b); // 887112
		System.out.println(result);
		
		// except
		operationFactory = new DivOperationFactoryImpl();
		operation = operationFactory.createOperation();
		result = operation.getResult(a, b); // 1
		System.out.println(result);
		
	}
	
}

5, Advantages and disadvantages
advantage:

1. In the factory method mode, the factory method is used to create the product required by the customer. At the same time, it also hides the details of which specific product class will be instantiated from the customer. Users only need to care about the factory corresponding to the required product, do not need to care about the creation details, or even know the class name of the specific product class.

2. Polymorphic design based on factory role and product role is the key of factory method pattern. It enables factories to independently determine what product object to create, and the details of how to create this object are completely encapsulated in specific factories. Factory method pattern is also called polymorphic factory pattern because all specific factory classes have the same abstract parent class.

3. Another advantage of using the factory method pattern is that when adding new products to the system, there is no need to modify the interface provided by the abstract factory and the abstract product, the client, or other specific factories and specific products, but just add a specific factory and specific product. In this way, the scalability of the system becomes very good and fully conforms to the requirements "Opening and closing principle".

Disadvantages:
1. When adding new products, you need to write new specific product classes and provide corresponding specific factory classes. The number of classes in the system will increase in pairs, which increases the complexity of the system to a certain extent. More classes need to be compiled and run, which will bring some additional overhead to the system.

2. Considering the scalability of the system, it is necessary to introduce an abstraction layer, which is defined in the client code, which increases the abstraction and understanding difficulty of the system, and DOM, reflection and other technologies may be used in the implementation, which increases the difficulty of the implementation of the system.