To access object properties and methods in PHP, use the -> operator. If the properties or methods are private, they need to be obtained through public methods. The details are as follows: 1. After creating the object, use $object->property or $object->method() to access public properties and methods; 2. Private or protected members need to be accessed indirectly through public methods such as getter/setter; 3. Static properties and methods are directly accessed through class name::. Mastering these rules can effectively avoid misuse of operators and implement encapsulation and control of data.

In PHP, accessing object properties and methods is straightforward once you understand the basics of object-oriented programming (OOP). When you create an object from a class, you can interact with it using the arrow operator ( -> ). Here's how to do it properly.

Accessing Object Properties

After creating an instance of a class, you access its properties using the -> symbol followed by the property name. This only works if the property is accessible — meaning it's not declared as private or protected .

Example:

 class Car {
    public $color = 'red';
}

$myCar = new Car();
echo $myCar->color; // Outputs: red

A few things to keep in mind:

• Always check if the property exists before trying to access it.
• Use public visibility for properties you want to access outside the class.
• You can also dynamically assign values:

   $myCar->color = 'blue';

If the property is private or protected , you'll need to use getter methods (more on that below).

Calling Object Methods

Just like with properties, you use the -> operator to call methods on an object. The method must be defined in the class and accessible (not private if you're calling it from outside the class).

Example:

 class Car {
    public function startEngine() {
        echo 'Engine started';
    }
}

$myCar = new Car();
$myCar->startEngine(); // Outputs: Engine started

Tips when working with methods:

• Make sure the method is defined in the class.
• If the method requires parameters, pass them inside the parentstheses.
• You can chain method calls if they return the object itself:

   $myCar->setColor('green')->startEngine();

This kind of chaining is common in fluent interfaces or build patterns.

Handling Private and Protected Members

You can't directly access private or protected properties or methods from outside the object. That's where getters and setters come in handy.

Example:

 class Car {
    private $color;

    public function setColor($color) {
        $this->color = $color;
    }

    public function getColor() {
        return $this->color;
    }
}

$myCar = new Car();
$myCar->setColor('black');
echo $myCar->getColor(); // Outputs: black

Why this matters:

• It gives you control over how data is set and retrieved.
• You can validate input inside setter methods.
• It follows OOP principles like encapsulation.

So even though you can't access $myCar->color directly here, you can safely manipulate it through public methods.

Working with Static Properties and Methods

Sometimes you don't need an object instance to access a property or method. In those cases, use static .

Example:

 class Car {
    public static $wheels = 4;

    public static function showWheels() {
        echo self::$wheels;
    }
}

echo Car::$wheels; // Outputs: 4
Car::showWheels(); // Outputs: 4

Key points:

• Use the scope resolution operator :: instead of -> .
• Inside the class, refer to static members with self:: .
• Static methods can't access non-static properties unless you instantiate the class inside the method.

Keep in mind that static members are shared across all instances of the class.

Basically that's it. As long as you understand the relationship between objects and classes and master the role of access modifiers, it will not be too difficult to operate attributes and methods. However, one thing that is easy to ignore is that sometimes you may misuse -> and :: , especially when dealing with static members, you should pay special attention to this.

The above is the detailed content of How do I access object properties and methods in PHP?. For more information, please follow other related articles on the PHP Chinese website!