PHP design pattern singleton pattern learning

class A{
 private function __construct(){}
}
$a = new A();
?>

The program running result is: Fatal error: Call to private A::__construct() from invalid context in E:PHPProjectstest.php on line 6

We have prohibited the external use of new to instantiate this class. How do we allow users to access this class? The front door is blocked, we need to leave a back door for users. The solution is: static modified method, you can directly access this method without instantiating a class. //Classes that cannot be instantiated with new.
//static methods are reserved for external access.
//Return the instance inside the method.

class A{
 private function __construct(){}
 static function getClassA(){
 $a = new A();
 return $a;
 }
}
// Look What is indeed returned here is an instance of A. But it is not the same object.
$a1 = A::getClassA();
$a2 = A::getClassA();
echo "The class of $a1 is".get_class( $a1)." , $a2 is ".get_class($a1);
if($a1 === $a2){
 echo " $a1 $a2 points to the same object.";
}else{
 echo " $a1 $a2 is not an object.";
}
?>

The program running result is: The class of $a1 is A , $a2 is A $a1 $a2 is not an object.

We have returned the instance of A through the static method. But there's still a problem. How do we ensure that we obtain the same instance through multiple operations?

Solution: There is only one static attribute internally. Static attributes can be effectively called by static methods. Also set this property to private to prevent external calls. First set this property to null. Before each return of the object, first determine whether this property is null. If null, create a new instance of this class and assign it to this static property. If it is not empty, return the static property pointing to the instance. //Classes that cannot be instantiated with new.
//static methods are reserved for external access.
//Return the instance inside the method.
//Define static attributes to ensure that this instance can be called by static methods.
//Add judgment part.

class A{
 private static $a = null;
 private function __construct(){}
 static function getClassA(){
 if( null == self::$a){
 self::$a = new A();
 }
 return self::$a;
 }
}
// You can see that the instance of A is indeed returned here. But it is not the same object.
$a1 = A ::getClassA();
$a2 = A::getClassA();
echo "The class of $a1 is ".get_class($a1)." , $a2 is ".get_class($a1);
if($ a1 === $a2){
 echo " $a1 $a2 points to the same object.";
}else{
 echo " $a1 $a2 is not an object.";
}
? >

The program running result is: The class of $a1 is A , $a2 is A $a1 $a2 point to the same object.

At this point, we have written the simplest singleton pattern. Now, you can try to write a database connection class that applies the singleton design pattern. Remember the usage and writing methods of the singleton pattern.