OOP With PHP 2: Encapsulation & Access Control In PHP

Introduction

Encapsulation is one of the core principles of Object-Oriented Programming (OOP) in PHP. It ensures that an object's internal data is protected from unintended modifications and allows controlled access through defined methods. This concept is implemented using Access Modifiers such as public, private, and protected, which control how properties and methods can be accessed.

In this blog, we will cover:

• Understanding Access Modifiers in PHP

• Encapsulation: Data Hiding and Control

• Practical Examples of Encapsulation in PHP

By the end of this article, you'll understand how to use encapsulation effectively to write secure and maintainable code in PHP.

Access Modifiers in PHP

Access modifiers define the visibility of class properties and methods. PHP provides three types of access modifiers:

1. Public

• Properties and methods declared as public can be accessed from anywhere, both inside and outside the class.

Example:

class User {
    public $name; // Public property
    
    public function sayHello() {
        return "Hello, my name is " . $this->name;
    }
}

$user = new User();
$user->name = "John";
echo $user->sayHello(); // Outputs: Hello, my name is John

2. Private

• Properties and methods declared as private can only be accessed within the same class. They are not accessible from outside the class or in derived classes.

Example:

class BankAccount {
    private $balance = 1000; // Private property
    
    private function getBalance() {
        return $this->balance;
    }
    
    public function showBalance() {
        return "Your balance is: " . $this->getBalance();
    }
}

$account = new BankAccount();
echo $account->showBalance(); // Outputs: Your balance is: 1000

// The following line will cause an error
// echo $account->balance; // Fatal Error: Cannot access private property

3. Protected

• Properties and methods declared as protected can only be accessed within the same class and by subclasses (child classes). They are not accessible from outside the class.

Example:

class Animal {
    protected $species;
    
    public function setSpecies($species) {
        $this->species = $species;
    }
}

class Dog extends Animal {
    public function getSpecies() {
        return "This is a " . $this->species;
    }
}

$dog = new Dog();
$dog->setSpecies("Dog");
echo $dog->getSpecies(); // Outputs: This is a Dog

// The following line will cause an error
// echo $dog->species; // Fatal Error: Cannot access protected property

Encapsulation in PHP: Data Hiding and Control

Encapsulation allows for better data security by preventing direct modification of sensitive properties. Instead, properties are accessed and modified through getter and setter methods.

Encapsulation Example:

class Employee {
    private $salary;
    
    public function setSalary($amount) {
        if ($amount > 0) {
            $this->salary = $amount;
        } else {
            echo "Invalid salary amount!";
        }
    }
    
    public function getSalary() {
        return $this->salary;
    }
}

$emp = new Employee();
$emp->setSalary(5000);
echo "Employee salary: " . $emp->getSalary(); // Outputs: Employee salary: 5000

In the above example:

• The salary property is private, meaning it cannot be accessed directly.

• The setSalary() method ensures that only positive values can be assigned to the salary.

• The getSalary() method allows controlled access to the salary value.

Conclusion

Encapsulation is a crucial OOP concept that enhances data security and code maintainability. By using access modifiers (public, private, protected), developers can effectively control access to class properties and methods. Implementing encapsulation through getter and setter methods ensures that data remains secure and is modified only through controlled mechanisms.

By mastering encapsulation, you can write PHP applications that are more structured, secure, and scalable.

Stay tuned for more PHP OOP tutorials! 🚀