Introduction to PHP Object-Oriented Programming: How to Use Access Modifiers to Protect Object Properties and Methods

Getting started with object-oriented programming in PHP: How to use access modifiers to protect the properties and methods of objects

In PHP, object-oriented programming (Object-oriented Programming, referred to as OOP) is a very common and powerful Programmatically. In this way, we can abstract entities into objects and define their properties and methods to describe their behavior. However, sometimes we need to restrict access to an object to protect its internal state and some key methods. For this purpose, PHP provides access modifiers to help us achieve this purpose.

There are three commonly used access modifiers in PHP: public, private and protected. Different access modifiers define the visibility and accessibility of an object's properties and methods to the outside world. Below we will introduce the use of these three access modifiers in detail.

1. Public access modifier

The public access modifier is the most common modifier, which indicates that the properties and methods of the object can be accessed from anywhere and transfer. When we do not define any access modifier, the default is the public access modifier.

Generally, we define the properties of a class as private or protected, and define the methods as public, so that external code can access and operate the properties of the object through the methods. The following is an example of using the public access modifier:

class Person {
  public $name;
  
  public function sayHello() {
    echo "Hello, my name is ".$this->name;
  }
}

$person = new Person();
$person->name = "John";
$person->sayHello();  // 输出 "Hello, my name is John"

In the above code, we define a Person class with the $name attribute and sayHello() methods are all public. By setting $name as a public property, external code can directly modify and access the property's value. The sayHello() method can print out a greeting in external code by instantiating the object and calling the method.

2. Private access modifier

Private access modifier means that the properties and methods of the object can only be accessed and called within the class to which they belong, and external code cannot directly access. In order to access private properties and methods, we need to use public methods defined inside the class. Here is an example of using the private access modifier:

class Person {
  private $name;
  
  public function setName($name) {
    $this->name = $name;
  }
  
  public function sayHello() {
    echo "Hello, my name is ".$this->name;
  }
}

$person = new Person();
$person->setName("John");
$person->sayHello();  // 输出 "Hello, my name is John"

In the above code, the $name property is defined as private and cannot be accessed directly by external code. In order to assign a value to this property, we define a public setName($name) method and set its value by accessing the private property within the method. Similarly, the sayHello() method can be used in external code to print out the greeting by instantiating the object and calling the method.

3. Protected (protected) access modifier

The protected access modifier indicates that the properties and methods of the object can only be accessed in the class to which it belongs and its subclasses. calls and cannot be directly accessed by external code. Similar to private access modifiers, in order to access protected properties and methods, we also need to use public methods defined within the class. The following is an example of using the protected access modifier:

class Person {
  protected $name;
  
  public function setName($name) {
    $this->name = $name;
  }
  
  public function sayHello() {
    echo "Hello, my name is ".$this->name;
  }
}

class Student extends Person {
  public function study() {
    echo $this->name." is studying.";
  }
}

$student = new Student();
$student->setName("John");
$student->sayHello();  // 输出 "Hello, my name is John"
$student->study();  // 输出 "John is studying."

In the above code, the $name attribute of the Person class is defined as protected, while The Student class inherits the Person class. Inside the Student class, we can directly access and call protected properties and methods inherited from the Person class. In external code, we access and call protected properties and methods by instantiating the Student object and calling its defined public methods.

By using access modifiers, we can better control the access rights of objects and avoid some unreasonable access and operations. In actual development, we should reasonably select and use access modifiers based on needs and design principles. I hope this article will help you understand and use access modifiers in PHP!

The above is the detailed content of Introduction to PHP Object-Oriented Programming: How to Use Access Modifiers to Protect Object Properties and Methods. For more information, please follow other related articles on the PHP Chinese website!