„PHP-Objektorientierte Programmierentwurfsmuster: SOLID-Prinzipien und ihre Anwendungen verstehen'

WBOY
Freigeben: 2024-02-25 21:22:02
nach vorne
1204 Leute haben es durchsucht

Objektorientierte PHP-Programmierentwurfsmuster waren schon immer ein heißes Thema unter Entwicklern. In diesem Artikel geht der PHP-Editor Strawberry näher auf die SOLID-Prinzipien ein, um den Lesern zu helfen, diese Designprinzipien zu verstehen und anzuwenden. Das SOLID-Prinzip ist der Eckpfeiler der objektorientierten Programmierung, einschließlich des Einzelverantwortungsprinzips, des offenen und geschlossenen Prinzips, des Liskov-Substitutionsprinzips, des Schnittstellenisolationsprinzips und des Abhängigkeitsinversionsprinzips. Durch das Erlernen und Üben dieser Prinzipien können Entwickler flexibleren, wartbareren und skalierbareren PHP-Code schreiben.

  1. Single-Responsibility-Prinzip (SRP): Eine Klasse sollte nur für eine Aufgabe verantwortlich sein und diese Aufgabe sollte in der Klasse gekapselt sein. Dies kann die Wartbarkeit und Wiederverwendbarkeit der Klasse verbessern.
class User {
private $id;
private $name;
private $email;

public function __construct($id, $name, $email) {
$this->id = $id;
$this->name = $name;
$this->email = $email;
}

public function getId() {
return $this->id;
}

public function getName() {
return $this->name;
}

public function getEmail() {
return $this->email;
}
}

class UserRepository {
private $connection;

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

public function save(User $user) {
$stmt = $this->connection->prepare("INSERT INTO users (name, email) VALUES (?, ?)");
$stmt->execute([$user->getName(), $user->getEmail()]);
}

public function find($id) {
$stmt = $this->connection->prepare("SELECT * FROM users WHERE id = ?");
$stmt->execute([$id]);
$result = $stmt->fetch();

if ($result) {
return new User($result["id"], $result["name"], $result["email"]);
}

return null;
}
}
Nach dem Login kopieren
  1. Open-Closed-Prinzip (OCP): Software-Entitäten (Klassen, Module usw.) sollten für Erweiterungen offen und für Änderungen geschlossen sein. Dies kann die Flexibilität der Software verbessern und die Softwarewartungskosten senken.
interface Shape {
public function getArea();
}

class Rectangle implements Shape {
private $width;
private $height;

public function __construct($width, $height) {
$this->width = $width;
$this->height = $height;
}

public function getArea() {
return $this->width * $this->height;
}
}

class Circle implements Shape {
private $radius;

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

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

class ShapeCalculator {
public function calculateTotalArea($shapes) {
$totalArea = 0;
foreach ($shapes as $shape) {
$totalArea += $shape->getArea();
}

return $totalArea;
}
}
Nach dem Login kopieren
  1. Liskov-Substitutionsprinzip (LSP): Eine Unterklasse kann ihre übergeordnete Klasse ersetzen, ohne die Korrektheit des Programms zu beeinträchtigen. Dies erhöht die Flexibilität der Software und erleichtert das Refactoring.
class Animal {
public function eat() {
echo "Animal is eating.";
}
}

class Dog extends Animal {
public function bark() {
echo "Dog is barking.";
}
}

class Cat extends Animal {
public function meow() {
echo "Cat is meowing.";
}
}

function feedAnimal(Animal $animal) {
$animal->eat();
}

feedAnimal(new Dog()); // prints "Dog is eating."
feedAnimal(new Cat()); // prints "Cat is eating."
Nach dem Login kopieren
  1. Interface Segregation Principle (ISP): Anstelle einer universellen Schnittstelle sollten mehrere spezialisierte Schnittstellen verwendet werden. Dies kann die Lesbarkeit der Software verbessern und die Softwarewartungskosten senken.
interface Printable {
public function print();
}

interface Scannable {
public function scan();
}

interface Faxable {
public function fax();
}

class Printer implements Printable {
public function print() {
echo "Printer is printing.";
}
}

class Scanner implements Scannable {
public function scan() {
echo "Scanner is scanning.";
}
}

class FaxMachine implements Faxable {
public function fax() {
echo "Fax machine is faxing.";
}
}

class MultifunctionDevice implements Printable, Scannable, Faxable {
public function print() {
echo "Multifunction device is printing.";
}

public function scan() {
Nach dem Login kopieren

Das obige ist der detaillierte Inhalt von„PHP-Objektorientierte Programmierentwurfsmuster: SOLID-Prinzipien und ihre Anwendungen verstehen'. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Quelle:lsjlt.com
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage