PHP object-oriented programming (oop) study notes (3) - singleton mode and factory mode_PHP tutorial

There is no doubt that design patterns are win-win for ourselves, others, and the system; design patterns make coding truly engineering; design patterns are the cornerstone of software engineering, just like the structure of a building.

Single case mode

The singleton pattern is very useful when you need to ensure that there can only be one instance of an object. It delegates control of object creation to a single point, and only one instance will exist in the application at any time. A singleton class should not be instantiated outside the class. A singleton class should have the following elements.

Must have a constructor with private access level to effectively prevent the class from being instantiated at will.

Must have a static variable that holds an instance of the class.

There must be a public static method to access this instance, which is usually named GetInstance().

Must have a private and empty __clone method to prevent the instance from being cloned.

The following uses a simple example of a singleton class to illustrate

Copy code The code is as follows:

class ClassName
{
public static $_instance;
private function __construct()
                                                                                                                                                                                                function __construct()
{
if(!(self::$_instance instanceof self))
{
self::$_instance = new self();
}
return self::$ _instance;
}
public function SayHi()
{
echo "Hi boy!";
}
}
$App= ClassName::GetInstance();
$App->SayHi();

/**
 *
 * Output
 *
 * Hi boy!
 * */

Simple Factory Pattern


When you have a large number of classes that implement the same interface, instantiate the appropriate class at the right time. If these new ones are scattered to every corner of the project, it will not only make the business logic confusing but also make the project difficult to maintain. . At this time, if the concept of factory mode is introduced, this problem can be solved well. We can also let the factory class return the appropriate instance for us through application configuration or by providing parameters.

Factory class, which puts the process of instantiating a class into each factory class, is specifically used to create objects of other classes. The factory pattern is often used in conjunction with interfaces, so that the application does not need to know the specific details of these instantiated classes. As long as the factory returns a class that supports a certain interface, it can be used conveniently. The following is a simple example to illustrate the use of factory classes.

Copy code

The code is as follows:

interface ProductInterface
{
    public function showProductInfo();
}
class ProductA implements ProductInterface
{
    function showProductInfo()
    {
        echo 'This is product A.';
    }
}
class ProductB implements ProductInterface
{
    function showProductInfo()
    {
        echo 'This is product B.';
    }
}
class ProductFactory
{
    public static function factory($ProductType)
    {       
        $ProductType = 'Product' . strtoupper($ProductType);
        if(class_exists($ProductType))
        {
            return new $ProductType();
        }
        else
        {
            throw new Exception("Error Processing Request", 1);
        }
    }
}
//这里需要一个产品型号为 A 的对象
$x = ProductFactory::factory('A');
$x -> showProductInfo();
//这里需要一个产品型号为 B 的对象
$o = ProductFactory::factory('B');
$o -> showProductInfo();
//都可以调用showProductInfo方法，因为都实现了接口 ProductInterface.

小结

模式就像是软件工程的基石脉络像大厦的设计图纸一样，这里接触了两种模式：单例模式和工程模式。单例类中存在一个静态变量保存着自身的一个实例，并且提供了获取这个静态变量的静态方法。单例类还应该把构造函数和clone函数标记为私有的，防止破换实例的唯一性。工厂模式根据传入的参数或程序的配置来创建不同的类型实例，工厂类返回的是对象，工厂类在多态性编程实践中是至关重要的。

http://www.bkjia.com/PHPjc/788634.htmlwww.bkjia.comtruehttp://www.bkjia.com/PHPjc/788634.htmlTechArticle毫无疑问，设计模式于己于他人于系统都是多赢的；设计模式使代码编制真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一...