Let's talk about the five basic principles of PHP object-oriented design (S.O.L.I.D)

This article will take you through the five basic principles of Lets talk about the five basic principles of PHP object-oriented design (S.O.L.I.D) object-oriented design (S.O.L.I.D). I hope it will be helpful to you!

##S.O.L.I.Dis an acronym for the 5 principles of object-oriented design (OOD) developed by Robert C. .Proposed by Martin, better known as Uncle Bob.These guidelines make it easier to develop scalable and maintainable software. It also makes the code more streamlined and easier to refactor. Also part of agile development and adaptive software development.

Note

This is not a simple introduction to "Welcome to_*S.O.L.I.D*", this article wants to clarify*# What is ##S.O.L.I.D***.

The expanded acronyms may look complicated, but they're actually pretty easy to understand.

S

• O- Open-Closed Principle
• L- Liskov Substitution Principle
• I- Interface Isolation Principle
• D- Dependency Inversion Principle
• Next Let's look at each principle to understand why S.O.L.I.D can help us become better developers.

The abbreviation isS.R.P, and the content of this principle is:

A class has and can only have one factor that causes it to change, which means that a class should only have a single responsibility.

For example, suppose we have some shapes and want to calculate the total area of these shapes. Yes, it's easy, right?

class Circle { public $radius; public function __construct($radius) { $this->radius = $radius; } } class Square { public $length; public function __construct($length) { $this->length = $length; } }

Copy after login

First, we create a graphics class, and the constructor of this class initializes the necessary parameters. Next, create the

class, and then write the logic code to calculate the total area of the specified graphic.

class AreaCalculator { protected $shapes; public function __construct($shapes = array()) { $this->shapes = $shapes; } public function sum() { // logic to sum the areas } public function output() { return 'Sum of the areas of provided shapes: ' . $this->sum(); } }

AreaCalculatorTo use the method, we simply instantiate this class and pass it a graphics array to display the output content at the bottom of the page.

$shapes = array( new Circle(2), new Square(5), new Square(6) ); $areas = new AreaCalculator($shapes); echo $areas->output();

The problem with the output method is thatAreaCalculatorhandles the data output logic. So, what if the user wants to output the data in json or other formats?

All logic is handled by theAreaCalculatorclass, which exactly violates the Single Responsibility Principle (SRP); the

class should only be responsible for calculating the total area of the graph, it does not You should care whether the user wants data in json or HTML format.So, to solve this problem, you can create aSumCalculatorOutputterclass and use it to handle the display logic required to handle how the total area of all graphics should be displayed. The

SumCalculatorOutputterclass works as follows:

$shapes = array( new Circle(2), new Square(5), new Square(6) ); $areas = new AreaCalculator($shapes); $output = new SumCalculatorOutputter($areas); echo $output->JSON(); echo $output->HAML(); echo $output->HTML(); echo $output->JADE();

Now, whatever format of data you want to output to the user is handled by theSumCalculatorOutputterclass.

Objects and entities should be open for extension, but closed for modification.

Simply put, a class should be able to easily extend its functionality without modifying itself. Let's take a look at the

AreaCalculator

class, specifically the

method.

public function sum() { foreach($this->shapes as $shape) { if(is_a($shape, 'Square')) { $area[] = pow($shape->length, 2); } else if(is_a($shape, 'Circle')) { $area[] = pi() * pow($shape->radius, 2); } } return array_sum($area); }

, but this violates Opening and closing principle.The way to make thissummethod better is to move the code logic that calculates the area of each shape out of the sum method and put it into each shape class:

class Square { public $length; public function __construct($length) { $this->length = $length; } public function area() { return pow($this->length, 2); } }

The same operation should be used to handle theCircleclass, adding an

method to the class. Now, calculating the sum of the areas of any shape should be as simple as:

public function sum() { $area = []; foreach($this->shapes as $shape) { $area[] = $shape->area(); } return array_sum($area); }

method in the shape object?Interface coding is part of the practiceS.O.L.I.D. For example, in the following example we create an interface class, and each shape class will implement this interface class:

interface ShapeInterface { public function area(); } class Circle implements ShapeInterface { public $radius; public function __construct($radius) { $this->radius = $radius; } public function area() { return pi() * pow($this->radius, 2); } }

In our In the sum method ofAreaCalculator, we can check whether the provided instance of the shape class is an implementation of

, otherwise we throw an exception:

public function sum() { $area = []; foreach($this->shapes as $shape) { if(is_a($shape, 'ShapeInterface')) { $area[] = $shape->area(); continue; } throw new AreaCalculatorInvalidShapeException; } return array_sum($area); }

class VolumeCalculator extends AreaCalulator { public function construct($shapes = array()) { parent::construct($shapes); } public function sum() { // logic to calculate the volumes and then return and array of output return array($summedData); } }

class SumCalculatorOutputter { protected $calculator; public function __constructor(AreaCalculator $calculator) { $this->calculator = $calculator; } public function JSON() { $data = array( 'sum' => $this->calculator->sum(); ); return json_encode($data); } public function HTML() { return 'Sum of the areas of provided shapes: ' . $this->calculator->sum(); } }

$areas = new AreaCalulator($shapes); $volumes = new VolumeCalculator($solidShapes); $output = new SumCalculatorOutputter($areas); $output2 = new SumCalculatorOutputter($volumes);

public function sum() { // logic to calculate the volumes and then return and array of output return $summedData; }

interface ShapeInterface { public function area(); public function volume(); }

interface ShapeInterface { public function area(); } interface SolidShapeInterface { public function volume(); } class Cuboid implements ShapeInterface, SolidShapeInterface { public function area() { //计算长方体的表面积 } public function volume() { // 计算长方体的体积 } }

interface ManageShapeInterface { public function calculate(); } class Square implements ShapeInterface, ManageShapeInterface { public function area() { /Do stuff here/ } public function calculate() { return $this->area(); } } class Cuboid implements ShapeInterface, SolidShapeInterface, ManageShapeInterface { public function area() { /Do stuff here/ } public function volume() { /Do stuff here/ } public function calculate() { return $this->area() + $this->volume(); } }

class PasswordReminder { private $dbConnection; public function __construct(MySQLConnection $dbConnection) { $this->dbConnection = $dbConnection; } }

interface DBConnectionInterface { public function connect(); }

class MySQLConnection implements DBConnectionInterface { public function connect() { return "Database connection"; } } class PasswordReminder { private $dbConnection; public function __construct(DBConnectionInterface $dbConnection) { $this->dbConnection = $dbConnection; } }

The above is the detailed content of Let's talk about the five basic principles of PHP object-oriented design (S.O.L.I.D). For more information, please follow other related articles on the PHP Chinese website!