SOLID Principles in PHP: A Comprehensive Guide

SOLID is a set of five design principles aimed at making software more maintainable, scalable, and flexible. These principles help developers write clean, efficient, and robust code. In this blog, we will explore each principle with practical examples in PHP.

What is SOLID?

SOLID is an acronym that represents:

1. S – Single Responsibility Principle (SRP)
2. O – Open/Closed Principle (OCP)
3. L – Liskov Substitution Principle (LSP)
4. I – Interface Segregation Principle (ISP)
5. D – Dependency Inversion Principle (DIP)

Let’s dive into each principle with examples.

---

1. Single Responsibility Principle (SRP)

Definition: A class should have only one reason to change, meaning it should have only one job.

Example:

class ReportGenerator {
    public function generatePDFReport($data) {
        // Generate PDF report
    }
}

class ReportSaver {
    public function saveReportToFile($report) {
        // Save report to file
    }
}

Explanation:

• The ReportGenerator class is responsible for generating reports.
• The ReportSaver class is responsible for saving reports.
• This separation ensures that changes in report generation do not affect report saving.

---

2. Open/Closed Principle (OCP)

Definition: A class should be open for extension but closed for modification.

Example:

interface PaymentMethod {
    public function pay($amount);
}

class CreditCardPayment implements PaymentMethod {
    public function pay($amount) {
        echo "Paid $amount using Credit Card.";
    }
}

class PayPalPayment implements PaymentMethod {
    public function pay($amount) {
        echo "Paid $amount using PayPal.";
    }
}

Explanation:

• The PaymentMethod interface allows adding new payment methods without modifying existing ones.
• Adding a new payment method, such as UPIPayment, would not require changes to existing classes.

---

3. Liskov Substitution Principle (LSP)

Definition: Subtypes must be substitutable for their base types without altering the correctness of the program.

Example:

class Bird {
    public function fly() {
        return "I can fly";
    }
}

class Sparrow extends Bird {}

class Penguin extends Bird {
    public function fly() {
        throw new Exception("Penguins can't fly");
    }
}

Problem:

• The Penguin class violates LSP because it cannot substitute Bird without breaking functionality.
• A better approach is to refactor:

interface FlyingBird {
    public function fly();
}

class Sparrow implements FlyingBird {
    public function fly() {
        return "I can fly";
    }
}

class Penguin {
    public function swim() {
        return "I can swim";
    }
}

Solution:

• Now, Sparrow and Penguin have distinct behaviors without violating LSP.

---

4. Interface Segregation Principle (ISP)

Definition: A class should not be forced to implement interfaces it does not use.

Example:

interface Worker {
    public function work();
    public function eat();
}

class HumanWorker implements Worker {
    public function work() {
        return "Working...";
    }

    public function eat() {
        return "Eating...";
    }
}

class RobotWorker implements Worker {
    public function work() {
        return "Working...";
    }
    
    public function eat() {
        throw new Exception("Robots don't eat");
    }
}

Problem:

• RobotWorker is forced to implement eat(), which is irrelevant.

Solution:

interface Workable {
    public function work();
}

interface Eatable {
    public function eat();
}

class HumanWorker implements Workable, Eatable {
    public function work() {
        return "Working...";
    }

    public function eat() {
        return "Eating...";
    }
}

class RobotWorker implements Workable {
    public function work() {
        return "Working...";
    }
}

Explanation:

• Now, RobotWorker implements only the relevant Workable interface.

---

5. Dependency Inversion Principle (DIP)

Definition: High-level modules should not depend on low-level modules. Both should depend on abstractions.

Example:

class MySQLDatabase {
    public function connect() {
        return "Connected to MySQL";
    }
}

class UserRepository {
    private $database;

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

Problem:

• UserRepository is tightly coupled to MySQLDatabase.

Solution:

interface DatabaseConnection {
    public function connect();
}

class MySQLDatabase implements DatabaseConnection {
    public function connect() {
        return "Connected to MySQL";
    }
}

class PostgreSQLDatabase implements DatabaseConnection {
    public function connect() {
        return "Connected to PostgreSQL";
    }
}

class UserRepository {
    private $database;

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

Explanation:

• UserRepository depends on DatabaseConnection, not a specific implementation.
• We can now switch databases without modifying the repository.

---

Interview Questions and Answers

Q1: What are the benefits of the SOLID principles?

A: They improve code maintainability, scalability, and flexibility, making it easier to test and modify code without breaking functionality.

Q2: How does the Open/Closed Principle help in real-world projects?

A: It allows developers to add new functionality without modifying existing code, reducing the risk of introducing bugs.

Q3: Can you give an example where Liskov Substitution Principle is violated?

A: If a subclass changes the expected behavior of a parent class (e.g., a Bird class has a fly() method, but a Penguin subclass throws an error in fly()), LSP is violated.

Q4: What is the main difference between DIP and ISP?

A: DIP focuses on reducing dependencies between high-level and low-level modules, while ISP ensures that classes implement only the necessary interfaces.

---

Conclusion

Applying SOLID principles in PHP leads to better software design and architecture. To explore more, check out my GitHub repository: GitHub – PHP SOLID Principles

Follow infoblend.in for more Information in future