Introduction to SOLID Principles

The SOLID principles are a set of design guidelines that help developers create software that is easy to maintain, extend, and understand. These principles are particularly important in PHP development, where applications often grow in complexity over time. By adhering to SOLID, you can ensure your codebase remains clean and manageable.

Single Responsibility Principle (SRP)

The Single Responsibility Principle states that a class should have only one reason to change, meaning it should have only one job or responsibility. This principle helps in reducing the complexity of the code and makes it easier to test and maintain.

class User {
    public function __construct(private string $name, private string $email) {}

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

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

class UserPrinter {
    public function print(User $user): void {
        echo $user->getName() . ' - ' . $user->getEmail();
    }
}

In this example, the User class is responsible only for managing user data, while the UserPrinter class handles the printing logic. This separation adheres to SRP.

Open/Closed Principle (OCP)

The Open/Closed Principle suggests that software entities should be open for extension but closed for modification. This means you should be able to add new functionality without changing existing code.

interface Shape {
    public function area(): float;
}

class Rectangle implements Shape {
    public function __construct(private float $width, private float $height) {}

    public function area(): float {
        return $this->width * $this->height;
    }
}

class Circle implements Shape {
    public function __construct(private float $radius) {}

    public function area(): float {
        return pi() * pow($this->radius, 2);
    }
}

Here, the Shape interface allows for the addition of new shapes without modifying the existing code, adhering to OCP.

Liskov Substitution Principle (LSP)

The Liskov Substitution Principle states that objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program. This ensures that a subclass can stand in for its superclass without causing errors.

class Bird {
    public function fly(): void {
        echo 'Flying';
    }
}

class Sparrow extends Bird {
    public function fly(): void {
        echo 'Sparrow flying';
    }
}

class Ostrich extends Bird {
    public function fly(): void {
        throw new Exception('Cannot fly');
    }
}

In this example, the Ostrich class violates LSP because it cannot fly, unlike its superclass Bird. To adhere to LSP, we should reconsider the inheritance hierarchy.

Interface Segregation Principle (ISP)

The Interface Segregation Principle advocates for creating small, specific interfaces rather than large, general-purpose ones. This ensures that implementing classes only need to be concerned with the methods that are relevant to them.

interface Printer {
    public function print(): void;
}

interface Scanner {
    public function scan(): void;
}

class AllInOnePrinter implements Printer, Scanner {
    public function print(): void {
        echo 'Printing';
    }

    public function scan(): void {
        echo 'Scanning';
    }
}

class SimplePrinter implements Printer {
    public function print(): void {
        echo 'Printing';
    }
}

Here, the Printer and Scanner interfaces are segregated, allowing classes to implement only the methods they need.

Dependency Inversion Principle (DIP)

The Dependency Inversion Principle states that high-level modules should not depend on low-level modules. Both should depend on abstractions. This principle promotes the use of interfaces or abstract classes to decouple the system’s components.

interface Database {
    public function save($data): void;
}

class MySQLDatabase implements Database {
    public function save($data): void {
        echo 'Saving data to MySQL database';
    }
}

class UserService {
    public function __construct(private Database $database) {}

    public function createUser($userData): void {
        $this->database->save($userData);
    }
}

In this example, the UserService depends on the Database interface, not on a specific database implementation, adhering to DIP.

Conclusion

By mastering the SOLID principles, PHP developers can create code that is not only robust and scalable but also easy to maintain and extend. These principles provide a solid foundation for building high-quality software that stands the test of time.