PHP Access Modifiers: How Public, Private & Protected Work

PHP supports OOP with access modifiers to prevent unintended changes and improve security. In this article, we will cover the following topics:

• What is the definition of access modifiers, and why are they important?
• Access modifier types and use them in the inheritance and encapsulation examples.
• The difference between their three types.

Let’s start with what access modifiers are.

Understand What Access Modifiers Are in PHP

The PHP Access modifiers control how properties and methods are accessed within a class. They define whether code outside the class can use them directly.

They are important for object-oriented programming (OOP). Here’s why they matter:

• Encapsulation – They protect internal class data from unintended modification by restricting direct access.
• Data security – Private and protected modifiers prevent unauthorized changes. They reduce the risk of bugs.
• Code maintainability – They help manage dependencies and make code easier to update and refactor with limited access.
• Inheritance control – They define how subclasses interact with parent class properties and methods, and ensure proper structure.

Let’s move on to the following section to understand the types of access modifiers in-depth.

Types of Access Modifiers in PHP

Access modifiers in PHP define the visibility of class properties and methods. There are three types:

• Public modifier.
• Private modifier.
• Protected modifier.

Let’s take each one in detail with an example.

Public Modifier

The public access modifier allows class properties and methods to be accessed from anywhere:

• Inside the class.
• In subclasses
• Outside the class.

This means there are no restrictions on visibility.

Here is an example:

class Individual {
   // Public property
    public $name = "FlatCoding"; 

    public function greet() {
        return " Hello, " . $this->name;
    }
}

$individual = new Individual();
echo $individual->name;
echo $individual->greet();

Here is the output:

FlatCoding Hello, FlatCoding

So, when to use a public modifier?

• When a property or method needs to be accessed freely across the application.
• For utility methods that don’t modify sensitive data.
• With designed APIs or libraries where external access is required.

Private Modifier

The private access modifier limits access to properties and methods.It makes them only accessible within the same class.

The other classes and included subclasses cannot access private members, even if they extend the class.

This makes sure that internal details are kept hidden from outside interaction and promotes better encapsulation.

Here is an example:

class Viewer {
    // Private property
    private $password = "secret"; 

    private function encryptPassword() {
        return md5($this->password);
    }

    public function showPassword() {
        // Access private method within the same class
        return $this->encryptPassword(); 
    }
}

$viewer = new Viewer();

Here, if you use the property $viewer->password; or the method $viewer->encryptPassword(); it will show you an error such as:

echo $viewer->password;
echo $viewer->encryptPassword();

Here is the output:

Error: Cannot access private property
Error: Cannot access private method

Hence, you need to use a public function inside the same class to access the private method or property like the below:

echo $viewer->showPassword();

Output:

5ebe2294ecd0e0f08eab7690d2a6ee69

You use this when:

• You want to hide implementation details and prevent external code from modifying the internal state.
• For sensitive data like passwords, internal calculations, or any logic that shouldn’t be altered from the outside.
• When you need to protect certain functionality, you need to make sure it’s only manipulated by the class itself.

Protected Modifier

The protected access modifier allows properties and methods to be accessed within the same class and by subclasses, but not from outside the class.

This creates a balance between public and private access. It works well when you want child classes to use specific data or methods, but still keep them hidden from external use.

Here is an example:

class Guest {
    // Protected property
    protected $username = "guest123"; 
    protected function getUsername() {
        return $this->username;
    }
}

class Admin extends Guest {
    public function displayUsername() {
        // Access protected method in subclass
        return $this->getUsername(); 
    }
}

$guest = new Admin();

If you try to access the $guest->username; it will cause an error for example:

echo $guest->username;  

Here is the output:

Error: Cannot access protected property

It works when you use the subclass. The subclass can access the data or methods, but they remain hidden from outside use. Here is an example:

// The subclass
echo $guest->displayUsername(); 

Here is the output:

guest123

So, you use a protected modifier in the following cases:

• When you want to allow access to a class’s properties or methods within the class and its subclasses, but prevent external code from accessing them.
• For functionality that’s shared or extended by child classes but shouldn’t be accessed directly by other parts of the program.
• When creating base classes that provide common functionality to derived classes, but need to hide details from the outside world.

Let’s move on to the following section to understand the difference between access modifier types.

Difference Between Public, Private, and Protected

Each modifier provides a different level of access. Here are the key differences:

Wrapping Up

Access modifiers help you to control how properties and methods are accessed. They help you in:

• Maintain security.
• Improve code organization.
• It ensures better encapsulation.

Here are the types of access modifiers:

• Public – Allows access from anywhere. Use it when properties or methods need to be freely accessible.
• Private – Restricts access to within the class. Best for sensitive data and internal logic.
• Protected – Allows access within the class and subclasses but prevents external use. Useful for inheritance.

FAQ’s