Understanding Access Modifiers

1. The Principle of Encapsulation

Encapsulation means bundling the data (properties) and the methods that operate on that data within a single unit (the class), and controlling access to it. Think of it like a car's dashboard. You, the driver, have a public interface: a steering wheel, pedals, and a speedometer. You don't need to—and shouldn't—directly manipulate the engine's fuel injectors or the transmission's gears. Those are private, internal details.

In PHP, we achieve this control with three keywords: public, private, and protected.

Let's get a formal definition for each.

Now, let's see these concepts introduced in a video format.

2. The Three Visibility Modifiers in Action

Let's break down each modifier with code examples to see how they behave.

public: Accessible from Anywhere

As the name suggests, a public property or method can be accessed from anywhere:

• From outside the class instance (e.g., _index.php_).
• From inside the class itself.
• From a class that inherits from this one.

If you don't specify any visibility, PHP defaults to public.

class User
{
    public $username; // Public property

    public function getUsername() // Public method
    {
        return $this->username;
    }
}

$user = new User();
$user->username = 'Alice';      // OK: Accessing public property from outside
echo $user->getUsername(); // OK: Calling public method from outside

private: Accessible Only Within the Class

A private member can only be accessed from within the class that defined it. This is the highest level of protection. Neither code outside the class nor any child classes can access it directly.

This is perfect for sensitive data like passwords or for internal "helper" methods that shouldn't be called from anywhere else.

Let's see what happens when we try to break this rule.

So how do we work with private data? We create controlled, public "entry points," often called getters and setters.

protected: Accessible Within the Class and Its Children

The protected modifier is the middle ground. A protected member can be accessed from within the class itself, just like private. However, it can also be accessed by any class that inherits from it (a "child" or "subclass"). It still cannot be accessed from outside the object instance.

We will cover inheritance in detail in a future module, but for now, just understand that protected is for sharing implementation details with trusted child classes.

The official PHP manual provides code examples that demonstrate all three access levels for both properties and methods. It's an excellent reference to solidify your understanding.

3. Best Practices: How to Choose?

Now that you know the rules, how do you decide which modifier to use? Here's a simple, professional rule of thumb:

Start by making everything private. Only make something protected or public if you have a clear and specific reason to do so.

This "default to private" approach maximizes encapsulation and security. You can always make something less restrictive later, but making it more restrictive can break other parts of your application that depend on it.

Let's watch a practical application of these principles in a class designed to handle database connections—a perfect real-world scenario related to your goal of building secure web applications.

To wrap up the theory, let's review a list of best practices and common mistakes.

Conclusion

Excellent work! You now have a solid grasp of one of the most important principles in Object-Oriented Programming. By correctly applying visibility modifiers, you can create code that is more secure, easier to debug, and much simpler to maintain and extend in the long run.

Key Takeaways:

• Encapsulation is the practice of bundling data and methods together and controlling access to them.
• public members are accessible from anywhere. This is your class's external "interface".
• private members are only accessible from within the class that defines them. Use this for sensitive data and internal helper functions.
• protected members are accessible within the defining class and any child classes that inherit from it.
• Best Practice: Default to private and only increase visibility (protected or public) when necessary.

Preview of the Next Lesson:
Throughout today's examples, you've seen the $this keyword used repeatedly (e.g., $this->username). This special variable is how an object refers to itself from within its own methods. In our next lesson, we will focus entirely on using the $this keyword to understand precisely how an object manipulates its own properties and calls its own methods, regardless of their visibility.