PHP object-oriented advanced design patterns: factory pattern usage examples

The largest switch/case statement I have ever seen in an object-oriented program had over 20 conditions. During runtime, this code module executes all conditions every time. Each condition is responsible for creating a new object, which is used to communicate with external uses of the application's API. After performing some general troubleshooting on one of them, I started looking at the interfaces implemented by the application. To my surprise, every class referenced in the switch/case statement is implementing the same interface! When later adding new conditional statements to the switch/case statement, I recommend using the factory pattern instead.

What is factory pattern?

The factory design pattern provides an interface for obtaining a new instance of an object, while enabling the calling code to avoid determining the steps to actually instantiate the base class.

As PHP has grown and evolved as a language, its features have continued to provide simple means of development through the application of proven design patterns. A particularly useful feature in PHP is the ability to create new instances of a class based on the contents of variables. This dynamic method of object instantiation is a code block building approach to implementing the Factory design pattern in PHP.

Classes based on the Factory design pattern help reduce condition-based complexity in the main code flow. Throughout an application, objects are called in many and different ways. Any modification related to the creation of an object affects the rest of the application. Suppose you instantiate one of 5 objects to complete some functionality. Creating conditional statements to determine which objects are instantiated is one approach. Conditional statements may be complex if/else statements or switch/case statements. This functionality can be used in many places in the application, but results in duplicate code. Next, if a sixth object is added or the name of one of the five existing objects is changed, then all instances of the program code need to be modified and tested again. The factory design pattern helps avoid this headache by providing a simple interface for creating the above objects. Whether the object is modified or other objects are added, the Factory object is still called in the same way. Displaying a blog entry is an instance of display.

The creation of different objects is not the only purpose of using the factory design pattern. Another use case for classes based on the Factory design pattern is when working with collections of items. In this case, the object collection contains the same base object, but each object has different characteristics.

When several steps are required to determine the type of object to create, it is best to use a class based on the factory design pattern to retrieve new instances.

UML

This UML diagram details a class design using the factory design pattern.

The following is a description of the above picture:

1. The two existing base classes are MyObjectTyepA and MyObjectTyepB. Both mines have a public method called doSomething(), which performs object-specific logic in its own unique way. The public interfaces and return types of the two base classes are exactly the same.

2. The MyObjectFactory class is used to create an instance of any of the above base classes and return it to the code flow. It has a public method called createObject(), which accepts a parameter type, which helps determine which instance of the base class should be created. Subsequently, the createObject() method returns an instance of the requested type class.

PHP Design Pattern Factory Pattern Usage Examples

<?php
/*
* 每日练习 PHP设计模式工厂模式的使用方法
* PHP工厂模式不难理解，顾名思义，就是一个加工厂，然后工厂是制造产品的，只要制造产品
* 就必须有几个要素："方法"，"模型"，"工厂车间"。
*/
/*第一种示例 普通工厂模式
* */
abstract class model {//产品模型
abstract function getNames();
}
class zhangsan extends model {//产品实例
function getNames(){
return "my name is zhengsan";
}
}
class lisi extends model{//产品实例
function getNames(){
return "my name is lisi";
}
}
abstract class gongchangModel {//工厂模型
abstract function getZhangsan();
abstract function getLisi();
}
class gongchang extends gongchangModel{//工厂实例
function getZhangsan(){
return new zhangsan();
}
function getLisi(){
return new lisi();
}
}
$gongchang=new gongchang();//实例化工厂
$zhangsan=$gongchang->getZhangsan();//制造产品
echo $zhangsan->getNames();//产品输出功能
?>

I wrote an article about the factory design pattern before. In fact, the factory pattern includes the ordinary factory pattern and the abstract factory pattern, but whether it is All factory patterns have one function, which is to generate objects.

Okay, let’s use the simplest example below to demonstrate the factory pattern in the PHP design pattern.

I have summarized the three elements of the factory model:

1. Product model

2. Product examples

3. Factory workshop

<?php
abstract class prModel {//产品模型
abstract function link();
}
class webLink extends prModel{//实例一个产品
public function link(){
echo "www.jb51.net";
}
}
class gongchang {//工厂
static public function createLink (){
return new webLink();
}
}
$weblink=gongchang::createLink();//通过工厂制造一个对象
$weblink->link();//输出 www.jb51.net
?>

The above is the detailed content of PHP object-oriented advanced design patterns: factory pattern usage examples. For more information, please follow other related articles on the PHP Chinese website!