Categories

Mastering Encapsulation in PHP: Getters, Setters, and Access Modifiers Demystified (With Code Examples)

Donate with

82uymVXLkvVbB4c4JpTd1tYm1yj1cKPKR2wqmw3XF8YXKTmY7JrTriP4pVwp2EJYBnCFdXhLq4zfFA6ic7VAWCFX5wfQbCC

Copy Monero Donation Address

Donate with

Donate BAT now

Verified BAT publisher

TL;DR – Quick Summary

• Encapsulation is a core concept of object-oriented programming (OOP) in PHP that helps restrict direct access to object data.
• PHP uses access modifiers like public, private, and protected to define the visibility of class properties and methods.
• Getters and Setters allow controlled access to private data, adding security and flexibility.
• This post covers practical examples to help you apply encapsulation effectively in your PHP applications.

What is Encapsulation in PHP?

Encapsulation is a principle in object-oriented programming (OOP) that bundles data and the methods that operate on that data within one unit: the class. It’s about controlling how the internal data of a class can be accessed or modified, and it’s achieved using access modifiers and getter/setter methods.

Why Encapsulation Matters

• Improves data security by hiding internal state.
• Allows validation logic before setting values.
• Makes code easier to maintain and extend.

Understanding Access Modifiers in PHP

Access modifiers in PHP determine how accessible a class property or method is from outside the class:

• public – Accessible from anywhere.
• private – Accessible only within the class itself.
• protected – Accessible within the class and its child classes.

Example: Access Modifiers in Action

class Car {
    public $brand = "Toyota";
    private $engineNumber = "ENG123456";
    protected $mileage = 50000;

    public function getEngineNumber() {
        return $this->engineNumber;
    }
}

$myCar = new Car();
echo $myCar->brand;            // Works: public
echo $myCar->getEngineNumber(); // Works: public method accessing private
echo $myCar->engineNumber;     // Error: Cannot access private property

Output:

Toyota
ENG123456
Fatal error: Uncaught Error: Cannot access private property Car::$engineNumber

What are Getters and Setters?

Getters and Setters are methods that provide indirect access to an object’s properties. They allow you to add validation, formatting, or even logging before accessing or changing data.

Simple Getter and Setter Example

class User {
    private $email;

    public function setEmail($email) {
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            throw new Exception("Invalid email address.");
        }
        $this->email = $email;
    }

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

$user = new User();
$user->setEmail("john@example.com");
echo $user->getEmail();

Output:

john@example.com

Encapsulation in Real-World PHP Projects

Encapsulation is often used in large-scale PHP applications like Laravel, Symfony, or WordPress plugin development. Here’s how encapsulation supports scalable architecture:

• Form input validation in models using setters.
• Preventing unauthorized changes to critical data like user roles.
• API response formatting using getters.

Example: Bank Account Class

class BankAccount {
    private $balance = 0;

    public function deposit($amount) {
        if ($amount <= 0) {
            throw new Exception("Amount must be greater than zero.");
        }
        $this->balance += $amount;
    }

    public function withdraw($amount) {
        if ($amount > $this->balance) {
            throw new Exception("Insufficient funds.");
        }
        $this->balance -= $amount;
    }

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

$account = new BankAccount();
$account->deposit(500);
$account->withdraw(200);
echo "Current balance: $" . $account->getBalance();

Output:

Current balance: $300

Best Practices for Encapsulation in PHP

• Always declare class properties as private or protected.
• Use getters and setters for access control.
• Validate and sanitize data within setters.
• Use PHP 7.4+ typed properties and PHP 8+ constructor property promotion to make code cleaner.

Encapsulation with Constructor Property Promotion (PHP 8+)

class Product {
    public function __construct(
        private string $name,
        private float $price
    ) {}

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

    public function getPrice(): float {
        return $this->price;
    }
}

$product = new Product("Keyboard", 99.99);
echo $product->getName();
echo $product->getPrice();

Output:

Keyboard
99.99

Conclusion

Encapsulation in PHP is more than just a best practice — it’s a foundation for writing secure, maintainable, and scalable code. By combining access modifiers with well-designed getter and setter methods, you take full control of how data flows through your application. Whether you're working on enterprise software or a personal side project, mastering encapsulation will elevate your PHP development skills.