It’s understandable that you say this is not used in business. Also, don’t think that only those with class name Factory are factories, such as UUID objects. There are currently 4 versions of UUID, none of which are instantiated by new. Factory produces various versions of UUID. The reason for this design is usually to solve the problem of creating a large number of the same interface classes. After grouping and abstraction, it is convenient for unified management. Similar to encoding charset

It would be a tragedy if you still haven’t encountered one after working for so many years. First of all, you can consider changing jobs to a big company and you will encounter one.
The simplest factory mode is relational/non-relational database switching, version switching, and class library switching. Wait, the reason you haven't encountered it is because there is no need for post-maintenance or there is no need to consider version iterations and database updates, right?

Other design patterns also have their own functions. If you haven’t encountered this thing, it won’t feel important. But if you encounter it, you will feel that it is very easy to use. It uses class encapsulation, inheritance, and polymorphism very cleverly.

Furthermore, the progress of programmers is to study framework source code, language source code, large concurrency, and code maintainability.

Let’s take an example from jdk. The Executors class has a static method of newFixedThreadPool. The interface is defined as follows:

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {

As you can see, the second parameter can be passed in a thread factory, and then the Executors class can create the threads needed by the thread pool based on the factory method. In other words, you can write all the rules for creating threads in ThreadFactory. For example, let the thread names created by the factory have the XXX-prefix, or specify the thread priority, etc.

This can be said to be the most common scenario of the factory pattern, and it is widely used in various frameworks. Learn design patterns and read more actual codes while reading books, and you will naturally discover the specific functions of patterns and even various clever techniques.

Whether it is the factory pattern or other creation patterns, they all have one purpose - to initialize an object. In other words, in order to build a data structure model (classes and objects themselves are a custom data structure).

So, the question is, why can we create an object using new and use design pattern? Essentially, the reason is that we don’t want upper-level users to directly use new to initialize objects. new 这样方式可以创建一个对象，还要使用设计模式。本质上就是一个原因，不想让上层使用者直接使用 new 来初始化对象。

这样的原因有很多，绝大多数原因就是对上层的使用者隔离对象创建的过程；或者是对象创建的过程复杂，使用者不容易掌握；或者是对象创建要满足某种条件，这些条件是业务的需求也好，是系统约束也好，没有必要让上层使用者掌握，增加别人开发的难度。

所以，到这时我们应该清楚了，无论是工厂模式，还是上面的战友说的开闭原则，都是为了隔离一些复杂的过程，使得这些复杂的过程不向外暴露，如果暴露了这些过程，会对使用者增加麻烦，这也就是所谓的团队合作。

面向对象封装的本身也就是为了使得对外的 API 尽可能的简化。

例如，你定义了一个 Status字段，但这个字段因为某些业务原因，需要使用整数来表示状态。那么，如果数字少了还好办，如果数字多了，上层使用者就不一定能记清楚每个数字代表的状态（比如你要做语音通信系统，那么，语音设备是有很多状态数字的）。这时，如果使用 new来创建对象，然后再对 Status

public static class Factory
{
    public static Ixxxxxx CreateWithOpen()
    {
        var obj = new Obj();
        obj.Status = 1;
        return obj;
    }
    public static Ixxxxxx CreateWithClose()
    {
        var obj = new Obj();
        obj.Status = 2;
        return obj;
    }
}