Loading...

Lesson 3

Applying the Law of Demeter in PHP Code

Introduction

Welcome to the third lesson of the "Applying Clean Code Principles" course. In our journey so far, we've discussed the importance of the DRY (Don't Repeat Yourself) principle for eliminating redundancy in code. We followed that with the KISS (Keep It Simple, Stupid) principle, which highlights the value of simplicity in software development. Today, our focus is on the Law of Demeter — a key guideline in structured programming. By limiting the knowledge that an object has about other objects, this lesson will guide you in crafting more maintainable and modular code.

Understanding the Law of Demeter

The Law of Demeter suggests that an object should only communicate with its immediate collaborators, avoiding the entire system. By reducing dependency between parts, you'll find your code easier to maintain and scale. In simple terms, a method X of the class C should only call the methods of:

Class C itself
An object created by X
An object passed as an argument to X
An object held in an instance variable of C
A static field

With these principles, you control how parts of your application interact, leading to a more organized structure. Let's explore how this works with examples. 🚀

First Rule Example

For the first point, a method should only access its own class's methods:

php
1class Car {
2    public function start(): void {
3        $this->checkFuel();
4        $this->ignite();
5    }
6    
7    private function checkFuel(): void {
8        echo "Checking fuel level...\n";
9    }
10    
11    private function ignite(): void {
12        echo "Igniting the engine...\n";
13    }
14}

In this example, the start method interacts solely with methods within the Car class itself. This shows how you maintain clear boundaries adhering to the Law of Demeter.

Second Rule Example

Next, a method can interact with the objects it creates:

php
1class Library {
2    public function borrowBook(string $title): Book {
3        $book = new Book($title);
4        $book->issue();
5        return $book;
6    }
7}
8
9class Book {
10    private string $title;
11    
12    public function __construct($title) {
13        $this->title = $title;
14    }
15    
16    public function issue(): void {
17        echo "Book issued: ".$this->title."\n";
18    }
19}

Here, the Library class creates a Book and calls the issue method on it. This usage pattern complies with the Law of Demeter, where Library interacts with the newly-created Book. 📚

Third Rule Example

Continuing, let's look at interacting with objects passed as arguments:

php
1class Printer {
2    public function print(Document $document): void {
3        $document->sendToPrinter();
4    }
5}
6
7class Document {
8    public function sendToPrinter(): void {
9        echo "Document is being printed...\n";
10    }
11}

The Printer class method print communicates with the Document object passed as an argument, aligning with the Law of Demeter by limiting communication to direct method parameters. 🖨️

Fourth Rule Example

Objects held in instance variables of a class can also be accessed:

php
1class House {
2    private Door $door;
3    
4    public function __construct() {
5        $this->door = new Door();
6    }
7    
8    public function lockHouse(): void {
9        $this->door->close();
10    }
11}
12
13class Door {
14    public function close(): void {
15        echo "Door is closed.\n";
16    }
17}

In this example, the House class interacts with its door through the lockHouse method, showcasing compliance by interacting with an object it holds in an instance variable. 🏠

Fifth Rule Example

Finally, let's see a method interacting with static fields. While static fields are convenient, they should generally be used cautiously since they can lead to shared state issues in larger applications:

php
1class TemperatureConverter {
2    private const CONVERSION_FACTOR = 9.0 / 5.0;
3    
4    public function celsiusToFahrenheit(float $celsius): string {
5        return (int)(($celsius * self::CONVERSION_FACTOR) + 32);
6    }
7}

Here, CONVERSION_FACTOR is defined as a const to indicate that it's a constant, and to ensure correct calculations, the division is a float. Accessing static fields like this is compliant with the Law of Demeter. 🌡️

Violation Example

Here's an example that violates the Law of Demeter:

php
1class Person {
2    private string $address;
3    
4    public function __construct($address) {
5        $this->address = $address;
6    }
7
8    public function getAddressDetails(): string {
9        return "Address: " . $this->address->getFirstName() . " " . $this->address->getLastName() .
10               ", " . $this->address->getStreet() . 
11               ", " . $this->address->getCity() . 
12               ", " . $this->address->getCountry() . 
13               ", ZipCode: " . $this->address->getZipCode();
14    }
15}
16
17class Address {
18    private string $firstName;
19    private string $lastName;
20    private string $street;
21    private string $city;
22    private string $country;
23    private string $zipCode;
24    
25    public function __construct(string $firstName, string $lastName, string $street, string $city, string $country, string $zipCode) {
26        $this->firstName = $firstName;
27        $this->lastName = $lastName;
28        $this->street = $street;
29        $this->city = $city;
30        $this->country = $country;
31        $this->zipCode = $zipCode;
32    }
33
34    public function getFirstName(): string {
35        return $this->firstName;
36    }
37    
38    public function getLastName(): string {
39        return $this->lastName;
40    }
41    
42    public function getStreet(): string {
43        return $this->street;
44    }
45    
46    public function getCity(): string {
47        return $this->city;
48    }
49    
50    public function getCountry(): string {
51        return $this->country;
52    }
53    
54    public function getZipCode(): string {
55        return $this->zipCode;
56    }
57}

In this case, Person is directly accessing multiple fields through Address, leading to tight coupling. Person relies on the internal structure of Address, which might result in fragile code.

Refactored Example

Let's refactor the previous code to adhere to the Law of Demeter:

php
1class Person {
2    private string $address;
3    
4    public function __construct(string $address) {
5        $this->address = $address;
6    }
7
8    public function getAddressDetails(): string {
9        return $this->address->getAddressLine();
10    }
11}
12
13class Address {
14    private string $firstName;
15    private string $lastName;
16    private string $street;
17    private string $city;
18    private string $country;
19    private string $zipCode;
20    
21    public function __construct(string $firstName, string $lastName, string $street, string $city, string $country, string $zipCode) {
22        $this->firstName = $firstName;
23        $this->lastName = $lastName;
24        $this->street = $street;
25        $this->city = $city;
26        $this->country = $country;
27        $this->zipCode = $zipCode;
28    }
29    
30    public function getAddressLine(): string {
31        return $this->firstName . " " . $this->lastName .
32               ", " . $this->street .
33               ", " . $this->city . 
34               ", " . $this->country .
35               ", ZipCode: " . $this->zipCode;
36    }
37}

By encapsulating all the address details within the getAddressLine method in the Address class, the dependency is minimized, and Person no longer accesses Address's internals directly.

Summary and Next Steps

The Law of Demeter plays a vital role in writing clean, modular code by ensuring objects only interact with their closest dependencies. By understanding and implementing these guidelines, you enhance the modularity and maintainability of your code. As you move on to the practice exercises, challenge yourself to apply these principles and evaluate your code's interactions. Keep these lessons in mind as essential steps toward mastering clean code! 🌟

Enjoy this lesson? Now it's time to practice with Cosmo!

Practice is how you turn knowledge into actual skills.