objects.md

⬆️ Go to main menu ⬅️ Previous (Functions) ➡️ Next (Classes)

Objects and Data Structures

Use object encapsulation

In PHP you can set public, protected and private keywords for methods. Using it, you can control properties modification on an object.

• When you want to do more beyond getting an object property, you don't have to look up and change every accessor in your codebase.
• Makes adding validation simple when doing a set.
• Encapsulates the internal representation.
• Easy to add logging and error handling when getting and setting.
• Inheriting this class, you can override default functionality.
• You can lazy load your object's properties, let's say getting it from a server.

Additionally, this is part of Open/Closed principle.

Bad:

class BankAccount
{
    public $balance = 1000;
}

$bankAccount = new BankAccount();

// Buy shoes...
$bankAccount->balance -= 100;

Good:

class BankAccount
{
    private $balance;

    public function __construct(int $balance = 1000)
    {
      $this->balance = $balance;
    }

    public function withdraw(int $amount): void
    {
        if ($amount > $this->balance) {
            throw new \Exception('Amount greater than available balance.');
        }

        $this->balance -= $amount;
    }

    public function deposit(int $amount): void
    {
        $this->balance += $amount;
    }

    public function getBalance(): int
    {
        return $this->balance;
    }
}

$bankAccount = new BankAccount();

// Buy shoes...
$bankAccount->withdraw($shoesPrice);

// Get balance
$balance = $bankAccount->getBalance();

⬆ back to top

Make objects have private/protected members

• public methods and properties are most dangerous for changes, because some outside code may easily rely on them, and you can't control what code relies on them. Modifications in class are dangerous for all users of class.
• protected modifier are as dangerous as public, because they are available in scope of any child class. This effectively means that difference between public and protected is only in access mechanism, but encapsulation guarantee remains the same. Modifications in class are dangerous for all descendant classes.
• private modifier guarantees that code is dangerous to modify only in boundaries of single class (you are safe for modifications, and you won't have Jenga effect).

Therefore, use private by default and public/protected when you need to provide access for external classes.

For more information you can read the blog post on this topic written by Fabien Potencier.

Bad:

class Employee
{
    public $name;

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

$employee = new Employee('John Doe');
// Employee name: John Doe
echo 'Employee name: ' . $employee->name;

Good:

class Employee
{
    private $name;

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

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

$employee = new Employee('John Doe');
// Employee name: John Doe
echo 'Employee name: ' . $employee->getName();

⬆ back to top