How to apply the simple factory pattern in PHP to achieve automated creation of objects

The simple factory pattern is a common design pattern that is used to create objects and abstract The process of instantiating an object. In PHP, applying the simple factory pattern can help us decouple object creation and specific implementation, making the code more flexible and maintainable.

In this article, we will use an example to illustrate how to apply the simple factory pattern in PHP. Suppose we have an electronics store that sells mobile phones and televisions. We need to create corresponding product objects based on user selections and provide corresponding functions.

First, we need to create a product interface, which defines the methods that mobile phones and TVs need to implement.

interface ProductInterface
{
    public function getInfo();
    public function getPrice();
}

Then, we create two specific product categories, namely mobile phones and televisions.

class Phone implements ProductInterface
{
    private $brand;
    private $model;
    private $price;
    
    public function __construct($brand, $model, $price)
    {
        $this->brand = $brand;
        $this->model = $model;
        $this->price = $price;
    }
    
    public function getInfo()
    {
        return "手機品牌：{$this->brand}，型號：{$this->model}";
    }
    
    public function getPrice()
    {
        return $this->price;
    }
}

class TV implements ProductInterface
{
    private $brand;
    private $model;
    private $price;
    
    public function __construct($brand, $model, $price)
    {
        $this->brand = $brand;
        $this->model = $model;
        $this->price = $price;
    }
    
    public function getInfo()
    {
        return "電視品牌：{$this->brand}，型號：{$this->model}";
    }
    
    public function getPrice()
    {
        return $this->price;
    }
}

Next, we create a simple factory class, which is responsible for creating corresponding product objects based on the user's selections.

class ProductFactory
{
    public static function create($type, $brand, $model, $price)
    {
        switch ($type) {
            case 'phone':
                return new Phone($brand, $model, $price);
                break;
            case 'tv':
                return new TV($brand, $model, $price);
                break;
            default:
                throw new Exception("不支持的產(chǎn)品類型：{$type}");
        }
    }
}

Now, we can use the simple factory pattern to automatically create objects in our code. Here is an example:

$phone = ProductFactory::create('phone', 'iPhone', '11 Pro', 6999);
$tv = ProductFactory::create('tv', 'Sony', 'Bravia', 5999);

echo $phone->getInfo();  // 輸出：手機品牌：iPhone，型號：11 Pro
echo $tv->getInfo();  // 輸出：電視品牌：Sony，型號：Bravia

echo $phone->getPrice();  // 輸出：6999
echo $tv->getPrice();  // 輸出：5999

By using the simple factory pattern, we can create different types of product objects based on the user's selection without caring about specific implementation details. In this way, when we need to add a new product type, we only need to modify the factory class without modifying the calling code, thereby achieving code scalability.

To sum up, the simple factory pattern is a simple and effective design pattern that can help us realize the automated creation of objects and improve the flexibility and maintainability of the code. Applying the simple factory pattern in PHP can help us decouple the object creation process and make the code more extensible and easier to understand.

The above is the detailed content of How to apply the simple factory pattern in PHP to realize automated creation of objects. For more information, please follow other related articles on the PHP Chinese website!