Константы класса
Статические свойства и методы
Ключевые слова static и self
Мы можем оперировать свойствами и методами не только в контексте объекта, но и в контексте класса . Это специальные свойства и методы и называются они — статическими . Объявляются они с помощью ключевого слова » static «, которое добавляется перед модификатором:
— public static $countCar — статическое свойство ,
— public static function getCount() — статический метод .
Тем самым мы указываем, что данное свойство или метод являются статическим и использовать их теперь можно не в контексте объекта, а в контексте класса.
Они могут быть нам полезны если по каким-то причинам нам не нужно создавать объект, но нужно работать с методами, свойствами класса.
Классический пример — создание калькулятора. Для того, чтобы производить математические операции, методы которых будут описанны в классе, нерационально создавать объект, проще для выполнения какой-нибудь операции обратиться к методу класса (как в процедурном программировании — вызывая функцию). В это случае, как раз и создают класс полностью статический — все методы и свойства в нем — статические (классо — ориентированное программирование).
Создание статического свойства
Обращение к статическому свойству внутри класса
Создадим счетчик автомобилей (файл Car.php из урока «Конструктор и деструктор»).
Для этого создадим статическое свойство public static $countCar=0 и присвоим начальное значение равное нулю.
Объявим статический метод public static function getCount() — данный метод будет получать значение счетчика.
Операция увеличения счетчика будет происходить в конструкторе.
Так как свойство $countCar — статическое оно принадлежит классу и обращаться к нему надо из контекста класса, а не объекта.
Ключевое слово self
Чтобы обратиться к свойству из класса используетя специальное ключевое свойство — self .
Ключевое слово self— указывает на текущий класс .
Оператор ::
Далее идет оператор двойное двоеточие » :: «
— это оператор разрешения области видимости , он служит для обращению к статическому свойству или статическому методу класса .
Далее: ++ — операция инкрементации.
В конструкторе обратимся к статическому свойству $countCar : self :: $countCar ++
Файл Car.php
class Car
<
public $color ;
public $wheels ;
public $speed ;
public $brand ;
// статическое свойство $countCar (счетчик автомобилей) с начальным значением 0
public static $countCar = 0 ;
public function __construct ( $color , $wheels = 4 , $speed , $brand )
<
// обращения из контекста объекта:
$this -> color = $color ;
$this -> wheels = $wheels ;
$this -> speed = $speed ;
$this -> brand = $brand ;
// статическое свойство $countCar —
// — счетчик объектов — это свойство принадлежит классу, а не объекту
// обращаться к нему надо из контекста класса, а не объекта
// ключевое слово self — указывает на текущий класс
// :: — оператор разрешения области видимости
self :: $countCar ++ ;
>
public function getCarInfo ()
<
return «
О моем авто:
Марка: < $this ->brand >
Цвет: < $this ->color >
Кол-во колес: < $this ->wheels >
Скорость: < $this ->speed >
» ;
>
>
?>
Обращение к статическому свойству вне класса
Чтобы обратиться к статическому свойству из вне класса необходимо:
— обратиться к классу : Car ,
— далее поставить оператор двойное двоеточие : «::» ,
— далее идет само статическое свойство : $countCar .
Выведем его три раза — до создания первого объекта, после создания первого объекта, после создания второго объекта. (файл index.php из урока «Конструктор и деструктор»).
Файл index.php
error_reporting (- 1 );
require_once ‘classes/Car.php’ ;
function debug ( $data )
<
echo ‘
' . print_r ( $data , 1 ) . '
‘ ;
>
// первый вывод статического свойства $countCar (до создания первого объекта)
// обращение к свойству или методу через имя класса и оператора ::
echo Car :: $countCar ;
echo ‘
‘ ;
$car1 = new Car ( ‘черный’ , 4 , 180 , ‘volvo’ );
// второй вывод статического свойства $countCar (после создания первого объекта)
echo Car :: $countCar ;
echo ‘
‘ ;
$car2 = new Car ( ‘белый’ , 4 , 220 , ‘bmv’ );
// третий вывод статического свойства $countCar (после создания второго объекта)
echo Car :: $countCar ;
echo ‘
‘ ;
// обращение к методу getCarInfo()(вывод информации о созданном объекте (автомобиле))
echo $car1 -> getCarInfo ();
echo $car2 -> getCarInfo ();
?>
После обновления страницы получим:
0 — значение счетчика до создания первого объекта (значение, которое установили по умолчанию)
1 — значение счетчика после создания первого объекта
2 — значение счетчика после создания второго объекта
О моем авто:
Марка: volvo
Цвет: черный
Кол-во колес: 4
Скорость: 180
О моем авто:
Марка: bmv
Цвет: белый
Кол-во колес: 4
Скорость: 220
Создание статического метода
Объявим статический метод public static function getCount() — данный метод будет получать значение счетчика.
Он должен обратиться к статическому свойству $countCar: self::$countCar .
Файл Car.php
class Car
<
public $color ;
public $wheels ;
public $speed ;
public $brand ;
// статическое свойство $countCar (счетчик автомобилей) с начальным значением 0
public static $countCar = 0 ;
public function __construct ( $color , $wheels = 4 , $speed , $brand )
<
// обращения из контекста объекта:
$this -> color = $color ;
$this -> wheels = $wheels ;
$this -> speed = $speed ;
$this -> brand = $brand ;
// статическое свойство $countCar —
self :: $countCar ++ ;
// Car::$countCar++; — так тоже можно записать
>
// объявляем статический метод getCount(), данный метод будет получать значение счетчика
public static function getCount ()
<
// возвращает количество автомобилей
return self :: $countCar ;
// return Car::$countCar; — так тоже можно записать
>
public function getCarInfo ()
<
return «
О моем авто:
Марка: < $this ->brand >
Цвет: < $this ->color >
Кол-во колес: < $this ->wheels >
Скорость: < $this ->speed >
» ;
>
>
?>
Обращение к статическому методу вне класса
В индексном файле обратимся к методу getCount() :
Файл index.php
error_reporting (- 1 );
require_once ‘classes/Car.php’ ;
function debug ( $data )
<
echo ‘
' . print_r ( $data , 1 ) . '
‘ ;
>
echo Car :: $countCar ;
echo ‘
‘ ;
$car1 = new Car ( ‘черный’ , 4 , 180 , ‘volvo’ );
echo Car :: $countCar ;
echo ‘
‘ ;
$car2 = new Car ( ‘белый’ , 4 , 220 , ‘bmv’ );
echo Car :: $countCar ;
echo ‘
‘ ;
// обращение к статическому методу getCount()
/* ——- */
// выводим результат работы статического метода getCount()
// обращение к свойству или методу через имя класса и оператора ::
echo Car :: getCount ();
echo ‘
‘ ;
echo ‘Количество созданных автомобилей:’ . Car :: getCount ();
echo ‘
‘ ;
/* ——- */
echo $car1 -> getCarInfo ();
echo $car2 -> getCarInfo ();
?>
После обновления страницы получим:
0 — значение счетчика до создания первого объекта (значение, которое установили по умолчанию)
1 — значение счетчика после создания первого объекта
2 — значение счетчика после создания второго объекта
О моем авто:
Марка: volvo
Цвет: черный
Кол-во колес: 4
Скорость: 180
О моем авто:
Марка: bmv
Цвет: белый
Кол-во колес: 4
Скорость: 220
2 — результат обращение к методу getCount()
Количество созданных автомобилей: 2 — результат обращение к методу getCount()
Константы класса
Константы — постоянные свойства .
— Константы нужны для того, чтобы хранить неизменную, постоянную информацию , например, настройки соединения с базой данных (имя пользователя, пароль, хост и т. д.).
— Определяются они с помощью ключевого слова — const .
— По умолчанию константы являются публичными.
Константы принадлежат не объекту, а классу и соответственно, обращаться к ним мы можем в контексте класса, а не объекта, также как мы делали это со статическими свойствами:
— через ключевое слово self и двойное двоеточие «::» (внутри класса),
— через имя класса и двойное двоеточие «::» (вне класса).
Для неизменяемого прототипа автомобиля в классе Car создадим две константы:
— const TEST_CAR = ‘Прототип’; — создание константы TEST_CAR (ключевое слово — const ),
— const TEST_CAR_SPEED = 300 ; — скорость прототипа TEST_CAR_SPEED .
Определим метод getPrototypeInfo() , который будет выводить данные прототипа:
Файл Car.php
class Car
<
public $color ;
public $wheels ;
public $speed ;
public $brand ;
public static $countCar = 0 ;
// создание константы — прототип (ключевое слово — const)
const TEST_CAR = ‘Прототип’ ;
// создание константы — скорость прототипа
const TEST_CAR_SPEED = 300 ;
public function __construct ( $color , $wheels = 4 , $speed , $brand )
<
$this -> color = $color ;
$this -> wheels = $wheels ;
$this -> speed = $speed ;
$this -> brand = $brand ;
self :: $countCar ++ ;
>
public static function getCount ()
<
return self :: $countCar ;
>
public function getCarInfo ()
<
return «
О моем авто:
Марка: < $this ->brand >
Цвет: < $this ->color >
Кол-во колес: < $this ->wheels >
Скорость: < $this ->speed >
» ;
>
// определяем метод (getPrototypeInfo), который будет выводить данные прототипа
// (работаем с константами в контексте класса — обращение с помощью — self::)
public function getPrototypeInfo ()
<
return «
Данные тестового авто:
Наименование: » . self :: TEST_CAR . »
Скорость: » . self :: TEST_CAR_SPEED . «
» ;
>
>
?>
Обращение к константе вне класса
Вызовем в индексном файле метод getPrototypeInfo() и обратимся к константе через имя класса:
Файл index.php
error_reporting (- 1 );
require_once ‘classes/Car.php’ ;
function debug ( $data )
<
echo ‘
' . print_r ( $data , 1 ) . '
‘ ;
>
echo Car :: $countCar ;
echo ‘
‘ ;
$car1 = new Car ( ‘черный’ , 4 , 180 , ‘volvo’ );
echo Car :: $countCar ;
echo ‘
‘ ;
$car2 = new Car ( ‘белый’ , 4 , 220 , ‘bmv’ );
echo Car :: $countCar ;
echo ‘
‘ ;
echo Car :: getCount ();
echo ‘
‘ ;
echo ‘Количество созданных автомобилей:’ . Car :: getCount ();
echo ‘
‘ ;
echo $car1 -> getCarInfo ();
echo $car2 -> getCarInfo ();
// вызываем метод getPrototypeInfo() для первого автомобиля
echo $car1 -> getPrototypeInfo ();
echo ‘
‘ ;
// обращение к константе вне класса через имя класса
echo Car :: TEST_CAR_SPEED ;
?>
После обновления страницы получим:
0
1
2
О моем авто:
Марка: volvo
Цвет: черный
Кол-во колес: 4
Скорость: 180
О моем авто:
Марка: bmv
Цвет: белый
Кол-во колес: 4
Скорость: 220
2
Количество созданных автомобилей: 2
— результат работы метода getPrototypeInfo()
Данные тестового авто:
Наименование: Прототип
Скорость: 300
300 — результат обращение к константе вне класса через имя класса
Отличие статических свойств и методов от обычных
Обычные свойства и методы описаны в классе и принадлежат они объекту .
Вызывать их можно в контексте объекта:
— если мы работаем в классе, то — this
— если мы работаем вне класса, то через созданный экземпляр класса, то есть объект .
Статические свойства и методы и константы также описаны в классе, но принадлежат они
не объекту, а классу .
Обращатся к ним нужно в контексте класса:
— внутри класса — через ключевое слово self и двойное двоеточие «::» ,
— вне класса — через наименование класса и двойное двоеточие «::» .
Содержание папки 6 («Константы класса. Статические свойства и методы»):
Разница между `self` и `this` в PHP
$this — это не переменная, а псевдопеременная. Оператор разрешения области видимости можно использовать вместе с $this.
Leave a reply
Ньюансы многосайтовой установки битрикса
Профайлеры и трейсеры
You might also like
Класс для работы с CURL на PHP
Идеальная защита от ботов без капчи
Заметки по laravel
PHP How to debug to file
PHP аналог команды dir/ls
Get Newsletter
Online chat
Send ◃toggle▹ Open in new window
Featured Posts
Простые модалы
Заметки DevOps
Заметки Linux
Recent Posts
How to make Outline VPN for 1€/month October 30, 2023
Отличия Авторизации от Аутентификации и их обоих от Идентификации October 29, 2023
Итерация элементов JavaScript на примере отписки от mail.ru October 29, 2023
Telegram bots Awesome October 29, 2023
Categories
Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed voluptua. At vero eos et accusam et justo duo dlores et ea rebum magna text ar koto din.
contact Info
б. Черемушкинская 20, Москва
Phone: +123 456 78900
Testimonials
Очень хороший сайт, прям помог вообще!
ЗлостныйКодер
У каждого обычно возникает вопрос, что такое $this, что такое self, для чего они используются и в чем разница между ними?
ПРАВИЛА КОТОРЫЕ ВЫ ДОЛЖНЫ ЗАПОМНИТЬ:
- Статические функции должны использовать только статические переменные.
- self ТОЛЬКО для статических функций, свойств. Но также можно вызвать нестатический метод, КАК СТАТИЧЕСКИЙ через self. Но лучше так не делать, а то папа побьет.
- this ТОЛЬКО для нестатических.
- this требует, чтобы класс был проинстанцирован, self не требует.
class human public $name;
public function klassFunc() <>; function getName() echo $name; // неправильно, обратиться не к переменной public name echo $this->name; // правильно //вызов метода класса $this->klassFunc(); > >
Обычна нужна, чтобы инициализировать поля в конструкторе, ну и не только:
class human public $name;
public function __construct($name)$this->name = $name;$name = $name; //будет ошибка$self используется в том, же самом ключе, но уже для СТАТИЧЕСКИХ свойств:
class human static $name = "ololo";public function klassFunc() <>; function getName() echo self::$name; //обращение к nameecho $this->name; //null или ошибка. НЕЛЬЗЯ > >Проверочная программа которая показывает главную разницу между self и $this:
class Klass const STAT = 'S' ; // константы всегда статичны static $stat = 'Static' ;
public $publ = 'Public' ;
private $priv = 'Private' ;
protected $prot = 'Protected' ;public function show ( ) print '
self::STAT: ' . self :: STAT ; // ссылается на константу
print '
self::$stat: ' . self :: $stat ; // статическая переменная.
print '
$this->stat: ' . $this -> stat ; // Ошибки нет, но выведет пустую строку. ПРЕДУПРЕЖДЕНИЕ.
print '
$this->publ: ' . $this -> publ ; // выведет как надо
print '
' ;
>
> $me = new Klass () ; $me -> show () ;Результат:
self::STAT: S
self::$stat: Static
Strict Standards: Accessing static property Klass::$stat as non static in htdocs\test\testReference.php on line ..
Notice: Undefined property: Klass::$stat in C:\xampp\htdocs\test\testReference.php on line 50
$this->stat:
$this->publ: Public
Видно, что php умный и кидает предупреждения глупым программистам. Не делайте так.Второе главное отличие состоит в том, что
self не использует таблицу виртуальных методов, то есть:
(взято с StackOverflow)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()."
"; > public function sayGoodbye() echo "Goodbye from ".self::getTitle()."
"; > > 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();Hello, I'm Ludwig the geek
Goodbye from Ludwig the personПояснение:
Метод sayHello использует this, поэтому виртуальная таблица вызовет Geek::getTitle()
Метод sayGoodbye использует self, поэтому виртуальная таблица будет не задействована и будет вызван parent::getTitle()Решение:
Используем вместо self, static keyword:
public function sayGoodbye() echo "Goodbye from ". static::getTitle() ;Всем, спасибо, за внимание 🙂
Когда использовать self вместо $this?
Используйте $this для ссылки на текущий объект, а self — для ссылки на текущий класс. Другими словами, используйте $this->member для нестатических членов, а self::$member — для статических.
Полный ответ
Ниже приведен пример правильного использования $this и self для не статических и статических переменных-членов:
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 для нестатических и статических переменных-членов:
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 для функций-членов:
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 функций-членов:
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() любого точного типа текущего объекта. Если объект имеет тип X, то вызывается X::foo(). Если объект имеет тип Y, то вызывается Y::foo(). Но при использовании self::foo() всегда вызывается X::foo().
Ответ 2
Ключевое слово self НЕ относится только к « текущему классу » , по крайней мере, не так, чтобы ограничивать вас статическими членами. В контексте нестатического члена self также предоставляет возможность обойти 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()."
";>
public function sayGoodbye()
echo "Goodbye from ".self::getTitle()."
";>
>
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();
Это выведет:
Hello, I'm Ludwig the geek
Goodbye from Ludwig the personsayHello() использует указатель $this, поэтому для вызова Geek::getTitle() вызывается vtable. sayGoodbye() использу ет self::getTitle(), поэтому vtable не используется, а вызывается Person::getTitle(). В обоих случаях мы имеем дело с методом инстанцированного объекта и имеем доступ к указателю $this внутри вызываемых функций.
Ответ 3
НЕ ИСПОЛЬЗУЙТЕ self. используйте static::
Есть еще один аспект self. о котором стоит упомянуть. Досадно, что self:: относится к области видимости в точке определения, а не в точке выполнения. Рассмотрим простой класс с двумя методами:
class Person
public static function status()
self::getStatus();
>
protected static function getStatus()
echo "Person is alive";
>
>
Если мы вызовем Person::status(), то увидим « Person is alive » . Теперь рассмотрим, что произойдет, если мы создадим класс, который наследуется от него:
class Deceased extends Person
protected static function getStatus()
echo "Person is deceased";
>
>
Вызывая Deceased::status(), мы ожидали бы увидеть « Person is deceased » , однако мы видим « Person is alive » , поскольку область видимости содержит исходное определение метода, когда был определен вызов self::getStatus().
В PHP 5.3 есть решение. Оператор разрешения static:: реализует « позднюю статическую привязку » , что является интересным способом указать, что он привязан к области видимости вызываемого класса. Измените строку в status() на static::getStatus(), и результаты будут такими, как вы ожидаете. В более старых версиях PHP вам придется прибегнуть к хитрости, чтобы сделать это.
Итак, резюмируя…
$this-> относится к текущему объекту (экземпляру класса), тогда как static:: относится непосредственно к классу.
Ответ 4
Чтобы по-настоящему понять, о чем мы говорим, когда говорим о 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 .
Определение состояния
- Свойства — воспринимайте их как переменные, которые будет содержаться в каждом экземпляре.
- Статические свойства — воспринимайте их как переменные, которые раздел я ются на уровне класса. Это означает, что они никогда не копируются каждым экземпляром.
- Методы — это функции, которые будут содержаться в каждом экземпляре (и работать над экземплярами).
- Статические методы — это функции, общие для всего класса. Они не работают с экземплярами, только со статическими свойствами.
- Константы — класс разрешает использование констант. Не будем углубляться, но добавим для полноты:
Состояние и методы
Внутри метода экземпляр объекта представлен переменной $this. В ней находится текущее состояние этого объекта, и мутирование (изменение) любого свойства приведет к изменению этого экземпляра (но не других).
Если метод вызывается статически, переменная $this не определяется. Это происходит потому, что со статическим вызовом не ассоциируется ни один экземпляр.
Интересным здесь является то, как выполняются статические вызовы. Поэтому давайте поговорим о том, как мы получаем доступ к состоянию.
Состояние доступа
Итак, теперь, когда мы сохранили это состояние, нам нужно получить к нему доступ. Это может оказаться немного сложным, поэтому давайте разделим это на две точки зрения: снаружи экземпляра/класса (скажем, из обычного вызова функции или из глобальной области видимости) и внутри экземпляра/класса (из метода объекта).
Снаружи экземпляра/класса
- -> - объект-оператор — всегда используется, когда мы обращаемся к экземпляру.
- :: - scope-Resolution-operator — всегда используется для доступа к статическому свойству или методу класса.
Внутри экземпляра/класса
- В статическом контексте.
- В контексте экземпляра.
Краткие ключевые слова
- 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(). Но мы используем parent::getName(), чтобы сделать это в одном из случаев (дочерний случай). Именно это и делает данный подход мощным.
Мы будем очень благодарны
если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.