PHP Access Modifiers

This tutorial helps you learn how to use PHP access modifiers. So, let us start.

What are PHP Access Modifiers?

You can use access modifiers for setting the access rights for class methods and variables. Access modifiers are PHP keywords. Some of these access modifiers can even be assigned to the class to make it behave in a special way.

Given below are the PHP keywords which you can use as access modifiers with their meaning:

• public: When class members are defined as public, then you can access them from anywhere, even from outside of the class scope.
• private: If class members are defined as private, you can acess them only from within the class itself.
• protected: It is similar to private, but there is an exception; you can still access the class members defined as protected from its subclass 
• abstract: You can use this keyword only for PHP classes and their member functions.
• final: If the class methods have been defined as final, then you cannot change or override them by any subclass.

When to use Which Access Modifier

All the available access modifiers cannot be used with class, its variables, and methods. In the following table, it has been specified which access modifier is applied to what:

public Access Modifier

If any access modifiers have not been specified, they will treat all classes and members as public by default.

As mentioned in the table given above, you cannot use public, private, or protected access modifiers with class. Let's see what happens if you do,

<?php
    public class LovePHP {
        ...
    }
?>

Output:

Parse error: syntax error, unexpected 'public' (T_PUBLIC) in ...

You will get the above error.

However, you should specify an access modifier for class methods and variables, although they are treated as public by default.

A PHP class example:

<?php
    class LovePHP {
        // to store name of person
        var $url = "developerstutorial.com";
        
        // simple class method
        function desc() {
            echo "developerstutorial helps you learn PHP.";
        }
    }
?>

The keyword var has been used before the class variable in the code above. If var is not used, then we will get a parse error.

However, rather than using var, access modifier keywords can also be used before the class variable declaration, for example:

<?php
    class LovePHP {
        // to store name of person
        public $url = "developerstutorial.com";
        
        // simple class method
        function desc() {
            echo "developerstutorial helps you learn PHP.";
        }
    }
?>

A PHP class should be created like this; specifying the access modifiers with class variables and methods is a good programming practice.

private Access Modifier

The private access modifier can be utilized for class variables and methods but not for the PHP class. Therefore, when you have declared a class member - a variable or a function- as private, you cannot access it directly using the class object. For example:

<?php
    class Person {
        // first name of person
        private $fname;
        // last name of person
        private $lname;
        
        // public function to set value for fname
        public function setFName($fname) {
            $this->fname = $fname;
        }
        
        // public function to set value for lname
        public function setLName($lname) {
            $this->lname = $lname;
        }
        
        // public function to 
        public function showName() {
            echo "My name is: " . $this->fname . " " . $this->lname;
        }
    }
    
    // creating class object
    $john = new Person();
    
    // trying to access private class variables
    $john->fname = "John";  // invalid
    $john->lname = "Wick";  // invalid
    
    // calling the public function to set fname and lname
    $john->setFName("John");
    $john->setLName("Wick");

?>

In the above-mentioned code, $fname and $lname are private class variables; therefore, these cannot be directly accessed by using the class object. So, when you will try to execute the following line of code:

<?php
    $john->setFName("John");
?>

You will get a fatal PHP error:

Output:

Fatal error:  Cannot access private property Person::$fname in ...

But the private variables of a class can be easily accessed by defining public functions in the class. Separate functions can also be created to set the value to private variables and get their values. These functions are called Getters and Setters.

<?php
    class Person {
        // first name of person
        private $name;
        
        // public function to set value for name (setter method)
        public function setName($name) {
            $this->name = $name;
        }
        
        // public function to get value of name (getter method)
        public function getName() {
            return $this->name;
        }
    }
    
    // creating class object
    $john = new Person();
    
    // calling the public function to set fname
    $john->setName("John Wick");
    
    // getting the value of the name variable
    echo "My name is " . $john->getName();

?>

Output:

My name is John Wick

protected Access Modifier

The protected access modifier also restricts the access of class variables and methods outside the class. However, you can access the protected class variables and functions inside the class as well as inside the subclass (a subclass that inherits the class).

Let us learn how to create a subclass and the concept of Inheritance in the upcoming tutorials.

Let's take a quick and simple example:

<?php
    class Human {
        // protected variable
        protected $genders = array("Male", "Female", "Other");
        
        // protected function for humans features
        protected function getFeatures($gender) {
            if($gender == "Male") {
                echo "Men will be Men";
            }
            else if($gender == "Female") {
                echo "Women's mind is a maze.";
            }
            else if($gender == "Other") {
                echo "All are born equal.";
            }
        }
        
    }
    
    // subclass of the above class
    class Male extends Human {
        protected $gender = "Male";
        
        // public function to print Male features
        public function getMaleFeatures() {
            // calling the protected getFeatures() method of class Human
            $this->getFeatures($this->gender);
        }
    }
    
    // object of Human class
    $human = new Human();
    // object of Male class
    $male = new Male();
    
    /*  
        accessing protected variables and methods
    */
    echo $human->genders;   // INVALID
    $human->getFeatures("Male");    // INVALID
    echo $male->gender;     // INVALID
    
    /*
        but we can call getMaleFeatures method,
        in which we are calling a protected method 
        of Human class
    */
    $male->getMaleFeatures();

?>

In the program mentioned above, two classes have been defined, Human and Male. The Male class is a subclass of the class Human.

All class variables and methods are protected in the human class; hence they cannot be accessed from outside the class, but these variables and methods can be accessed from inside the subclass of the class Human.

abstract Access Modifier

You can use the abstract access modifier with the PHP class and its functions. However, abstract access modifiers cannot be used for class variables.

In case a class has even a single abstract method, then you must define the class as abstract.

Also, instantiating the abstract class is not allowed by PHP, i.e., the object of an abstract class cannot be created, although these classes can be inherited.

The access modifier has been discussed in detail in the Abstract class and Interfaces tutorial.

final Access Modifier

When a class is declared as final by using a final access modifier, that class cannot be inherited.

Likewise, when a class function is defined as final, PHP will restrict the subclasses of that class from overriding that function that has been declared as final.

We will explain this with examples in the Inheritance tutorial.