oophp, method and property naming

Question

In php, is there any difference between using

$myClass::method()

and

$myClass->method()

What's the reason for the change? (I believe -> has been around longer.)

I could see a point of using :: for methods and -> for properties or vice versa.

Answer 1

:: is the scope resolution operator, used for accessing static members of classes.

-> is the member operator, used for access members of objects.

Here's an example:

class Car {
   public $mileage, $current_speed, $make, $model, $year;
   public function getCarInformation() {
      $output = 'Mileage: ' . $this->mileage;
      $output = 'Speed: ' . $this->current_speed;
      $output = 'Make: ' . $this->make;
      $output = 'Model: ' . $this->model;
      $output = 'Year: ' . $this->year;
      return $output; 
   }
}

class CarFactory {

    private static $numberOfCars = 0;

    public static function carCount() {
       return self::$numberOfCars;    
    }

    public static function createCar() {
       self::$numberOfCars++; 
       return new Car();
    }

}    

echo CarFactory::carCount(); //0

$car = CarFactory::createCar();

echo CarFactory::carCount(); //1

$car->year = 2010;
$car->mileage = 0;
$car->model = "Corvette";
$car->make = "Chevrolet";

echo $car->getCarInformation();

Answer 2

Consider this:

class testClass {
    var $test = 'test';
    
    function method() {
        echo $this->test;
    }
}

$test = new testClass();

$test->method();
testClass::method();

The output will be something like:

test

Fatal error: Using $this when not in object context in ... on line 7

This is because :: makes a static call to a class while -> is used to call methods or properties on a specific instance of a class.

Incidentally, I don't believe you can do $test::method() because PHP will give you a parse error like this:

Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM in ... on line 14

Answer 3

:: is also used within a class/object to call its parent, e.g.:

parent::__constructor();

Also if it's called from within an object (so not statically).