Public members can be accessed within, outside and in subclasses; 2. The protected members are only accessed within and in subclasses, and cannot be accessed from outside; 3. The private members are only accessed within the class that defines them, and are not accessible from the subclass and outside; correct use of these three access modifiers can effectively implement encapsulation, improving the security, maintainability and reusability of the code.

When working with object-oriented programming (OOP) in PHP, understanding the difference between scope and visibility is essential for writing clean, secure, and maintainable code. While these terms are sometimes used interchangeably, they refer to slightly different concepts:

• Scope refers to where a variable or method can be accessed (eg, inside a class, outside, in child classes).
• Visibility (also called access control ) refers to how accessible a property or method is — controlled by keywords like public , protected , and private .

Let's break down how public , protected , and private work in PHP and how they affect both scope and visibility.

What Are Visibility Modifiers?

PHP provides three visibility keywords to control access to class members (properties and methods):

These modifiers define who can access a property or method — that's the core of visibility.

public : No Restrictions

A public member can be accessed from anywhere — inside the class, outside the class via an object, and in any child class.

 class User {
    public $name = "John";

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

$user = new User();
echo $user->name; // Works: John
echo $user->getName(); // Works: John

? Use public when you want a property or method to be freely accessible.

?? Overusing public can lead to poor encapsulation. It's generally better to make properties private and expose them via public getter/setter methods if needed.

protected : Internal Inherited Access

protected members can be accessed:

• Inside the class that defines them
• Inside any child class (via inheritance)
• But not from outside the object

 class User {
    protected $name = "John";

    protected function getName() {
        return $this->name;
    }
}

class Admin extends User {
    public function display() {
        return $this->getName(); // OK: inherited access
    }
}

$admin = new Admin();
echo $admin->display(); // Works: John

$user = new User();
echo $user->name; // Fatal error: Cannot access protected property

? Use protected when you want to allow subclasses to use or override behavior but hide it from external code.

This is common with methods means to be extended or helper functions used across a class hierarchy.

private : Class-Only Access

private members are only accessible within the class where they are defined. Even child classes cannot access them.

 class User {
    private $password = "secret123";

    private function hashPassword($pass) {
        return md5($pass);
    }

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

class Admin extends User {
    public function showPassword() {
        // echo $this->password; // Fatal error: Cannot access private property
    }
}

? Use private to fully encapsulate internal logic or sensitive data. This prevents accidental or intentional misuse from subclasses or external code.

? Think of private as "internal use only" — ideal for helper methods, configuration, or data that shouldn't leak.

Key Differences Summary

Note: There's no friend concept in PHP (like in C ), so no way to grant special access to other classes.

Best Practices

• Make properties private by default — expose them via public getters/setters if needed.
• Use protected for methods intended to be reused or overridden in child classes.
• Avoid public properties — they break encapsulation and make your class harder to maintain.
• Use visibility to enforce encapsulation , one of the core OOP principles.

For example:

 class User {
    private $email;

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

    public function setEmail($email) {
        if (filter_var($email, FILTER_VALIDATE_EMAIL)) {
            $this->email = $email;
        } else {
            throw new InvalidArgumentException("Invalid email");
        }
    }
}

Here, we control how the email is set — something impossible with a public property.

Understanding public , protected , and private isn't just about syntax — it's about designing robust, reusable, and secure classes . Choosing the right visibility helps you define clear boundaries and protect your object's internal state.

Basically:

• public = anyone can use it
• protected = only us and our kids
• private = strictly internal

Get this right, and your OOP will be much stronger.

The above is the detailed content of Scope vs. Visibility: Understanding `public`, `protected`, and `private` in PHP OOP. For more information, please follow other related articles on the PHP Chinese website!