Applying SOLID Principles in PHP: Examples and Best Practices

Single Responsibility Principle (SRP)

This principle states that each class should have a single responsibility. It emphasizes that a class should perform one specific function and not have too many reasons to change.

Example: Managing user information and sending email notifications.

class UserManager {
    public function createUser($userData) {
        // Logic for creating a user
    }
}

class EmailService {
    public function sendEmail($emailData) {
        // Logic for sending an email
    }
}

Open/Closed Principle (OCP)

This principle encourages extending functionality by adding new code rather than modifying existing code.

Example: Handling different payment methods in an e-commerce application.

interface PaymentProcessor {
    public function processPayment();
}

class CreditCardPaymentProcessor implements PaymentProcessor {
    public function processPayment() {
        // Logic for processing credit card payment
    }
}

class PayPalPaymentProcessor implements PaymentProcessor {
    public function processPayment() {
        // Logic for processing PayPal payment
    }
}

Liskov Substitution Principle (LSP)

This principle asserts that objects of a derived class should be substitutable for objects of the base class without affecting the correctness of the program.

Example: Managing geometric shapes.

abstract class Shape {
    abstract public function area();
}

class Rectangle extends Shape {
    public function area() {
        return $this->width * $this->height;
    }
}

class Square extends Shape {
    public function area() {
        return $this->side * $this->side;
    }
}

Interface Segregation Principle (ISP)

This principle advises breaking interfaces into smaller ones to avoid forcing classes to implement methods they don't need.

Example: Interfaces for updating and displaying data.

interface UpdateableFeature {
    public function updateFeature();
}

interface DisplayableFeature {
    public function displayFeature();
}

Dependency Inversion Principle (DIP)

This principle suggests using dependency injection to manage dependencies.

Example: Using dependency injection to manage dependencies.

class OrderProcessor {
    private $dbConnection;
    private $emailService;

    public function __construct(DatabaseConnection $dbConnection, EmailService $emailService) {
        $this->dbConnection = $dbConnection;
        $this->emailService = $emailService;
    }
}

Remember that applying SOLID principles in PHP should be done flexibly based on the specific purpose of your project and your understanding of SOLID and PHP.