How to create flexible object instances using PHP object-oriented simple factory pattern

How to use the PHP object-oriented simple factory pattern to create flexible object instances

The simple factory pattern is a common design pattern that can create objects without exposing the logic Create an object instance. This mode can improve the flexibility and maintainability of the code, and is especially suitable for scenarios where different objects need to be dynamically created based on input conditions. In PHP, we can use the characteristics of object-oriented programming to implement the simple factory pattern.

Let's look at an example below. Suppose we need to create a graphing calculator that can calculate the corresponding area and perimeter based on the shape type entered by the user (circle, square, triangle, etc.).

First, we need to create an abstract class Shape to represent various shapes:

abstract class Shape
{
    abstract public function getArea();
    abstract public function getPerimeter();
}

Then, we create specific shape classes, such as circle class Circle, square class Square and triangle class Triangle ：

class Circle extends Shape
{
    private $radius;

    public function __construct($radius)
    {
        $this->radius = $radius;
    }

    public function getArea()
    {
        return pi() * pow($this->radius, 2);
    }

    public function getPerimeter()
    {
        return 2 * pi() * $this->radius;
    }
}

class Square extends Shape
{
    private $side;

    public function __construct($side)
    {
        $this->side = $side;
    }

    public function getArea()
    {
        return pow($this->side, 2);
    }

    public function getPerimeter()
    {
        return 4 * $this->side;
    }
}

class Triangle extends Shape
{
    private $side1;
    private $side2;
    private $side3;

    public function __construct($side1, $side2, $side3)
    {
        $this->side1 = $side1;
        $this->side2 = $side2;
        $this->side3 = $side3;
    }

    public function getArea()
    {
        // 使用海伦公式计算面积
        $semiPerimeter = ($this->side1 + $this->side2 + $this->side3) / 2;
        return sqrt($semiPerimeter * ($semiPerimeter - $this->side1) *
            ($semiPerimeter - $this->side2) * ($semiPerimeter - $this->side3));
    }

    public function getPerimeter()
    {
        return $this->side1 + $this->side2 + $this->side3;
    }
}

Next, we create a simple factory class ShapeFactory to create corresponding object instances according to the shape type input by the user:

class ShapeFactory
{
    public static function createShape($type, $params)
    {
        switch ($type) {
            case 'circle':
                return new Circle($params['radius']);
            case 'square':
                return new Square($params['side']);
            case 'triangle':
                return new Triangle($params['side1'], $params['side2'], $params['side3']);
            default:
                throw new Exception('Unsupported shape type: ' . $type);
        }
    }
}

Now, we can use the simple factory pattern to create graphics object. For example, we can create a circle object and calculate its area and perimeter:

$params = ['radius' => 5];
$shape = ShapeFactory::createShape('circle', $params);

echo 'Area of the circle: ' . $shape->getArea() . PHP_EOL;
echo 'Perimeter of the circle: ' . $shape->getPerimeter() . PHP_EOL;

The output is:

Area of the circle: 78.539816339745
Perimeter of the circle: 31.415926535897

Similarly, we can also create square and triangle objects and calculate them area and perimeter.

By using the object-oriented simple factory pattern, we can dynamically create different object instances based on user input without exposing the object creation logic and details. This makes our code more flexible and easier to maintain. In actual development, if you encounter a situation where you need to create different objects based on conditions, you can consider using the simple factory pattern to implement it.

The above is the detailed content of How to create flexible object instances using PHP object-oriented simple factory pattern. For more information, please follow other related articles on the PHP Chinese website!