OOP Basics: Encapsulation

Encapsulation is one of the fundamental concepts of object-oriented programming (OOP). It refers to the bundling of data and methods inside a class, thereby controlling access to the data and preventing unwanted changes from the outside. Encapsulation enables better modularity and higher data security within programs.

EXAMPLE

<?php
echo " ";

class Person {
    // Properties are private and protected from access outside the class
    private $name;
    private $age;

// Constructor to initialize the object
    public function __construct($name, $age) {
        $this->name = $name;
        $this->setAge($age);
    }

// Public method to access the private property $name
    public function getName() {
        return $this->name;
    }

// Public method to set the private property $name
    public function setName($name) {
        $this->name = $name;
    }

// Public method to access the private property $age
    public function getAge() {
        return $this->age;
    }

// Public method to set the private property $age
    // This allows us to control data validity
    public function setAge($age) {
        if($age > 0) {
            $this->age = $age;
        } else {
            throw new Exception("Age must be a positive number.");
        }
    }
}

// Creating an object and accessing data via public methods
$person = new Person("John", 30);

echo "Name: " . $person->getName() . " ";
echo "Age: " . $person->getAge() . " ";

// Changing private property values via public methods
$person->setName("Mary");
$person->setAge(25);

echo "Name: " . $person->getName() . " ";
echo "Age: " . $person->getAge() . " ";
?>

RESULT

The result will be displayed here...

Keywords:

Accessibility	Description
`public`	Properties or methods marked as public are accessible both inside and outside the class.
`protected`	Properties or methods marked as protected are accessible inside the class and its subclasses, but not from the outside.
`private`	Properties or methods marked as private are accessible only within the class where they are defined.

Key Points:

Private properties are hidden from external access and can only be accessed within the class where they are defined.
Public methods provide controlled access to private properties. This allows us to validate and verify data before it is set.
Encapsulation allows for better modularity and introducing changes inside a class without affecting other parts of the program.