What is the difference between the calling methods of php objects

The difference between the calling methods of PHP objects is: 1. To use "->" to call the member properties and methods of the object, you need to instantiate the object first, and then access it through the object variable, while using ":: "To call static properties and methods of a class, you do not need to instantiate the object first, but directly use the class name and static property/method name to access; 2. Use "->" to access non-static properties and methods, and also Dynamically change properties and call methods, while using "::" cannot access non-static properties and methods, nor can you change property values, but it is faster than dynamic calls.

Operating system for this tutorial: Windows 10 system, php8.1.3 version, Dell G3 computer.

In PHP, the common object calling methods are `->` and `::`.

Among them, `->` is used to call the member properties and methods of the object, and `::` is used to call the static properties and methods of the class.

1. `->` Calls the member attributes and methods of the object

Using `->` to call the member attributes and methods of the object requires instantiation first Object and then access it through object variables. The advantage of this approach is that you can access non-static properties and methods, and you can also dynamically change properties and call methods. The disadvantage is that it is slightly slower than static calling because the object needs to be instantiated first.

Sample code:

```php
class Person {
    public $name;
    
    public function sayHello() {
        echo "Hello, my name is {$this->name}!";
    }
}
$person = new Person();
$person->name = 'Alice';
$person->sayHello(); // 输出：Hello, my name is Alice!
```

In the above example, we created a `Person` class and instantiated a `$person` object. The `name` attribute is set through `$person->name`, and then the `sayHello()` method is called through `$person->sayHello()` to output the greeting.

2. `::` calls the static properties and methods of the class

Use `::` to call the static properties and methods of the class without instantiating the object first , but access directly using the class name and static property/method name. The advantage of this method is that it is faster than dynamic calling because there is no need to instantiate the object first. The disadvantage is that non-static properties and methods cannot be accessed, and property values ​​cannot be changed.

The following is a simple PHP code example that demonstrates how to call static properties and methods of a class:

```php
<?php
class MyClass {
  public static $myStaticProperty = "Hello World!";
  public static function myStaticMethod() {
    echo "This is a static method.";
  }
}
echo MyClass::$myStaticProperty; // 输出 "Hello World!"
MyClass::myStaticMethod(); // 输出 "This is a static method."
?>
```

Start by declaring a class named `MyClass`. In this class, a public static property called `$myStaticProperty` is defined and set to the string `"Hello World!"`. Next, a public static method called `myStaticMethod()` is also defined, which simply prints a message.

To access these static properties and methods, you can call them using the class name plus the scope resolution operator `::`. For example, you can use `MyClass::$myStaticProperty` to access the `$myStaticProperty` property and print its value, or use `MyClass::myStaticMethod()` to call the `myStaticMethod()` method and execute the code in it.

The above is the detailed content of What is the difference between the calling methods of php objects. For more information, please follow other related articles on the PHP Chinese website!