Encapsulation and Access Modifiers

Welcome to the lesson on encapsulation! In this lesson, you’ll learn how encapsulation helps protect the data inside classes and how access modifiers control the visibility of class properties and methods. Let’s dive in!

What Is Encapsulation?

Encapsulation is the practice of bundling data (properties) and methods that operate on that data within a class and restricting direct access to them from outside the class.

Key Features of Encapsulation:

• Protects the internal state of an object.
• Provides controlled access to class properties using methods.
• Helps maintain data integrity.

Tip: Encapsulation is a fundamental concept for building secure and modular applications.

Access Modifiers in PHP

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

• public: Accessible from anywhere.
• protected: Accessible only within the class and its subclasses.
• private: Accessible only within the class itself.

Key Point: Use access modifiers to control how properties and methods are accessed and modified.

Using public Properties

Properties declared as public can be accessed and modified from anywhere. Example:

Tip: Use public for properties and methods meant to be openly accessed.

<?php
  class Car {
    public $make;
    public $model;

    public function drive() {
      echo "The car is driving.";
    }
  }

  $car = new Car();
  $car->make = "Toyota";
  $car->model = "Corolla";

  echo "Make: " . $car->make . ", Model: " . $car->model;
  $car->drive();
?>

Using private Properties

Properties declared as private can only be accessed within the class. Example:

Key Point: Use private for properties that need to be protected from external modification.

<?php
  class BankAccount {
    private $balance;

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

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

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

  $account = new BankAccount(100);
  $account->deposit(50);
  echo "Balance: " . $account->getBalance(); // Outputs: Balance: 150
?>

Using protected Properties

Properties declared as protected are accessible within the class and its child classes. Example:

Key Point: Use protected to allow child classes to access parent properties and methods.

<?php
  class Vehicle {
    protected $fuel;

    public function setFuel($fuel) {
      $this->fuel = $fuel;
    }
  }

  class Car extends Vehicle {
    public function getFuel() {
      return $this->fuel;
    }
  }

  $car = new Car();
  $car->setFuel("Gasoline");
  echo "Fuel: " . $car->getFuel(); // Outputs: Fuel: Gasoline
?>

Getters and Setters

Encapsulation often involves using getter and setter methods to provide controlled access to private properties. Example:

Tip: Use setters to validate data before modifying properties.

<?php
  class User {
    private $password;

    public function setPassword($password) {
      $this->password = $password;
    }

    public function getPassword() {
      return $this->password;
    }
  }

  $user = new User();
  $user->setPassword("my_secure_password");
  echo "Password: " . $user->getPassword();
?>

Benefits of Encapsulation

Encapsulation provides the following advantages:

• Protects the internal state of an object.
• Improves code maintainability by centralizing control over properties.
• Prevents accidental modification of data.
• Enhances security by restricting direct access to sensitive data.

Key Point: Encapsulation is a fundamental principle of secure and modular OOP.

Great Job!

Congratulations! You’ve learned about encapsulation and how access modifiers control the visibility of class properties and methods. In the next lesson, we’ll explore polymorphism and how it allows flexibility in object behavior. Let’s keep coding!