Analyze the benefits of PHP factory pattern

As the name suggests, the factory can process parts. The Factory mode in the PHP program also has the same function. You can conveniently use a static factory method to instantiate a certain class. So what are the benefits of doing so? What is it? I am new to PHP design patterns. The following is my personal understanding
Generally, when we instantiate a class, we will give it some parameters so that when it is constructed, we can feedback the results we need based on different parameters.
For example, the following is a User class, which is very simple:

<?php
interface IUser{
   function getName();
   function getAge();
}
class User implements IUser{
   protected $_name;
   protected $_age;
   function __construct($name, $age){
      $this->_name = $name;
      $this->_age = (int)$age;
   }
   function getName(){
      return $this->_name;
   }
  function getAge(){
      return $this->_age;
   }
}
?>

If we want to instantiate this class, we need to do this:
$u = new User('Xiao Ming',19);
Generally if this class is rarely used, then this will not have much impact and is very good.
Suddenly I want to add a classification to this class and put Xiao Ming into the student group. It is very easy to modify the code of the next class, but if this class is instantiated many times in many files before we want to modify it, then It becomes very cumbersome to add a parameter to it, because it needs to be replaced with:
$u = new User('Xiaoming',19,'student');
Of course we also This duplication of work can be avoided by setting default values ​​in the __construct function, but in fact this is not good from the perspective of code elegance. Imagine that we have a factory method that can correspond to a set of parameters through an identifier, and put This parameter is stored in a text document or directly in the factory class in the form of an array. It will become much easier when we call the User class. Even if we need to increase or decrease parameter attributes, we do not need to replace the code everywhere. , the following is a factory class (the method can also be stored directly in the User class)

interface IUser{
    function getName();
    function getAge();
}
class User implements IUser{
   protected $_group;
   protected $_name;
   protected $_age;
  function __construct($name, $age, $group){
      $this->_group = $group;
      $this->_name = $name;
      $this->_age = (int)$age;
  }
  function getName(){
     return $this->_name;
  }
  function getAge(){
      return $this->_age;
  }
}
class Fuser{
   private static $group = array(
       array(‘小明‘,19,‘学生‘),
       array(‘小王‘,19,‘学生‘)
   );
   static function create($id){
      list($name, $age, $group) = self::$group[(int)$id];
      return new User($name, $age, $group);
   }
}
echo Fuser::create(0)->getName();

The result should be the output "Xiao Ming".

Related articles:

Detailed explanation of the three forms of sample code of PHP factory mode

A brief analysis of php factory mode

Simple instructions for using php factory mode