new static php что это
Готовимся к собеседованию по PHP: ключевое слово «static»
Не секрет, что на собеседованиях любят задавать каверзные вопросы. Не всегда адекватные, не всегда имеющие отношение к реальности, но факт остается фактом — задают. Конечно, вопрос вопросу рознь, и иногда вопрос, на первый взгляд кажущийся вам дурацким, на самом деле направлен на проверку того, насколько хорошо вы знаете язык, на котором пишете.
Попробуем разобрать «по косточкам» один из таких вопросов — что значит слово «static» в PHP и зачем оно применяется?
Ключевое слово static имеет в PHP три различных значения. Разберем их в хронологическом порядке, как они появлялись в языке.
Значение первое — статическая локальная переменная
Однако всё меняется, если мы перед присваиванием поставим ключевое слово static:
Подводные камни статических переменных
Разумеется, как всегда в PHP, не обходится без «подводных камней».
Камень первый — статической переменной присваивать можно только константы или константные выражения. Вот такой код:
с неизбежностью приведет к ошибке парсера. К счастью, начиная с версии 5.6 стало допустимым присвоение не только констант, но и константных выражений (например — «1+2» или «[1, 2, 3]»), то есть таких выражений, которые не зависят от другого кода и могут быть вычислены на этапе компиляции
Камень второй — методы существуют в единственном экземпляре.
Тут всё чуть сложнее. Для понимания сути приведу код:
Такое поведение может быть неожиданным для неподготовленного к нему разработчика и послужить источником ошибок. Нужно заметить, что наследование класса (и метода) приводит к тому, что всё-таки создается новый метод:
Вывод: динамические методы в PHP существуют в контексте классов, а не объектов. И только лишь в рантайме происходит подстановка «$this = текущий_объект»
Значение второе — статические свойства и методы классов
В объектной модели PHP существует возможность задавать свойства и методы не только для объектов — экземпляров класса, но и для класса в целом. Для этого тоже служит ключевое слово static:
Для доступа к таким свойствам и методам используются конструкции с двойным двоеточием («Paamayim Nekudotayim»), такие как ИМЯ_КЛАССА::$имяПеременной и ИМЯ_КЛАССА:: имяМетода().
Само собой разумеется, что у статических свойств и статических методов есть свои особенности и свои «подводные камни», которые нужно знать.
Особенность вторая — static не аксиома!
Обратное не совсем верно:
И кстати, всё написанное выше относится только к методам. Использование статического свойства через «->» невозможно и ведет к фатальной ошибке.
Значение третье, кажущееся самым сложным — позднее статическое связывание
Разработчики языка PHP не остановились на двух значениях ключевого слова «static» и в версии 5.3 добавили еще одну «фичу» языка, которая реализована тем же самым словом! Она называется «позднее статическое связывание» или LSB (Late Static Binding).
Понять суть LSB проще всего на несложных примерах:
Ключевое слово self в PHP всегда значит «имя класса, где это слово написано». В данном случае self заменяется на класс Model, а self::$table — на Model::$table.
Такая языковая возможность называется «ранним статическим связыванием». Почему ранним? Потому что связывание self и конкретного имени класса происходит не в рантайме, а на более ранних этапах — парсинга и компиляции кода. Ну а «статическое» — потому что речь идет о статических свойствах и методах.
Немного изменим наш код:
Теперь вы понимаете, почему PHP ведёт себя в этой ситуации неинтуитивно. self был связан с классом Model тогда, когда о классе User еще ничего не было известно, поэтому и указывает на Model.
Для решения этой дилеммы был придуман механизм связывания «позднего», на этапе рантайма. Работает он очень просто — достаточно вместо слова «self» написать «static» и связь будет установлена с тем классом, который вызывает данный код, а не с тем, где он написан:
Это и есть загадочное «позднее статическое связывание».
Нужно отметить, что для большего удобства в PHP кроме слова «static» есть еще специальная функция get_called_class(), которая сообщит вам — в контексте какого класса в данный момент работает ваш код.
New static php что это
Reg.ru: домены и хостинг
Крупнейший регистратор и хостинг-провайдер в России.
Более 2 миллионов доменных имен на обслуживании.
Продвижение, почта для домена, решения для бизнеса.
Более 700 тыс. клиентов по всему миру уже сделали свой выбор.
Бесплатный Курс «Практика HTML5 и CSS3»
Освойте бесплатно пошаговый видеокурс
по основам адаптивной верстки
на HTML5 и CSS3 с полного нуля.
Фреймворк Bootstrap: быстрая адаптивная вёрстка
Пошаговый видеокурс по основам адаптивной верстки в фреймворке Bootstrap.
Научитесь верстать просто, быстро и качественно, используя мощный и практичный инструмент.
Верстайте на заказ и получайте деньги.
Что нужно знать для создания PHP-сайтов?
Ответ здесь. Только самое важное и полезное для начинающего веб-разработчика.
Узнайте, как создавать качественные сайты на PHP всего за 2 часа и 27 минут!
Создайте свой сайт за 3 часа и 30 минут.
После просмотра данного видеокурса у Вас на компьютере будет готовый к использованию сайт, который Вы сделали сами.
Вам останется лишь наполнить его нужной информацией и изменить дизайн (по желанию).
Изучите основы HTML и CSS менее чем за 4 часа.
После просмотра данного видеокурса Вы перестанете с ужасом смотреть на HTML-код и будете понимать, как он работает.
Вы сможете создать свои первые HTML-страницы и придать им нужный вид с помощью CSS.
Бесплатный курс «Сайт на WordPress»
Хотите освоить CMS WordPress?
Получите уроки по дизайну и верстке сайта на WordPress.
Научитесь работать с темами и нарезать макет.
Бесплатный видеокурс по рисованию дизайна сайта, его верстке и установке на CMS WordPress!
Хотите изучить JavaScript, но не знаете, как подступиться?
После прохождения видеокурса Вы освоите базовые моменты работы с JavaScript.
Развеются мифы о сложности работы с этим языком, и Вы будете готовы изучать JavaScript на более серьезном уровне.
*Наведите курсор мыши для приостановки прокрутки.
Позднее статическое связывание: ключевое слово static
После того, как мы рассмотрели абстрактные классы и интерфейсы, самое время снова обратиться к статическим методам.
Вы уже знаете, что статический метод можно использовать в качестве фабрики, создающей экземпляры объектов того класса, в котором содержится этот метод. Если вы такой же ленивый программист, как и я, то вас должны раздражать повторы кода наподобие тех, что приведены ниже.
Сначала я создал суперкласс под именем DomainObject. Само собой разумеется, что в реальном проекте в нем будет находиться функциональность, общая для всех дочерних классов.
После этого я создал два дочерних класса User и Document. Я хотел, чтобы в каждом из моих конкретных классов находился метод create().
* Примечание
Почему для создания конкретного объекта я воспользовался статическим методом-фабрикой, а не оператором new и конструктором объекта?
Дело в том, что существует шаблон под названием Identity Map (материал по нему скоро будет доступен) и он создает и инициализирует новый объект только в том случае, если объект с аналогичными отличительными особенностями еще не создан. Если таковой объект существует, то возвращается просто ссылка на него.
Статический метод-фабрика наподобие рассмотренного выше метода create() является отличными кандидатом для реализации подобной функциональности.
Ну что ж, все выглядит круто! Теперь весь общий код сосредоточен в одном месте, и чтобы обратиться к текущему классу, я воспользуюсь ключевым словом self.
Однако насчет ключевого слова self я сделал допущение, что оно должно так работать. На самом деле оно не работает для классов так же, как псевдопеременная $this для объектов.
С помощью ключевого слова self нельзя сослаться на вызывающий объект. Оно используется только для разрешения ссылок на содержащий класс, в контексте которого вызывается метод. Поэтому при попытке запуска приведенного выше примера получим следующее сообщение об ошибке:
Переводится это так: невозможно создать экземпляр абстрактного класса.
Таким образом, ключевое слово self трансформируется в ссылку на класс DomainObject, в котором определен метод create(), а не на класс Document, для которого этот метод должен быть вызван.
До появления PHP 5.3 это было серьезным ограничением языка, которое породило массу неуклюжих обходных решений.
В PHP 5.3 впервые введена концепция позднего статического связывания (late static bindings). Самым заметным ее проявлением является введение нового (в данном контексте) ключевого слова static. Оно аналогично ключевому слову self, за исключением того, что относится к вызывающему, а не содержащему классу.
Итак, теперь я смогу воспользоваться всеми преимуществами наследования в статическом контексте.
В результате будет выведено следующее:
Ключевое слово static можно использовать не только для создания объектов. Так же, как и self и parent, его можно использовать как идентификатор для вызова статических методов даже из нестатического контекста.
Например, я хочу реализовать идею группировки моих классов DomainObject. По умолчанию все классы попадают в категорию «default». Но для некоторых веток иерархии наследования моих классов мне нужно это переопределить.
Здесь в класс DomainObject я ввел конструктор, в котором используется ключевое слово static для вызова метода getGroup(). Стандартное значение группы сосредоточено в классе DomainObject, но оно переопределяется в классе Document.
Я также создал новый класс SpreadSheet, расширяющий класс Document. Вот что получим в результате.
Все происходящее с классом User не настолько очевидно, поэтому требует пояснений.
В конструкторе класса DomainObject вызывается метод getGroup(), который интерпретатор находит в текущем классе. Несмотря на это, в случае с классом SpreadSheet поиск метода getGroup() начинается не с класса DomainObject, а с класса SpreadSheet, для которого из метода create() был вызван стандартный конструктор.
Поскольку в классе SpreadSheet реализиция метода getGroup() не предусмотрена, интерпретатор вызывает аналогичный метод класса Document (т.е. идет вверх по иерархии объектов).
Таким образом, до появления PHP 5.3 и позднего статического связывания, здесь у нас возникала проблема из-за использования ключевого слова self, которое находило метод getGroup() только в классе DomainObject. Теперь же этот вопрос можно считать решенным.
На этом я завершаю данную статью. В следующем материале мы поговорим об обработке ошибок в PHP.
Понравился материал и хотите отблагодарить?
Просто поделитесь с друзьями и коллегами!
Позднее статическое связывание в PHP (Часть I)
Позднее Статическое Связывание (Late Static Binding, LSB) является бурно темой обсуждений последние три года в кругах разработчиков PHP (и наконец мы его получили в PHP 5.3). Но зачем оно нужно? В данной статье, как раз и будет рассматриваться, как позднее статическое связывание может значительно упростить ваш код.
На встрече разработчиков PHP, которая проходила в Париже в ноябре 2005 года, тема позднего статического связывания официально обсуждалась основной командой разработчиков. Они согласились реализовать его, наряду со многими другими темами, которые стояли на повестке дня. Детали должны были быть согласованы в ходе открытых дискуссий.
С тех пор как позднее статическое связывание было объявлено как грядущая фишка, прошло два года. И вот наконец LSB стало доступно для использования в PHP 5.3. Но это событие прошло незаметно для разработчиков использующих PHP, из заметок только страничка в мануале.
Если кратко, новая функциональность позднего статического связывания, позволяет объектам все также наследовать методы у родительских классов, но помимо этого дает возможность унаследованным методам иметь доступ к статическим константам, методам и свойствам класса потомка, а не только родительского класса. Давайте рассмотрим пример:
Этот код выдаст такой результат:
Класс Ale унаследовал метод getName(), но при этом self все еще указывает на класс в котором оно используется (в данном случае это класс Beer). Это осталось и в PHP 5.3, но добавилось слово static. И снова рассмотрим пример:
Новое ключевое слово static указывает, что необходимо использовать константу унаследованного класса, вместо константы которая была определена в классе где объявлен метод getStaticName(). Слово static было добавлено, чтобы реализовать новый функционал, а для обратной совместимости self работает также как и в предыдущих версиях PHP.
Внутренне, основное отличие (и, собственно, причина почему связывание назвали поздним) между этими двумя способами доступа, в том, что PHP определят значение для self::NAME во время «компиляции» (когда симовлы PHP преобразуются в машинный код, который будет обрабатываться движком Zend), а для static::NAME значение будет определено в момент запуска (в тот момент, когда машинный код будет выполнятся в движке Zend).
Это еще один инструмент для PHP-разработчиков. Во второй части рассмотрим как его можно использовать во благо.
New static php что это
Эта страница описывает использование ключевого слова static для определения статических методов и свойств. static также может использоваться для определения статических переменных и позднего статического связывания. Для получения информации о таком применении ключевого слова static обратитесь по вышеуказанным страницам.
Объявление свойств и методов класса статическими позволяет обращаться к ним без создания экземпляра класса. К ним также можно получить доступ статически в созданном экземпляре объекта класса.
Статические методы
Пример #1 Пример статического метода
Foo :: aStaticMethod ();
$classname = ‘Foo’ ;
$classname :: aStaticMethod ();
?>
Статические свойства
Пример #2 Пример статического свойства
Результат выполнения данного примера в PHP 8 аналогичен:
User Contributed Notes 28 notes
Here statically accessed property prefer property of the class for which it is called. Where as self keyword enforces use of current class only. Refer the below example:
public function static_test ()<
This is also possible:
You misunderstand the meaning of inheritance : there is no duplication of members when you inherit from a base class. Members are shared through inheritance, and can be accessed by derived classes according to visibility (public, protected, private).
The difference between static and non static members is only that a non static member is tied to an instance of a class although a static member is tied to the class, and not to a particular instance.
That is, a static member is shared by all instances of a class although a non static member exists for each instance of class.
class Derived extends Base
<
public function __construct()
<
$this->a = 0;
parent::$b = 0;
>
public function f()
<
$this->a++;
parent::$b++;
>
>
$i1 = new Derived;
$i2 = new Derived;
To check if a method declared in a class is static or not, you can us following code. PHP5 has a Reflection Class, which is very helpful.
It is important to understand the behavior of static properties in the context of class inheritance:
— Static properties defined in both parent and child classes will hold DISTINCT values for each class. Proper use of self:: vs. static:: are crucial inside of child methods to reference the intended static property.
— Static properties defined ONLY in the parent class will share a COMMON value.
declare( strict_types = 1 );
$a = new staticparent ;
$a = new staticchild ;
It should be noted that in ‘Example #2’, you can also call a variably defined static method as follows:
Static variables are shared between sub classes
class Child1 extends MyParent <
class Child2 extends MyParent <
To check if a function was called statically or not, you’ll need to do:
(I’ll add this to the manual soon).
The static keyword can still be used (in a non-oop way) inside a function. So if you need a value stored with your class, but it is very function specific, you can use this:
echo aclass::b(); //24
echo aclass::b(); //36
echo aclass::b(); //48
echo aclass::$d; //fatal error
Starting with php 5.3 you can get use of new features of static keyword. Here’s an example of abstract singleton class:
abstract class Singleton <
/**
* Prevent direct object creation
*/
final private function __construct ()
/**
* Prevent object cloning
*/
final private function __clone ()
On PHP 5.2.x or previous you might run into problems initializing static variables in subclasses due to the lack of late static binding:
If the init() method looks the same for (almost) all subclasses there should be no need to implement init() in every subclass and by that producing redundant code.
Solution 1:
Turn everything into non-static. BUT: This would produce redundant data on every object of the class.
Short example on a DataRecord class without error checking:
Regarding the initialization of complex static variables in a class, you can emulate a static constructor by creating a static function named something like init() and calling it immediately after the class definition.
/*
this is the example to use new class with static method..
i hope it help
*/
It’s come to my attention that you cannot use a static member in an HEREDOC string. The following code
function __construct()
<
echo
Inheritance with the static elements is a nightmare in php. Consider the following code:
class DerivedClassOne extends BaseClass <
>
class DerivedClassTwo extends BaseClass <
>
At this point I think it is a big pity inheritance does not work in case of static variables/methods. Keep this in mind and save your time when debugging.
Hi, here’s my simple Singleton example, i think it can be useful for someone. You can use this pattern to connect to the database for example.
$objA = MySingleton :: getInstance (); // Object created!
$objB = MySingleton :: getInstance ();
Расширенные возможности использования объектов
В предыдущей статье вы уже познакомились с уточнением типов аргументов методов класса и управлением доступом к свойствам и методам. Все это позволяет довольно гибко управлять интерфейсом класса. В этой статье мы подробнее изучим более сложные объектно-ориентированные возможности PHP.
Статические методы и свойства
Во всех примерах показанных ранее мы работали с объектами. Я охарактеризовал классы как шаблоны, с помощью которых создаются объекты, а объекты — как активные компоненты, методы которых мы вызываем и к свойствам которых получаем доступ. Отсюда следовал вывод, что в объектно-ориентированном программировании реальная работа выполняется с помощью экземпляров классов. А классы, в конечном счете, — это просто шаблоны для создания объектов.
Но на самом деле не все так просто. Мы можем получать доступ и к методам, и к свойствам в контексте класса, а не объекта. Такие методы и свойства являются «статическими» и должны быть объявлены с помощью ключевого слова static:
— это функции, используемые в контексте класса. Они сами не могут получать доступ ни к каким обычным свойствам класса, потому что такие свойства принадлежат объектам. Однако из статических методов можно обращаться к статическим свойствам. И если вы измените статическое свойство, то все экземпляры этого класса смогут получать доступ к новому значению.
Поскольку доступ к статическому элементу осуществляется через класс, а не экземпляр объекта, вам не нужна переменная, которая ссылается на объект. Вместо этого используется имя класса, после которого указывается два двоеточия «::».
Вызов метода с помощью ключевого слова parent — это единственный случай, когда следует использовать статическую ссылку на нестатический метод. Кроме случаев обращения к переопределенному методу родительского класса, конструкция «::» должна всегда использоваться только для доступа к статическим методам или свойствам. Однако в документации часто можно увидеть использование конструкции «::» для ссылок на методы или свойства (использовать в данном случае «->» в документации не совсем корректно). Это не означает, что рассматриваемый элемент — обязательно статический; это всего лишь значит, что он принадлежит к указанному классу. Например, ссылку на метод write() класса ShopProductWriter можно записать так: ShopProductwriter::write(), несмотря на то что метод write() не является статическим. При этом использовать эту конструкцию в коде нельзя!
А зачем вообще использовать статический метод или свойство? У статических элементов есть ряд полезных характеристик. Во-первых, они доступны из любой точки сценария (при условии, что у вас есть доступ к классу). Это означает, что вы можете обращаться к функциям, не передавая экземпляр класса от одного объекта другому или, что еще хуже, сохраняя экземпляр объекта в глобальной переменной. Во-вторых, статическое свойство доступно каждому экземпляру объекта этого класса. Поэтому можно определить значения, которые должны быть доступны всем объектам данного типа. И наконец, сам факт, что не нужно иметь экземпляр класса для доступа к его статическому свойству или методу, позволит избежать создания экземпляров объектов исключительно ради вызова простой функции.
Постоянные свойства
Некоторые свойства не должны изменяться. Например, такие элементы, как коды ошибок или коды состояния программы, задаются обычно вручную в классах. Хотя они должны быть общедоступными и статическими, клиентский код не должен иметь возможность изменять их.
В PHP 5 можно определять постоянные свойства внутри класса. Как и глобальные константы, константы класса нельзя изменять после того, как они были определены. Постоянное свойство объявляют с помощью ключевого слова const. В отличие от обычных свойств, перед именем постоянного свойства не ставится знак доллара. По принятому соглашению им часто назначают имена, состоящие только из прописных букв, как в следующем примере:
Постоянные свойства могут содержать только значения, относящиеся к элементарному типу. Константе нельзя присвоить объект. Как и к статическим свойствам, доступ к постоянным свойствам осуществляется через класс, а не через экземпляр объекта. Подобно тому как константа определяется без знака доллара, при обращении к ней также не требуется использовать никакой символ впереди:
Попытка присвоить константе значение после того, как она была объявлена, приведет к ошибке на этапе синтаксического анализа. Константы следует использовать, когда свойство должно быть доступным для всех экземпляров класса и когда значение свойства должно быть фиксированным и неизменным.
Абстрактные классы
Введение абстрактных классов стало одним из главных изменений в PHP 5. А включение этой функции в список новых возможностей стало еще одним подтверждением растущей приверженности PHP объектно-ориентированному проектированию. Нельзя создать экземпляр абстрактного класса. Вместо этого в нем определяется (и, возможно, частично реализуется) интерфейс для любого класса, который может его расширить.
Абстрактный класс определяется с помощью ключевого слова abstract. Давайте переопределим класс ShopProductWriter, который мы создали ранее, в виде абстрактного класса:
В абстрактном классе вы можете создавать методы и свойства, как обычно, но любая попытка создать его экземпляр приведет к ошибке:
Ошибка создания экземпляра абстрактного класса
В большинстве случаев абстрактный класс будет содержать, по меньшей мере, один абстрактный метод. Как и класс, он описывается с помощью ключевого слова abstract. Абстрактный метод не может иметь реализацию в абстрактном классе. Он объявляется как обычный метод, но объявление заканчивается точкой с запятой, а не телом метода. Давайте добавим абстрактный метод write() к классу ShopProductWriter:
Создавая абстрактный метод, вы гарантируете, что его реализация будет доступной во всех конкретных дочерних классах, но детали этой реализации остаются неопределенными. Итак, в любом классе, который расширяет абстрактный класс, должны быть реализованы все абстрактные методы либо сам класс должен быть объявлен абстрактным. При этом в расширяющем классе должны быть не просто реализованы все абстрактные методы, но и должна быть воспроизведена сигнатура их методов. Это означает, что уровень доступа в реализующем методе не может быть более строгим, чем в абстрактном методе. Реализующему методу также должно передаваться такое же количество аргументов, как и абстрактному методу, а также в нем должны воспроизводиться все уточнения типов класса.
Ниже приведены две реализации класса ShopProductWriter:
В PHP 4 работу абстрактных классов моделировали с помощью методов, которые выводили предупреждающие сообщения или даже содержали операторы die(). Это заставляло программиста реализовывать абстрактные методы в производном классе, поскольку в противном случае сценарий переставал работать. Проблема состояла в том, что абстрактная природа базового класса проверяется только в случае вызова абстрактного метода. В PHP 5 абстрактные классы проверяются еще на этапе синтаксического анализа, что намного безопаснее.
Интерфейсы
Как известно, в абстрактном классе допускается частичная реализация методов, не объявленных абстрактными. В отличие от них, интерфейсы — это чистой воды шаблоны. Интерфейс может только определять функциональность, но никогда не реализует ее. Для объявления интерфейса используется ключевое слово interface. Интерфейс может содержать объявления свойств и методов, но не тела этих методов.
Давайте определим интерфейс:
Как видите, интерфейс очень похож на класс. Любой класс, содержащий этот интерфейс, должен реализовывать все методы, определенные в интерфейсе; в противном случае класс должен быть объявлен как абстрактный.
При реализации интерфейса в классе, имя интерфейса указывается в объявлении этого класса после ключевого слова implements. После этого процесс реализации интерфейса станет точно таким же, как расширение абстрактного класса, который содержит только абстрактные методы. Давайте сделаем так, чтобы в классе ShopProduct был реализован интерфейс IChargeable:
В классе ShopProduct уже есть метод getPrice(), что же может быть полезного в реализации интерфейса IChargeable? И снова ответ связан с типами. Дело в том, что реализующий класс принимает тип класса и интерфейса, который он расширяет. Это означает, что класс CDProduct относится к следующим типам: CDProduct, ShopProduct, IChargeable. Эту особенность можно использовать в клиентском коде. Как известно, тип объекта определяет его функциональные возможности. Поэтому метод
Поскольку интерфейс можно реализовать в любом классе (на самом деле, в классе можно реализовать любое количество интерфейсов), с помощью интерфейсов можно эффективно объединить типы данных, не связанных никакими другими отношениями. В результате мы можем определить совершенно новый класс, который реализует интерфейс IChargeable:
Затем объект типа Shipping мы можем передать методу addChargeableItem(), точно так же как мы передавали ему объект типа CDProduct. Для клиента, работающего с объектом типа IChargeable, очень важно то, что он может вызвать метод getPrice(). Любые другие имеющиеся методы связаны с другими типами — через собственный класс объекта, суперкласс или другой интерфейс. Но они не имеют никакого отношения к нашему клиенту.
В классе можно как расширить суперкласс, так и реализовать любое количество интерфейсов, при этом ключевое слово extends должно предшествовать ключевому слову implements.
В PHP поддерживается только наследование от одного родителя (так называемое одиночное наследование), поэтому после ключевого слова extends можно указать только одно имя базового класса.
Позднее статическое связывание: ключевое слово static
После того как мы рассмотрели абстрактные классы и интерфейсы, самое время снова обратиться к статическим методам. Статический метод можно использовать в качестве фабрики, создающей экземпляры объектов того класса, в котором содержится этот метод. Если вы такой же ленивый программист, как и я, то вас должны раздражать повторы кода наподобие тех, что приведены ниже:
Сначала я создал суперкласс под именем DomainObject. Само собой разумеется, что в реальном проекте в нем будет находиться функциональность, общая для всех дочерних классов. После этого я создал два дочерних класса User и Document. Я хотел, чтобы в каждом из моих конкретных классов находился метод create(). Созданный мною код прекрасно работает, но в нем есть досадный недостаток — дублирование. Мне совсем не нравится повторять однотипный код наподобие того, что приведен выше, для каждого создаваемого дочернего объекта, расширяющего класс DomainObject. Как насчет того, чтобы переместить метод create() в суперкласс?
Итак, теперь я смогу воспользоваться всеми преимуществами наследования в статическом контексте:
В результате будет выведено «Document Object ( )». Ключевое слово static можно использовать не только для создания объектов. Так же как и self и parent, его можно использовать как идентификатор для вызова статических методов даже из нестатического контекста. Например, я хочу реализовать идею группировки моих классов DomainObject. По умолчанию все классы попадают в категорию ‘default’. Но для некоторых веток иерархии наследования моих классов мне нужно это переопределить:
Здесь в класс DomainObject я ввел конструктор, в котором используется ключевое слово static для вызова метода getGroup(). Стандартное значение группы сосредоточено в классе DomainObject, но оно переопределяется в классе Document. Я также создал новый класс SpreadSheet, расширяющий класс Document. Вот что получим в результате. 
Использование позднего статического связывания для вызова метода из контекста класса
Все происходящее с классом User не настолько очевидно и поэтому требует объяснений. В конструкторе класса DomainObject вызывается метод getGroup(), который интерпретатор находит в текущем классе. Несмотря на это, в случае с классом SpreadSheet поиск метода getGroup() начинается не с класса DomainObject, а с класса SpreadSheet, для которого из метода create() был вызван стандартный конструктор. Поскольку в классе spreadsheet реализация метода getGroup() не предусмотрена, интерпретатор вызывает аналогичный метод класса Document (т.е. идет вверх по иерархии объектов). До появления PHP 5.3 и позднего статического связывания, здесь у меня возникала проблема из-за использования ключевого слова self, которое находило метод getGroup() только в классе DomainObject.
Завершенные классы и методы
Наследование открывает большие возможности для широкого поля действий в пределах иерархии класса. Вы можете переопределить класс или метод, чтобы вызов в клиентском методе приводил к совершенно разным результатам, в зависимости от типа объекта, переданного методу в качестве аргумента. Но иногда код класса или метода нужно зафиксировать, если предполагается, что в дальнейшем он не должен изменяться. Если вы создали необходимый уровень функциональности для класса и считаете, что его переопределение может только повредить идеальной работе программы, используйте ключевое слово final. Ключевое слово final позволяет положить конец наследованию. Для завершенного класса нельзя создать подкласс. А завершенный метод нельзя переопределить.
Давайте объявим класс завершенным:
А теперь сделаем попытку создать подкласс класса Checkout:
Это приведет к ошибке PHP: «Class IllegalCheckout may not inherit from final class». Мы можем несколько «смягчить» ситуацию, объявив завершенным только метод в классе Checkout, а не весь класс. Ключевое слово final должно стоять перед любыми другими модификаторами, такими как protected или static:
Теперь мы можем создать подкласс класса Checkout, но любая попытка переопределить метод some() приведет к неустранимой ошибке.
В хорошем объектно-ориентированном коде обычно во главу угла ставится строго определенный интерфейс. Но за этим интерфейсом могут скрываться разные реализации. Разные классы или сочетания классов могут соответствовать общим интерфейсам, но при этом вести себя по-разному в разных ситуациях. Объявляя класс или метод завершенным, вы тем самым ограничиваете эту гибкость. В некоторых случаях это выгодно. Но прежде чем объявлять что-либо завершенным, следует серьезно подумать. Действительно ли нет таких ситуаций, в которых переопределение было бы полезным? Конечно, вы всегда можете передумать, но внести изменения впоследствии может быть нелегко, например, если вы распространяете библиотеку для совместного использования. Поэтому будьте осторожны, используя ключевое слово final.
Работа с методами-перехватчиками
В PHP предусмотрены встроенные методы-перехватчики, которые могут перехватывать сообщения, посланные неопределенным (т.е. несуществующим) методам или свойствам. Это свойство называется также перегрузкой (overloading), но поскольку этот термин в Java и С# означает нечто совершенно другое, я думаю, будет лучше использовать термин «перехват» (interception).
В PHP 5 поддерживается несколько встроенных методов-перехватчиков. Как и в случае метода __construct(), вызов этих методов происходит неявно, когда удовлетворяются соответствующие условия. Эти методы описаны в таблице ниже:
Методы __get() и __set() предназначены для работы со свойствами, которые не были объявлены в классе (или его родителе). Метод __get() вызывается, когда клиентский код пытается прочитать необъявленное свойство. Он вызывается автоматически с одним строковым аргументом, содержащим имя свойства, к которому клиентский код пытается получить доступ. Все, что вернет метод __get(), будет отослано обратно клиенту, как будто искомое свойство существует с этим значением. Рассмотрим короткий пример:
то метод getName() вызывается неявно и выводится строка «Вася».
Если же метод не существует, то ничего не происходит. Свойству, к которому пользователь пытается обратиться, присваивается значение NULL. Метод __isset() работает аналогично методу __get(). Он вызывается после того, как в клиентском коде вызывается функция isset() и ей в качестве параметра передается имя неопределенного свойства. Метод __set() вызывается, когда клиентский код пытается присвоить значение неопределенному свойству. При этом передается два аргумента: имя свойства и значение, которое клиентский код пытается присвоить. Затем вы можете решить, как работать с этими аргументами.
Метод __call(), вероятно, самый полезный из всех методов-перехватчиков. Он вызывается, когда клиентский код обращается к неопределенному методу. При этом методу __call() передается имя несуществующего метода и массив, в котором содержатся все аргументы, переданные клиентом. Значение, возвращаемое методом __call(), передается клиенту так, как будто оно было возвращено вызванным несуществующим методом.
Метод __call() может использоваться для делегирования. Делегирование — это механизм, посредством которого один объект может вызвать метод другого объекта. Это чем-то напоминает наследование, когда дочерний класс вызывает метод, реализованный в родительском классе. В случае наследования взаимосвязь между родительским и дочерним классами фиксирована. Поэтому возможность изменить объект-получатель во время выполнения программы означает, что делегирование является более гибким, чем наследование. Чтобы лучше это понять, давайте проиллюстрируем все на примере. Рассмотрим простой класс, предназначенный для форматирования информации, полученной от класса Person:
то будет вызван метод __call(). В нем определяется, что в объекте типа PersonWriter существует метод с именем writeName(), который и вызывается. Это позволяет избежать вызова делегированного метода вручную, как показано ниже:
Таким образом класс Person, как по волшебству, получил два новых метода класса PersonWriter. Хотя автоматическое делегирование избавляет вас от рутинной работы по однотипному кодированию вызовов методов, сам код становится труден для понимания. И если в вашей программе активно используется делегирование, то для внешнего мира создается динамический интерфейс, который не поддается рефлексии (исследованию аспектов класса во время выполнения программы) и не всегда с первого взгляда понятен программисту клиентского кода.
Причина в том, что логика, лежащая в основе взаимодействия между делегирующим классом и целевым объектом, может быть непонятной. Ведь она скрыта в таких методах, как __call(), а не явно задана отношениями наследования или уточнениями типа аргументов методов. Методы-перехватчики имеют свою область применения, но использовать их следует с осторожностью. И в классах, которые применяют эти методы, факт такого применения необходимо очень четко и ясно документировать. К вопросам делегирования и рефлексии мы вернемся позже в следующих статьях.
Определение методов деструктора
Например, предположим, что класс после получения специальной команды сохраняет данные объекта в базе данных. Тогда метод __destruct() можно использовать для того, чтобы гарантированно сохранить данные объекта перед его удалением из памяти. Добавим деструктор в класс Person, как показано ниже:
Метод __destruct() вызывается каждый раз, когда объект Person удаляется из памяти. Это происходит при вызове функции unset(), которой передается ссылка на удаляемый объект, а также в случае, когда в текущем процессе не остается никаких ссылок на наш объект. Поэтому, если мы создадим объект Person, а затем решим его уничтожить, то увидим, как на самом деле работает метод __destruct().
Хотя такие приемы выглядят очень занимательно, следует добавить нотку предостережения. Методы __call(), __destruct() и им подобные иногда называют магическими. Если вы когда-либо читали произведения жанра «фэнтези», то, наверное, знаете, что магия — это не всегда хорошо. Магия случайна и непредсказуема. Магия нарушает правила. Магия приносит скрытые расходы.
Копирование объектов с помощью метода __clone()
В PHP 4 копирование объекта выполнялось очень просто — достаточно было присвоить значение одной объектной переменной другой:
Но эта простота часто служила источником множества ошибок, поскольку копии объекта случайно «размножались» при присвоении значений переменным, вызове методов и возврате объектов. Еще больше ухудшало ситуацию то, что не существовало способа протестировать две переменные, чтобы понять, относятся ли они к одному и тому же объекту. С помощью оператора эквивалентности (==) можно было проверить идентичность значений всех полей у двух объектов либо являются ли обе переменные объектами (===). Но в результате этих проверок нельзя было понять, указывают ли обе переменные на один и тот же объект.
К счастью, мы можем контролировать то, что копируется при использовании перед объектом ключевого слова clone. Для этого следует реализовать специальный метод __clone() (обратите внимание на два символа подчеркивания, с которых начинаются имена всех встроенных методов). Метод __clone() вызывается автоматически, когда для копирования объекта используется ключевое слово clone.
При реализации метода __clone() важно понимать контекст, в котором работает данный метод. Метод __clone() работает в контексте скопированного объекта, а не исходного. Давайте добавим метод __clone() к одной из версий нашего класса Person:
Поверхностное копирование гарантирует, что значения элементарных свойств будут скопированы из старого объекта в новый. Однако свойства-объекты также будут скопированы, но по ссылке. Возможно, это не совсем то, что вы хотите, когда клонируете объект. Предположим, мы добавим к объекту Person свойство-объект Account. В этом объекте хранятся данные о состоянии счета, которые мы тоже хотим скопировать в клонированный объект. Однако при этом мы не хотим, чтобы в обоих объектах Person сохранялись ссылки на один и тот же счет:
В результате будет выведено «210».
Если мы не хотим, чтобы после выполнения операции клонирования в новом объекте осталась ссылка на старое свойство-объект, последнее нужно клонировать явно в методе __clone():
Определение строковых значений для объектов
Еще одна функция, введенная в PHP 5 явно под влиянием строго типизированных объектно-ориентированных языков наподобие Java и C# — метод __toString(). Реализовав метод __toString(), вы можете контролировать то, какую информацию будут выводить объекты при печати. Метод __toString() должен возвращать строковое значение. Этот метод вызывается автоматически, когда объект передается функции print или echo, а возвращаемое им строковое значение будет выведено на экран. Давайте добавим версию метода __toString() к минимальной реализации класса Person:
Теперь при печати объекта Person:
получим «Вася (возраст 24)».
Метод __toString() особенно полезен для записи информации в журнальные файлы (логи) и для выдачи сообщений об ошибках, а также для классов, основная задача которых — передавать информацию. Например, при выводе на печать объекта типа Exception можно выдавать краткий отчет о происшедших исключениях, реализовав в нем метод __toString().
Функции обратного вызова, анонимные функции и механизм замыканий
Несмотря на то что анонимные функции относятся не только к области объектно-ориентированного программирования, они настолько полезны, что я не мог их здесь не упомянуть. Все дело в том, что они активно используются в объектно-ориентированных приложениях наряду с функциями обратного вызова. Более того, в этой области за последнее время было сделано несколько довольно интересных открытий. Для начала давайте определим несколько классов:
Чем же так полезны функции обратного вызова? Они позволяют в процессе выполнения программы добавлять компоненту новые функциональные возможности, которые напрямую не были связаны с его первоначальной основной функциональностью. Предусмотрев, в объекте работу с функциями обратного вызова, вы тем самым позволите другим программистам расширять функциональность вашего кода, причем при таких обстоятельствах, о которых раньше вы даже и не догадывались.
Представьте себе, например, что через какое-то время пользователь класса ProcessSale захочет создать журнал продаж. Если у пользователя будет доступ к исходному коду класса, он может добавить код фиксации сделок прямо в метод sale(). Однако это не всегда удачное решение. Если этот пользователь не является владельцем пакета, в котором определен класс ProcessSale, то все его исправления будут затерты, когда выйдет его обновленная версия. И даже если он является владельцем пакета, все равно, добавлять в метод sale() дополнительные ветки кода, решающие случайные задачи, неразумно. В конечном итоге это приведет к изменению зоны ответственности класса и потенциально может снизить возможность его повторного использования в других проектах.
Несмотря на это, по счастливой случайности, я заложил в класс ProcessSale возможность обратного вызова. Ниже я создал функцию обратного вызова, которая фиксирует все сделки в журнале продаж:
Передача анонимной функции в функцию обратного вызова
Давайте еще раз проанализируем пример кода с функцией create_function(). Обратили внимание, насколько уродливо он выглядит? При помещении исполняемого кода в строку всегда возникает головная боль. Для начала вам нужно выполнить экранирование всех символов ‘$’ и ‘?’, которые встречаются в тексте программы. Более того, по мере роста тела функции обратного вызова, ее и в самом деле будет все труднее и труднее проанализировать и понять. Было бы просто замечательно, если бы существовал какой-нибудь более элегантный способ для создания таких функций. Начиная с PHP 5.3 такой способ существует! Теперь вы можете просто объявить функцию как обычно, а затем присвоить ссылку на нее переменной. И все это — в одном операторе! Ниже приведен предыдущий пример, в котором использован новый синтаксис:
Единственное отличие здесь заключается в способе создания переменной, ссылающейся на анонимную функцию. Как видите, этот код намного понятнее. Я указал в операторе присваивания ключевое слово function и не задал имя функции. Обратите внимание на то, что поскольку в операторе присваивания используется встроенная функция, то в конце блока нужно обязательно поместить точку с запятой. Конечно, если ваш код должен работать в одной из предыдущих версий PHP, вам придется продолжать использовать уродливый синтаксис с функцией create_function(). Результат работы нового фрагмента кода ничем не будет отличаться от предыдущего.
Само собой разумеется, что функции обратного вызова не обязательно должны быть анонимными. В качестве такой функции вы смело можете использовать имя обычной функции или даже ссылку на метод какого-либо объекта. Ниже приведен пример:
Здесь я создал новый класс Mailer, содержащий единственный метод doMail(). Этому методу передается объект типа Product, о котором метод выводит сообщение. При вызове метода registerCallback() я передал ему в качестве параметра массив, а не ссылку на функцию обратного вызова, как это было раньше. Первым элементом этого массива является объект типа Mailer, а вторым — строка, содержащая имя метода, который мы хотим вызвать. Помните, что в методе registerCallback() с помощью функции is_callable() выполняется проверка аргумента на предмет того, можно ли его вызвать? Данная функция достаточно интеллектуальна и распознает массивы подобного вида. Поэтому при указании функции обратного вызова в виде массива, в первом элементе такого массива должен находиться объект, содержащий вызываемый метод, а имя этого метода помещается в виде строки во второй элемент массива. Таким образом, мы успешно прошли проверку типа аргумента, и результат выполнения программы будет таким же, как и раньше.
Разумеется, что анонимную функцию можно вернуть из метода, как показано ниже:
Предположим, я хочу сделать так, чтобы метод Totalizer::warnAmount() выполнял следующее. Во-первых, я хочу, чтобы ему можно было передавать пороговое значение стоимости товаров. Во-вторых, я хочу, чтобы он подсчитывал стоимость (т.е. сумму цен) проданного товара. И когда стоимость проданного товара превысит установленный порог, функция должна выполнить некоторые действия (в нашем случае, как вы уже можете догадаться, она просто выведет соответствующее сообщение).
Чтобы анонимная функция могла воспользоваться переменными, определенными в родительской области видимости, используется ключевое слово use, как показано в примере ниже:
Использование замыканий