PHP design pattern: Bridge mode learning experience (with case code)

If you have a shape class (Shape), it currently extends two subclasses, the circle class and the square class. The pseudo code is as follows:

interface Shape
{
    function fill ();
}

class circleShage implements Shape
{
    public function fill ()
    {
        echo '圆形' . PHP_EOL;
    }
}

class SquareShape implements Shape
{
    public function fill ()
    {
        echo '正方形' . PHP_EOL;
    }
}

Now you want to add color to the shape - red, blue. So, what should you do? If you use the idea of ​​inheritance, then you need to write four classes, as follows:

class RedCircleShage implements Shape
{
    public function fill ()
    {
        echo '红色圆形' . PHP_EOL;
    }
}

class RedSquareShape implements Shape
{
    public function fill ()
    {
        echo '红色正方形' . PHP_EOL;
    }
}

class BlueCircleShage implements Shape
{
    public function fill ()
    {
        echo '蓝色圆形' . PHP_EOL;
    }
}

class BlueSquareShape implements Shape
{
    public function fill ()
    {
        echo '蓝色正方形' . PHP_EOL;
    }
}

But now if I want to add a new shape-triangle, new color- Black as well as white. Then we need 12 subclasses (class explosion), so is there any good way to solve it?

Synthesis (combination) and aggregation

Before solving the above problems, we want to understand the meaning of synthesis and aggregation.

Principle of synthesis and aggregation: Try to use synthesis/aggregation and try not to use inheritance.

Synthesis (combination): Indicates a relationship (strong relationship) between a whole and a part. They have the same life cycle, such as the relationship between a person and the heart. The heart is a part of a person.

Aggregation: Represents a relationship between the whole and a part (weak relationship), indicating that A object can contain B object, but B object is not part of A object. For example, we talked about shape and color above. Shape can contain color, but color is not part of the shape.

The bridge mode uses aggregation to decouple the system.

Bridge pattern

Definition: Separate the abstract part from its implementation so that they can change independently

Above The definition of is difficult to understand. Using our example above, a system may have multiple angle classifications (color, shape), and each classification may change (new shapes and colors are added), then we can use Separate the implementation of the system from multiple perspectives and reduce the coupling between them.

So how to achieve it? The following is the implementation code:

abstract class FShape
{
    protected $color = null;
    public function __construct(IColor $color)
    {
        $this->color = $color;
    }
    public function shape ()
    {
        echo $this->color->color() . $this->setShape() . PHP_EOL;
    }
    protected abstract function setShape ();
}

class CircleShape extends FShape
{
    protected function setShape ()
    {
        return '圆形';
    }
}

class SquareShape extends FShape
{
    protected function setShape ()
    {
        return '正方形';
    }
}

interface IColor
{
    public function color ();
}

class BlueColor implements IColor
{
    public function color ()
    {
        return '蓝色';
    }
}

class RedColor implements IColor
{
    public function color ()
    {
        return '红色';
    }
}

The test code is as follows:

$blueColor = new BlueColor();
$redColor = new RedColor();

$blueCircleShape = new CircleShape($blueColor);
$redCircleShape = new CircleShape($redColor);
$blueSquareShape = new SquareShape($blueColor);
$redSquareShape = new SquareShape($redColor);

$blueCircleShape->shape();
$redCircleShape->shape();
$blueSquareShape->shape();
$redSquareShape->shape();

After using the bridge mode, our code complies with the "opening and closing principle". When a new shape or color is added, We just need to add new classes. There is no need to modify the previous class.

Learning recommendation:

php video tutorial

##mysql video tutorial

The above is the detailed content of PHP design pattern: Bridge mode learning experience (with case code). For more information, please follow other related articles on the PHP Chinese website!