PHP object-oriented programming and design patterns (3)_PHP tutorial

PHP Advanced Programming Study Notes 2014.06.11

Design pattern is a set of classified and cataloged code design experiences that are used repeatedly and are known to most people. The purpose of using design patterns is to reuse code, make the code easier to understand by others, and ensure code reliability. There is no doubt that design patterns are win-win for oneself, 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 pattern

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, empty __clone method to prevent instances from being cloned.

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

<span>class</span><span> ClassName
{

    </span><span>public</span> <span>static</span> <span>$_instance</span><span>;
    
    </span><span>private</span> <span>function</span><span> __construct()
    {
        </span><span>#</span><span> code...</span>
<span>    }

    </span><span>private</span> <span>function</span><span> __clone()
    {
        </span><span>#</span><span> empty</span>
<span>    }

    </span><span>public</span> <span>static</span> <span>function</span><span> GetInstance()
    {
        </span><span>if</span>(!(self::<span>$_instance</span><span> instanceof self))
        {
            self</span>::<span>$_instance</span> = <span>new</span><span> self();
        }
        </span><span>return</span> self::<span>$_instance</span><span>;
    }

    </span><span>public</span> <span>function</span><span> SayHi()
    {
        </span><span>echo</span> "Hi boy!"<span>;
    }
}

</span><span>$App</span>= ClassName::<span>GetInstance();
</span><span>$App</span>-><span>SayHi();

</span><span>/*</span><span>*
 *
 * Output
 *
 * Hi boy! 
 *
 </span><span>*/</span>

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 the factory class.

<span>interface</span><span> ProductInterface
{
    </span><span>public</span> <span>function</span><span> showProductInfo();
}

</span><span>class</span> ProductA <span>implements</span><span> ProductInterface
{
    </span><span>function</span><span> showProductInfo()
    {
        </span><span>echo</span> 'This is product A.'<span>;
    }
}
</span><span>class</span> ProductB <span>implements</span><span> ProductInterface
{
    </span><span>function</span><span> showProductInfo()
    {
        </span><span>echo</span> 'This is product B.'<span>;
    }
}

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

Summary

Pattern is like the cornerstone of software engineering. Like the design drawings of a building, two patterns are exposed here: singleton pattern and engineering pattern. There is a static variable in the singleton class that stores an instance of itself, and provides a static method to obtain this static variable. Singleton classes should also mark the constructor and clone function as private to prevent the uniqueness of the instance from being violated. The factory pattern creates different types of instances based on the parameters passed in or the configuration of the program. The factory class returns objects. The factory class is crucial in the practice of polymorphic programming.