Короткий ответ

Используйте $this для обозначения текущего объекта. Используйте self для обозначения текущего класса. Другими словами, используйте $this->member для нестатических членов, используйте self::$member для статических членов.

Полный ответ

Вот пример правильного использования $this и self для нестатических и статических переменных-членов:

 <?php class X { private $non_static_member = 1; private static $static_member = 2; function __construct() { echo $this->non_static_member . ' ' . self::$static_member; } } new X(); ?> 

Ниже приведен пример неправильного использования $this и self для нестатических и статических переменных-членов:

 <?php class X { private $non_static_member = 1; private static $static_member = 2; function __construct() { echo self::$non_static_member . ' ' . $this->static_member; } } new X(); ?> 

Вот пример полиморфизма с $this для функций-членов:

 <?php class X { function foo() { echo 'X::foo()'; } function bar() { $this->foo(); } } class Y extends X { function foo() { echo 'Y::foo()'; } } $x = new Y(); $x->bar(); ?> 

Ниже приведен пример подавления полиморфного поведения с помощью self для функций-членов:

 <?php class X { function foo() { echo 'X::foo()'; } function bar() { self::foo(); } } class Y extends X { function foo() { echo 'Y::foo()'; } } $x = new Y(); $x->bar(); ?> 

Идея состоит в том, что $this->foo() вызывает функцию-член foo() любого типа> точного типа текущего объекта. Если объект имеет type X , он таким образом> вызывает X::foo() . Если объект имеет type Y , он вызывает Y::foo() . Но с> self :: foo () всегда вызывается X::foo() .

С http://www.phpbuilder.com/board/showthread.php?t=10354489 :

По http://board.phpbuilder.com/member.php?145249-laserlight

Ключевое слово self не относится только к «текущему классу», по крайней мере, не таким образом, что ограничивает вас статическими членами. В контексте нестатического элемента self также предоставляет способ обхода vtable ( см. Wiki на vtable ) для текущего объекта. Так же, как вы можете использовать parent::methodName() для вызова родительской версии функции, вы можете вызвать self::methodName() чтобы вызвать реализацию метода в текущем классе.

 class Person { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } public function getTitle() { return $this->getName()." the person"; } public function sayHello() { echo "Hello, I'm ".$this->getTitle()."<br/>"; } public function sayGoodbye() { echo "Goodbye from ".self::getTitle()."<br/>"; } } class Geek extends Person { public function __construct($name) { parent::__construct($name); } public function getTitle() { return $this->getName()." the geek"; } } $geekObj = new Geek("Ludwig"); $geekObj->sayHello(); $geekObj->sayGoodbye(); 

Это приведет к выводу:

Привет, я Людвиг, выродка
До свидания с Людвигом человек

sayHello() использует указатель $this , поэтому vtable вызывается для вызова Geek::getTitle() . sayGoodbye() использует self::getTitle() , поэтому vtable не используется и Person::getTitle() . В обоих случаях мы имеем дело с методом экземпляра объекта и имеем доступ к $this указателю в вызываемых функциях.

НЕ ИСПОЛЬЗУЙТЕ self:: , используйте static::

Существует еще один аспект самого себя: это стоит упомянуть. Раздражающе self:: ссылается на область действия в точке определения не в точке исполнения . Рассмотрим этот простой класс двумя способами:

 class Person { public static function status() { self::getStatus(); } protected static function getStatus() { echo "Person is alive"; } } 

Если мы будем называть Person::status() мы увидим, что «Человек жив». Теперь рассмотрим, что происходит, когда мы создаем класс, который наследует от этого:

 class Deceased extends Person { protected static function getStatus() { echo "Person is deceased"; } } 

Calling Deceased::status() мы ожидаем увидеть «Человек умер», однако мы видим, что «Человек жив», поскольку область содержит определение исходного метода, когда был определен call to self::getStatus() .

PHP 5.3 имеет решение. оператор static:: resolution реализует «позднюю статическую привязку», которая является причудливым способом сказать, что она связана с областью действия класса. Измените строку в status() на static::getStatus() и результаты – это то, что вы ожидаете. В старых версиях PHP вам нужно будет найти kludge для этого.

См. Документацию по PHP

Поэтому, чтобы ответить на вопрос, а не на вопрос …

$this-> относится к текущему объекту (экземпляру класса), тогда как static:: относится к классу

Чтобы действительно понять, о чем мы говорим, когда говорим о self и об $this , нам нужно действительно вникать в то, что происходит на концептуальном и практическом уровне. Я действительно не чувствую, что какие-либо ответы соответствуют этому, поэтому вот моя попытка.

Давайте начнем с обсуждения того, что такое класс и объект .

Классы и объекты, концептуально

Итак, что такое класс ? Многие люди определяют его как план или шаблон для объекта. На самом деле, вы можете прочитать больше о классах в PHP . И в какой-то степени это так. Давайте посмотрим на класс:

 class Person { public $name = 'my name'; public function sayHello() { echo "Hello"; } } 

Как вы можете сказать, в этом классе есть свойство под названием $name и метод (функция), называемый sayHello() .

Очень важно отметить, что класс является статической структурой. Это означает, что класс Person , когда-то определенный, всегда один и тот же, когда вы смотрите на него.

Объект, с другой стороны, является тем, что называется экземпляром класса. Это означает, что мы берем «план» этого класса и используем его для создания динамической копии. Эта копия теперь специально привязана к переменной, в которой она хранится. Поэтому любые изменения экземпляра являются локальными для этого экземпляра.

 $bob = new Person; $adam = new Person; $bob->name = 'Bob'; echo $adam->name; // "my name" 

Мы создаем новые экземпляры класса с использованием new оператора.

Поэтому мы говорим, что класс является глобальной структурой, а объект является локальной структурой. Не беспокойтесь об этом смешном синтаксисе, мы немного займемся этим.

Еще одна вещь, о которой мы должны поговорить, заключается в том, что мы можем проверить , является ли экземпляр instanceof определенного класса: $bob instanceof Person который возвращает логическое значение, если экземпляр $bob был создан с использованием класса Person или дочернего элемента Person .

Определение состояния

Итак, давайте немного разобьем то, что на самом деле содержит класс. Существует 5 типов «вещей», которые содержит класс:

1. Свойства. Подумайте об этом как о переменных, которые будут содержать каждый экземпляр.

    class Foo { public $bar = 1; } 

2. Статические свойства. Подумайте об этом как о переменных, которые совместно используются на уровне класса. Это означает, что они никогда не копируются каждым экземпляром.

    class Foo { public static $bar = 1; } 

3. Методы. Это функции, которые каждый экземпляр будет содержать (и работать с экземплярами).

    class Foo { public function bar() {} } 

4. Статические методы. Это функции, которые совместно используются во всем классе. Они не работают по экземплярам, ​​а только по статическим свойствам.

    class Foo { public static function bar() {} } 

5. Константы – константы разрешенных классов. Не пойду глубже, но добавляем для полноты:

    class Foo { const BAR = 1; } 

Поэтому в основном мы сохраняем информацию о контейнере класса и объекта, используя «подсказки» о статике, которые определяют, является ли эта информация общей (и, следовательно, статической) или нет (и, следовательно, динамической).

Состояние и методы

Внутри метода экземпляр объекта представлен переменной $this . Текущее состояние этого объекта есть, и изменение (изменение) любого свойства приведет к изменению этого экземпляра (но не других).

Если метод называется статически, переменная $this не определена . Это связано с тем, что нет никакого экземпляра, связанного со статическим вызовом.

Интересно, как делаются статические вызовы. Итак, давайте поговорим о том, как мы обращаемся к государству:

Доступ к государству

Итак, теперь, когда мы сохранили это состояние, нам нужно получить к нему доступ. Это может немного запутаться (или немного больше), поэтому давайте разделим это на две точки зрения: извне экземпляра / класса (скажем, из обычного вызова функции или из глобальной области) и внутри экземпляра / class (изнутри метода объекта).

Из вне экземпляра / класса

С внешней стороны экземпляра / класса наши правила довольно просты и предсказуемы. У нас есть два оператора, и каждый говорит нам немедленно, если мы имеем дело с экземпляром или классом static:

• -> – object-operator – Это всегда используется, когда мы обращаемся к экземпляру.

   $bob = new Person; echo $bob->name; 

  Важно отметить, что вызов Person->foo не имеет смысла (поскольку Person является классом, а не экземпляром). Следовательно, это ошибка синтаксического анализа.

• :: – scope-resolution-operator – Это всегда используется для доступа к статическому свойству или методу класса.

   echo Foo::bar() 

  Кроме того, мы можем вызвать статический метод для объекта таким же образом:

   echo $foo::bar() 

  Крайне важно отметить, что, когда мы делаем это извне , экземпляр объекта скрыт от метода bar() . Это означает, что это точно так же, как запуск:

   $class = get_class($foo); $class::bar(); 

Следовательно, $this не определено в статическом вызове.

Изнутри экземпляра / класса

Вещи немного меняются. Используются те же самые операторы, но их значение становится значительно размытым.

Объект-оператор -> по-прежнему используется для совершения вызовов в состояние экземпляра объекта.

 class Foo { public $a = 1; public function bar() { return $this->a; } } 

Вызов метода bar() в $foo (экземпляр Foo ) с использованием объекта-оператора: $foo->bar() приведет к версии экземпляра $a .

Так мы и ожидаем.

Значение оператора :: меняться. Это зависит от контекста вызова текущей функции:

• В статическом контексте

  В статическом контексте любые вызовы, сделанные с помощью :: , также будут статическими. Давайте посмотрим на пример:

   class Foo { public function bar() { return Foo::baz(); } public function baz() { return isset($this); } } 

  Вызов Foo::bar() будет вызывать метод baz() статически, и, следовательно, $this не будет заселен. Стоит отметить, что в последних версиях PHP (5.3+) это вызовет ошибку E_STRICT , потому что мы статически ставим нестатические методы.

• В контексте экземпляра

  С другой стороны, в контексте экземпляра вызовы, сделанные с использованием :: зависят от получателя вызова (метод, который мы вызываем). Если метод определен как static , то он будет использовать статический вызов. Если это не так, он отправит информацию об экземпляре.

  Итак, рассмотрев приведенный выше код, вызов $foo->bar() вернет true , поскольку «статический» вызов происходит внутри контекста экземпляра.

Имеют смысл? Не думал так. Это сбивает с толку.

Краткосрочные ключевые слова

Поскольку связывание всего вместе с использованием имен классов довольно грязно, PHP предоставляет 3 основных слова "ярлыка", чтобы упростить определение области.

• self – Это относится к текущему имени класса. Итак, self::baz() совпадает с Foo::baz() в классе Foo (любой метод на нем).

• parent Это относится к родительскому элементу текущего класса.

• static – это относится к вызываемому классу. Благодаря наследованию дочерние классы могут переопределять методы и статические свойства. Поэтому вызов их с использованием static вместо имени класса позволяет нам решить, откуда пришел вызов, а не текущий уровень.

Примеры

Самый простой способ понять это – начать изучать некоторые примеры. Давайте подберем класс:

 class Person { public static $number = 0; public $id = 0; public function __construct() { self::$number++; $this->id = self::$number; } public $name = ""; public function getName() { return $this->name; } public function getId() { return $this->id; } } class Child extends Person { public $age = 0; public function __construct($age) { $this->age = $age; parent::__construct(); } public function getName() { return 'child: ' . parent::getName(); } } 

Теперь мы также рассматриваем наследство. Игнорируйте на мгновение, что это плохая модель объекта, но давайте посмотрим, что происходит, когда мы играем с этим:

 $bob = new Person; $bob->name = "Bob"; $adam = new Person; $adam->name = "Adam"; $billy = new Child; $billy->name = "Billy"; var_dump($bob->getId()); // 1 var_dump($adam->getId()); // 2 var_dump($billy->getId()); // 3 

Таким образом, счетчик ID используется как для обоих экземпляров, так и для детей (потому что мы используем self для доступа к нему. Если мы использовали static , мы могли бы переопределить его в дочернем классе).

 var_dump($bob->getName()); // Bob var_dump($adam->getName()); // Adam var_dump($billy->getName()); // child: Billy 

Обратите внимание, что мы каждый раз Person::getName() метод экземпляра Person::getName() . Но мы используем parent::getName() чтобы сделать это в одном из случаев (дочерний регистр). Именно это делает этот подход мощным.

Word Of Caution # 1

Обратите внимание, что вызывающий контекст определяет, используется ли экземпляр. Следовательно:

 class Foo { public function isFoo() { return $this instanceof Foo; } } 

Это не всегда так.

 class Bar { public function doSomething() { return Foo::isFoo(); } } $b = new Bar; var_dump($b->doSomething()); // bool(false) 

Теперь это действительно странно. Мы вызываем другой класс, но $this который передается методу Foo::isFoo() является экземпляром $bar .

Это может вызвать всевозможные ошибки и концептуальные WTF-ery. Поэтому я настоятельно рекомендую избегать использования :: оператора из методов экземпляра на всех, кроме трех виртуальных «коротких сокращенных» ключевых слов ( static , self и parent ).

Word Of Caution # 2

Обратите внимание, что статические методы и свойства разделяются всеми. Это делает их в основном глобальными переменными. Со всеми теми же проблемами, что и с глобальными. Поэтому я бы очень не решался хранить информацию в статических методах / свойствах, если вам не нравится, что это действительно глобально.

Слово предостережения № 3

В общем, вы захотите использовать то, что известно как Late-Static-Binding, используя static а не self . Но имейте в виду, что они не одно и то же, поэтому «всегда использовать static а не self скорее близорукость. Вместо этого остановитесь и подумайте о том, что вы хотите сделать, и подумайте, хотите ли вы, чтобы дочерние классы могли переопределять это статический разрешенный вызов.

TL / DR

Слишком плохо, вернитесь и прочитайте. Это может быть слишком долго, но это так долго, потому что это сложная тема

TL / DR # 2

Хорошо. Короче говоря, self используется для ссылки на текущее имя класса внутри класса, где as $this относится к текущему экземпляру объекта. Обратите внимание, что self является копией / вставкой. Вы можете спокойно заменить его своим именем класса, и он будет работать нормально. Но $this динамическая переменная, которая не может быть определена заранее (и может и не быть вашим классом).

TL / DR # 3

Если используется оператор-оператор ( -> ), вы всегда знаете, что имеете дело с экземпляром. Если используется оператор-разрешающая способность ( :: , вам нужна дополнительная информация о контексте (мы уже в объектном контексте? Не за пределами объекта?).

self (not $ self) относится к типу класса, где as $this относится к текущему экземпляру класса. self используется для использования в статических функциях-членах, чтобы вы могли получить доступ к статическим переменным-членам. $this используется в нестатических функциях-членах и является ссылкой на экземпляр класса, на который была вызвана функция-член.

Поскольку this объект, вы используете его как: $this->member

Поскольку self не является объектом, это в основном тип, который автоматически ссылается на текущий класс, вы используете его как: self::member

$ this-> используется для обозначения конкретного экземпляра переменных класса (переменных-членов) или методов.

 Example: $derek = new Person(); 

$ derek теперь является конкретным экземпляром Person. У каждого человека есть first_name и last_name, но у $ derek есть определенное имя_имя и last_name (Дерек Мартин). Внутри экземпляра $ derek мы можем обращаться к ним как $ this-> first_name и $ this-> last_name

ClassName :: используется для обозначения этого типа класса и его статических переменных, статических методов. Если это поможет, вы можете мысленно заменить слово «статический» на «общий». Поскольку они являются общими, они не могут ссылаться на $ this, что относится к определенному экземпляру (не разделяемому). Статические переменные (т.е. статические $ db_connection) могут быть разделены между всеми экземплярами типа объекта. Например, все объекты базы данных используют одно соединение (статическое соединение $).

Статические переменные Пример: Представьте, что у нас есть класс базы данных с одной переменной-членом: static $ num_connections; Теперь поставьте это в конструкторе:

 function __construct() { if(!isset $num_connections || $num_connections==null) { $num_connections=0; } else { $num_connections++; } } 

Так же, как объекты имеют конструкторы, они также имеют деструкторы, которые выполняются, когда объект умирает или не работает:

 function __destruct() { $num_connections--; } 

Каждый раз, когда мы создаем новый экземпляр, он увеличит счетчик соединений на один. Каждый раз, когда мы уничтожаем или останавливаем использование экземпляра, он уменьшает счетчик соединений на единицу. Таким образом, мы можем отслеживать количество экземпляров используемого объекта базы данных:

 echo DB::num_connections; 

Поскольку $ num_connections является статическим (общим), он будет отображать общее количество активных объектов базы данных. Возможно, вы видели эту технику, используемую для совместного использования соединений с базой данных среди всех экземпляров класса базы данных. Это делается потому, что создание соединения с базой данных занимает много времени, поэтому лучше всего создать один и поделиться им (это называется шаблоном Singleton).

Статические методы (т. Е. Public static View :: format_phone_number ($ digits)) можно использовать БЕЗ первого экземпляра одного из этих объектов (т. Е. Они внутренне не ссылаются на $ this).

Пример статического метода:

 public static function prettyName($first_name, $last_name) { echo ucfirst($first_name).' '.ucfirst($last_name); } echo Person::prettyName($derek->first_name, $derek->last_name); 

Как вы можете видеть, public static function prettyName ничего не знает об объекте. Он просто работает с параметрами, которые вы проходите, как обычная функция, которая не является частью объекта. Зачем же беспокоиться, если бы мы могли просто иметь это не как часть объекта?

1. Во-первых, привязка функций к объектам помогает вам организовывать вещи, поэтому вы знаете, где их найти.
2. Во-вторых, он предотвращает конфликты имен. В большом проекте у вас могут быть два разработчика, которые создают функции getName (). Если вы создаете ClassName1 :: getName (), а другой создает ClassName2 :: getName (), это не проблема. Нет конфликта. Yay статические методы!

SELF :: Если вы кодируете вне объекта, у которого есть статический метод, к которому вы хотите обратиться, вы должны вызвать его, используя имя объекта View :: format_phone_number ($ phone_number); Если вы кодируете внутри объекта, у которого есть статический метод, к которому вы хотите обратиться, вы можете либо использовать имя объекта View :: format_phone_number ($ pn), либо вы можете использовать ярлык self :: format_phone_number ($ pn)

То же самое касается статических переменных: Пример: View :: templates_path versus self :: templates_path

Внутри класса DB, если бы мы ссылались на статический метод какого-либо другого объекта, мы использовали бы имя объекта: Example: Session :: getUsersOnline ();

Но если класс DB хотел ссылаться на свою собственную статическую переменную, он просто сказал бы себя: Пример: self :: connection;

Надеюсь, что помогает разобраться 🙂

Из этого сообщения в блоге :

• self относится к текущему классу
• self может использоваться для вызова статических функций и ссылки на статические переменные-члены
• self может использоваться внутри статических функций
• self также может отключить полиморфное поведение, минуя vtable
• $this относится к текущему объекту
• $this можно использовать для вызова статических функций
• $this не следует использовать для вызова статических переменных-членов. Вместо этого используйте « self .
• $this не может использоваться внутри статических функций

В PHP вы используете ключевое слово self для доступа к статическим свойствам и методам.

Проблема в том, что вы можете заменить $this->method() на self::method() любом месте, независимо от того, объявлен ли method() статическим или нет. Итак, какой из них вы должны использовать?

Рассмотрим этот код:

 class ParentClass { function test() { self::who(); // will output 'parent' $this->who(); // will output 'child' } function who() { echo 'parent'; } } class ChildClass extends ParentClass { function who() { echo 'child'; } } $obj = new ChildClass(); $obj->test(); 

В этом примере self::who() всегда будет выводить «parent», а $this->who() будет зависеть от того, какой класс имеет объект.

Теперь мы можем видеть, что «я» относится к классу, в котором он вызывается, а « $this относится к классу текущего объекта .

Таким образом, вы должны использовать self только тогда, когда $this недоступно, или когда вы не хотите, чтобы классы потомков перезаписывали текущий метод.

Внутри определения класса $ this относится к текущему объекту, тогда как self относится к текущему классу.

Необходимо ссылаться на элемент класса, используя self, и ссылаться на элемент объекта, используя $ this.

 self::STAT // refer to a constant value self::$stat // static variable $this->stat // refer to an object variable 

Вот пример правильного использования $ this и self для нестатических и статических переменных-членов:

 <?php class X { private $non_static_member = 1; private static $static_member = 2; function __construct() { echo $this->non_static_member . ' ' . self::$static_member; } } new X(); ?> 

Согласно http://www.php.net/manual/en/language.oop5.static.php, нет $ self. Существует только $ this, для обращения к текущему экземпляру класса (объекта) и self, который может использоваться для ссылки на статические члены класса. Здесь происходит различие между экземпляром объекта и классом.

Я считаю, что вопрос не в том, можно ли вызвать статический член класса, вызвав ClassName :: staticMember. Вопрос в том, какая разница между использованием self :: classmember и $ this-> classmember.

Например, оба следующих примера работают без каких-либо ошибок, независимо от того, используете ли вы: self :: или $ this->

 class Person{ private $name; private $address; public function __construct($new_name,$new_address){ $this->name = $new_name; $this->address = $new_address; } } class Person{ private $name; private $address; public function __construct($new_name,$new_address){ self::$name = $new_name; self::$address = $new_address; } } 

само относится к текущему классу (в котором он называется),

$ this относится к текущему объекту. Вы можете использовать static вместо self. См. Пример:

  class ParentClass { function test() { self::which(); // output 'parent' $this->which(); // output 'child' } function which() { echo 'parent'; } } class ChildClass extends ParentClass { function which() { echo 'child'; } } $obj = new ChildClass(); $obj->test(); 

Выход: родительский ребенок

• Указатель объекта $ this относится к текущему объекту.
• Значение класса «static» относится к текущему объекту.
• Значение класса «я» относится к точному классу, в котором он был определен.
• Значение класса «parent» относится к родительскому объекту точного класса, в котором он был определен.

См. Следующий пример, показывающий перегрузку.

 <?php class A { public static function newStaticClass() { return new static; } public static function newSelfClass() { return new self; } public function newThisClass() { return new $this; } } class B extends A { public function newParentClass() { return new parent; } } $b = new B; var_dump($b::newStaticClass()); // B var_dump($b::newSelfClass()); // A because self belongs to "A" var_dump($b->newThisClass()); // B var_dump($b->newParentClass()); // A class C extends B { public static function newSelfClass() { return new self; } } $c = new C; var_dump($c::newStaticClass()); // C var_dump($c::newSelfClass()); // C because self now points to "C" class var_dump($c->newThisClass()); // C var_dump($b->newParentClass()); // A because parent was defined *way back* in class "B" 

Большую часть времени вы хотите обратиться к текущему классу, поэтому вы используете static или $this . Однако бывают случаи, когда вам нужно « self потому что вы хотите, чтобы оригинальный класс был независимо от того, что его расширяет. (Очень, очень редко)

Когда self используется с :: оператором, он ссылается на текущий класс, который может выполняться как в статическом, так и в нестационарном контексте. $this относится к самому объекту. Кроме того, совершенно законно использовать $this для вызова статических методов (но не для обозначения полей).

Поскольку здесь никто не говорил о спектаклях, вот небольшой показатель, который я сделал (5.6):

  Name | Time | Percent ----------|---------|--------- $this-> | 0.99163 | 106.23% self:: | 0.96912 | 103.82% static:: | 0.93348 | 100% 

Это результаты для 2 000 000 прогонов, и вот код, который я использовал:

 <?php require '../vendor/autoload.php'; // My small class to do benchmarks // All it does is looping over every test x times and record the // time it takes using `microtime(true)` // Then, the percentage is calculated, with 100% being the quickest // Times are being rouned for outputting only, not to calculate the percentages $b = new Tleb\Benchmark\Benchmark(2000000); class Foo { public function calling_this() { $this->called(); } public function calling_self() { self::called(); } public function calling_static() { static::called(); } public static function called() { } } $b->add('$this->', function () { $foo = new Foo; $foo->calling_this(); }); $b->add('self::', function () { $foo = new Foo; $foo->calling_self(); }); $b->add('static::', function () { $foo = new Foo; $foo->calling_static(); }); $b->run(); 

$this refers to the current class object, self refers to the current class (Not object). The class is the blueprint of the object. So you define a class, but you construct objects.

So in other words, use self for static and this for none-static members or methods .

also in child/parent scenario self / parent is mostly used to identified child and parent class members and methods.

Additionally since $this:: has not been discussed yet.

For informational purposes only, as of PHP 5.3 when dealing with instantiated objects to get the current scope value, as opposed to using static:: , one can alternatively use $this:: like so.

http://ideone.com/7etRHy

 class Foo { const NAME = 'Foo'; //Always Foo::NAME (Foo) due to self protected static $staticName = self::NAME; public function __construct() { echo $this::NAME; } public function getStaticName() { echo $this::$staticName; } } class Bar extends Foo { const NAME = 'FooBar'; /** * override getStaticName to output Bar::NAME */ public function getStaticName() { $this::$staticName = $this::NAME; parent::getStaticName(); } } $foo = new Foo; //outputs Foo $bar = new Bar; //outputs FooBar $foo->getStaticName(); //outputs Foo $bar->getStaticName(); //outputs FooBar $foo->getStaticName(); //outputs FooBar 

Using the code above is not common or recommended practice, but is simply to illustrate its usage, and is to act as more of a "Did you know?" in reference to the original poster's question.

It also represents the usage of $object::CONSTANT for example echo $foo::NAME; as opposed to $this::NAME;

Use 'self' if you want to call a method of a class without creating an object/instance of that class, thus saving RAM (sometimes use self for that purpose). In other words, it is actually calling a method statically. Use 'this' for object perspective.

Case 1: Use self can be used for class constants

 class classA { 
     const FIXED_NUMBER = 4; 
     self::POUNDS_TO_KILOGRAMS
 }

If you want to call it outside of the class, use classA::POUNDS_TO_KILOGRAMS to access the constants

Case 2: For static properties

class classC {
     public function __construct() { 
     self::$_counter++; $this->num = self::$_counter;
    }
 }

According to php.net there are three special keywords in this context: self , parent and static . They are used to access properties or methods from inside the class definition.

$this , on the other hand, is used to call an instance and methods of any class as long as that class is accessible.