Php конструкторы и деструкторы
Обновлено: 17.05.2024
В предыдущей статье мы рассмотрели основные концепции класса и объектов. В этом руководстве по PHP вы изучите конструктор и деструктор в классе PHP.
Что такое конструктор и деструктор в классе PHP?
Конструктор
Как следует из названия, конструкция создает объект. Настоящее определение конструктора таково, что он инициализирует объект класса.
Как объявить конструктор в PHP?
Чтобы объявить конструктор в PHP, используйте двойное подчеркивание (__) вместе со словом конструкция. Убедитесь, что имя конструктора должно быть «конструктор».
Например
- В приведенном выше примере мы создаем конструктор, используя двойные подчеркивания.
- Мы создаем объект, который автоматически использует конструктор и инициализируем его с помощью Cat.
- Нам не нужно вызывать функцию set_name для установки имени в объекте cat.
Итак, из приведенного выше обсуждения становится ясно, что конструктор упрощает инициализацию объекта и не требует для этого никаких функций-установщиков.
Еще примеры конструктора и деструктора в PHP
- В приведенном выше примере мы создаем конструктор с двумя параметрами и инициализируем атрибуты nick_name и color класса этими параметрами.
- Мы создаем новый объект cat и передаем два параметра, требуемых конструктору. Убедитесь, что для создания объекта требуется количество параметров в соответствии с конструктором класса, к которому он принадлежит.
- После создания объекта мы протестировали его, вызвав установщики get_name и get_color класса. Он выведет имя объекта «кошка» как «кошка» и его цвет как «коричневый».
Вы можете найти ссылку на официальную документацию конструктора в PHP. здесь.
Важное понятие о конструкторе
ООП позволяет использовать механизм наследования, с помощью которого дочерний класс может расширять базовый класс или родительский класс. Мы рассмотрим его подробно, а пока нам просто нужно его описание, чтобы понять концепцию. Если дочерний класс расширяет родительский класс и хочет вызвать конструктор родительского класса в своем собственном конструкторе, просто используйте parent :: construcor_name внутри его конструктора.
Если дочерний класс не содержит своего конструктора, то конструктор базового или родительского класса наследуется как обычная функция, если не объявлен как закрытый.
Как объявить параметр по умолчанию в конструкторе?
Как вы читали выше, конструктор может иметь несколько параметров, которые предоставляются при создании объекта с его использованием. Но если вы хотите сделать параметры необязательными для предоставления при создании объекта, вы можете установить значение по умолчанию для параметра конструктора. Например.
- В приведенном выше примере $ y присвоено значение по умолчанию 0.
- Если объект $ obj = new class (2) создан, значение y по умолчанию будет установлено конструктором равным 0.
разрушитель
Основная цель деструктора - уничтожить или удалить объект из памяти после остановки выполнения программы или завершения процесса.
В PHP вам не нужно вызывать деструктор для освобождения памяти, занятой объектами, потому что он автоматически вызывает деструктор для удаления всех объектов после того, как скрипт останавливает свое выполнение.
Посмотрите на следующий пример объявления деструктора в PHP
Еще один пример деструктора
Также вы можете вызвать деструктор для выполнения некоторых задач, которые необходимо выполнить во время завершения скрипта. Например, закрытие подключений к базе данных или объектов внешнего файлового потока.
Деструкторы выглядят просто с точки зрения реализации. Однако они играют жизненно важную роль в защите памяти от утечки.
Если какой-либо объект находится в памяти после завершения сценария PHP, это вызывает утечку памяти. Это может вызвать серьезные проблемы, особенно для крупномасштабных приложений.
Вы можете найти ссылку на официальную документацию деструктора в PHP здесь.
Каждое определение класса начинается с ключевого слова class , затем следует имя класса, и далее пара фигурных скобок, которые заключают в себе определение свойств и методов этого класса.
Именем класса может быть любое слово, при условии, что оно не входит в список зарезервированных слов PHP, начинается с буквы или символа подчёркивания и за которым следует любое количество букв, цифр или символов подчёркивания. Если задать эти правила в виде регулярного выражения, то получится следующее выражение: ^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$ .
Класс может содержать собственные константы, переменные (называемые свойствами) и функции (называемые методами).
class SimpleClass
// объявление свойства
public $var = 'значение по умолчанию' ;
// объявление метода
public function displayVar () echo $this -> var ;
>
>
?>
Псевдопеременная $this доступна в том случае, если метод был вызван в контексте объекта. $this - значение вызывающего объекта.
Вызов нестатического метода статически вызывает ошибку Error . До PHP 8.0.0 это привело бы к уведомлению об устаревании, и $this не была бы определена.
class A
function foo ()
if (isset( $this )) echo '$this определена (' ;
echo get_class ( $this );
echo ")\n" ;
> else echo "\$this не определена.\n" ;
>
>
>
$a = new A ();
$a -> foo ();
$b = new B ();
$b -> bar ();
Результат выполнения данного примера в PHP 7:
Результат выполнения данного примера в PHP 8:
Для создания экземпляра класса используется директива new . Новый объект всегда будет создан, за исключением случаев, когда он содержит конструктор, в котором определён вызов исключения в случае возникновения ошибки. Рекомендуется определять классы до создания их экземпляров (в некоторых случаях это обязательно).
Если с директивой new используется строка ( string ), содержащая имя класса, то будет создан новый экземпляр этого класса. Если имя находится в пространстве имён, то оно должно быть задано полностью.
Замечание:
В случае отсутствия аргументов в конструктор класса, круглые скобки после названия класса можно опустить.
// Это же можно сделать с помощью переменной:
$className = 'SimpleClass' ;
$instance = new $className (); // new SimpleClass()
?>
Начиная с PHP 8.0.0, поддерживается использование оператора new с произвольными выражениями. Это позволяет создавать более сложные экземпляры, если выражение представлено в виде строки ( string ). Выражения должны быть заключены в круглые скобки.
В данном примере мы показываем несколько вариантов допустимых произвольных выражений, которые представляют имя класса. Пример вызова функции, конкатенации строк и константы ::class .
class ClassA extends \ stdClass <>
class ClassB extends \ stdClass <>
class ClassC extends ClassB <>
class ClassD extends ClassA <>
function getSomeClass (): string
return 'ClassA' ;
>
var_dump (new ( getSomeClass ()));
var_dump (new ( 'Class' . 'B' ));
var_dump (new ( 'Class' . 'C' ));
var_dump (new ( ClassD ::class));
?>
Результат выполнения данного примера в PHP 8:
В контексте класса можно создать новый объект через new self и new parent .
Когда происходит присвоение уже существующего экземпляра класса новой переменной, то эта переменная будет указывать на этот же экземпляр класса. То же самое происходит и при передаче экземпляра класса в функцию. Копию уже созданного объекта можно создать через её клонирование.
$instance = new SimpleClass ();
$assigned = $instance ;
$reference =& $instance ;
$instance -> var = '$assigned будет иметь это значение' ;
$instance = null ; // $instance и $reference становятся null
var_dump ( $instance );
var_dump ( $reference );
var_dump ( $assigned );
?>
Результат выполнения данного примера:
Создавать экземпляры объекта можно двумя способами:
class Test
static public function getNew ()
return new static;
>
>
class Child extends Test
<>
$obj1 = new Test ();
$obj2 = new $obj1 ;
var_dump ( $obj1 !== $obj2 );
$obj3 = Test :: getNew ();
var_dump ( $obj3 instanceof Test );
$obj4 = Child :: getNew ();
var_dump ( $obj4 instanceof Child );
?>
Результат выполнения данного примера:
Обратиться к свойству или методу только что созданного объекта можно с помощью одного выражения:
Результатом выполнения данного примера будет что-то подобное:
Замечание: До PHP 7.1 аргументы не имели значения, если не определена функция конструктора.
Свойства и методы
Свойства и методы класса живут в разделённых "пространствах имён", так что возможно иметь свойство и метод с одним и тем же именем. Ссылки как на свойства, так и на методы имеют одинаковую нотацию, и получается, что получите вы доступ к свойству или же вызовете метод - определяется контекстом использования.
public function bar () return 'метод' ;
>
>
$obj = new Foo ();
echo $obj -> bar , PHP_EOL , $obj -> bar (), PHP_EOL ;
Результат выполнения данного примера:
Это означает, что вызвать анонимную функцию, присвоенную переменной, напрямую не получится. Вместо этого свойство должно быть назначено, например, переменной. Можно вызвать такое свойство напрямую, заключив его в скобки.
public function __construct () $this -> bar = function() return 42 ;
>;
>
>
echo ( $obj -> bar )(), PHP_EOL ;
Результат выполнения данного примера:
extends
Класс может наследовать константы, методы и свойства другого класса используя ключевое слово extends в его объявлении. Невозможно наследовать несколько классов, один класс может наследовать только один базовый класс.
Наследуемые константы, методы и свойства могут быть переопределены (за исключением случаев, когда метод или константа класса объявлены как final) путём объявления их с теми же именами, как и в родительском классе. Существует возможность доступа к переопределённым методам или статическим свойствам путём обращения к ним через parent::
Замечание: Начиная с PHP 8.1.0, константы можно объявлять окончательными (final).
class ExtendClass extends SimpleClass
// Переопределение метода родителя
function displayVar ()
echo "Расширенный класс\n" ;
parent :: displayVar ();
>
>
$extended = new ExtendClass ();
$extended -> displayVar ();
?>
Результат выполнения данного примера:
Правила совместимости сигнатуры
При переопределении метода его сигнатура должна быть совместима с родительским методом. В противном случае выдаётся фатальная ошибка или, до PHP 8.0.0, генерируется ошибка уровня E_WARNING . Сигнатура является совместимой, если она соответствует правилам контравариантности, делает обязательный параметр необязательным и если какие-либо новые параметры являются необязательными. Это известно как принцип подстановки Барбары Лисков или сокращённо LSP. Правила совместимости не распространяются на конструктор и сигнатуру private методов, они не будут выдавать фатальную ошибку в случае несоответствия сигнатуры.
class Base
public function foo ( int $a ) echo "Допустимо\n" ;
>
>
class Extend1 extends Base
function foo ( int $a = 5 )
parent :: foo ( $a );
>
>
class Extend2 extends Base
function foo ( int $a , $b = 5 )
parent :: foo ( $a );
>
>
$extended1 = new Extend1 ();
$extended1 -> foo ();
$extended2 = new Extend2 ();
$extended2 -> foo ( 1 );
Результат выполнения данного примера:
Следующие примеры демонстрируют, что дочерний метод, который удаляет параметр или делает необязательный параметр обязательным, несовместим с родительским методом.
class Base
public function foo ( int $a = 5 ) echo "Допустимо\n" ;
>
>
class Extend extends Base
function foo ()
parent :: foo ( 1 );
>
>
Результат выполнения данного примера в PHP 8 аналогичен:
class Base
public function foo ( int $a = 5 ) echo "Допустимо\n" ;
>
>
class Extend extends Base
function foo ( int $a )
parent :: foo ( $a );
>
>
Результат выполнения данного примера в PHP 8 аналогичен:
Переименование параметра метода в дочернем классе не является несовместимостью сигнатуры. Однако это не рекомендуется, так как приведёт к Error во время выполнения, если используются именованные аргументы.
class A public function test ( $foo , $bar ) <>
>
class B extends A public function test ( $a , $b ) <>
>
// Передача параметров согласно контракту A::test()
$obj -> test ( foo : "foo" , bar : "bar" ); // ОШИБКА!
Результатом выполнения данного примера будет что-то подобное:
::class
Ключевое слово class используется для разрешения имени класса. Чтобы получить полное имя класса ClassName , используйте ClassName::class . Обычно это довольно полезно при работе с классами, использующими пространства имён.
Результат выполнения данного примера:
Замечание:
Разрешение имён класса с использованием ::class происходит на этапе компиляции. Это означает, что на момент создания строки с именем класса автозагрузки класса не происходит. Как следствие, имена классов раскрываются, даже если класс не существует. Ошибка в этом случае не выдаётся.
Результат выполнения данного примера:
Начиная с PHP 8.0.0, константа ::class также может использоваться для объектов. Это разрешение происходит во время выполнения, а не во время компиляции. То же самое, что и при вызове get_class() для объекта.
Результат выполнения данного примера:
Методы и свойства Nullsafe
Начиная с PHP 8.0.0, к свойствам и методам можно также обращаться с помощью оператора "nullsafe": ?-> . Оператор nullsafe работает так же, как доступ к свойству или методу, как указано выше, за исключением того, что если разыменование объекта выдаёт null , то будет возвращён null , а не выброшено исключение. Если разыменование является частью цепочки, остальная часть цепочки пропускается.
Аналогично заключению каждого обращения в is_null() , но более компактный.
// Начиная с PHP 8.0.0, эта строка:
$result = $repository ?-> getUser ( 5 )?-> name ;
// Эквивалентна следующему блоку кода:
if ( is_null ( $repository )) $result = null ;
> else $user = $repository -> getUser ( 5 );
if ( is_null ( $user )) $result = null ;
> else $result = $user -> name ;
>
>
?>
Замечание:
Оператор nullsafe лучше всего использовать, когда null считается допустимым и ожидаемым значением для возвращаемого свойства или метода. Для индикации ошибки предпочтительнее выбрасывать исключение.
User Contributed Notes 13 notes
I was confused at first about object assignment, because it's not quite the same as normal assignment or assignment by reference. But I think I've figured out what's going on.
First, think of variables in PHP as data slots. Each one is a name that points to a data slot that can hold a value that is one of the basic data types: a number, a string, a boolean, etc. When you create a reference, you are making a second name that points at the same data slot. When you assign one variable to another, you are copying the contents of one data slot to another data slot.
Now, the trick is that object instances are not like the basic data types. They cannot be held in the data slots directly. Instead, an object's "handle" goes in the data slot. This is an identifier that points at one particular instance of an obect. So, the object handle, although not directly visible to the programmer, is one of the basic datatypes.
What makes this tricky is that when you take a variable which holds an object handle, and you assign it to another variable, that other variable gets a copy of the same object handle. This means that both variables can change the state of the same object instance. But they are not references, so if one of the variables is assigned a new value, it does not affect the other variable.
// Assignment of an object
Class Object public $foo = "bar" ;
>;
$objectVar = new Object ();
$reference =& $objectVar ;
$assignment = $objectVar
//
// $objectVar --->+---------+
// |(handle1)----+
// $reference --->+---------+ |
// |
// +---------+ |
// $assignment -->|(handle1)----+
// +---------+ |
// |
// v
// Object(1):foo="bar"
//
?>
$assignment has a different data slot from $objectVar, but its data slot holds a handle to the same object. This makes it behave in some ways like a reference. If you use the variable $objectVar to change the state of the Object instance, those changes also show up under $assignment, because it is pointing at that same Object instance.
$objectVar -> foo = "qux" ;
print_r ( $objectVar );
print_r ( $reference );
print_r ( $assignment );
//
// $objectVar --->+---------+
// |(handle1)----+
// $reference --->+---------+ |
// |
// +---------+ |
// $assignment -->|(handle1)----+
// +---------+ |
// |
// v
// Object(1):foo="qux"
//
?>
But it is not exactly the same as a reference. If you null out $objectVar, you replace the handle in its data slot with NULL. This means that $reference, which points at the same data slot, will also be NULL. But $assignment, which is a different data slot, will still hold its copy of the handle to the Object instance, so it will not be NULL.
$objectVar = null ;
print_r ( $objectVar );
print_r ( $reference );
print_r ( $assignment );
PHP 5 позволяет объявлять методы-конструкторы. Классы, в которых объявлен метод-конструктор, будут вызывать этот метод при каждом создании нового объекта, так что это может оказаться полезным, например, для инициализации какого-либо состояния объекта перед его использованием.
Замечание: Конструкторы в классах-родителях не вызываются автоматически, если класс-потомок определяет собственный конструктор. Чтобы вызвать конструктор, объявленный в родительском классе, следует обратиться к методу parent::__construct() внутри конструктора класса-потомка. Если в классе-потомке не определен конструктор, то он может наследоваться от родительского класса как обычный метод (если он не определен как приватный).
class BaseClass function __construct () print "Конструктор класса BaseClass\n" ;
>
>
class SubClass extends BaseClass function __construct () parent :: __construct ();
print "Конструктор класса SubClass\n" ;
>
>
class OtherSubClass extends BaseClass // inherits BaseClass's constructor
>
// In BaseClass constructor
$obj = new BaseClass ();
// In BaseClass constructor
// In SubClass constructor
$obj = new SubClass ();
// In BaseClass constructor
$obj = new OtherSubClass ();
?>
В целях обратной совместимости, если PHP 5 не может обнаружить объявленный метод __construct() и этот метод не наследуется от родительских классов, то вызов конструктора произойдет по устаревшей схеме, через обращение к методу, имя которого соответствует имени класса. Может возникнуть только одна проблема совместимости старого кода, если в нём присутствуют классы с методами __construct(), использующиеся для других целей.
В отличие от других методов, PHP не будет генерировать ошибку уровня E_STRICT , если __construct() будет перекрыт методом с другими параметрами, отличными от тех, которые находятся в родительском __construct().
Начиная с версии PHP 5.3.3, методы с именами, совпадающими с последним элементом имени класса, находящимся в пространстве имен, больше не будут считаться конструкторами. Это изменение не влияет на классы, не находящиеся в пространстве имен.
namespace Foo ;
class Bar public function Bar () // конструктор в версиях PHP 5.3.0-5.3.2
// обычный метод, начиная с версии PHP 5.3.3
>
>
?>
Деструкторы
PHP 5 предоставляет концепцию деструкторов, сходную с теми, что применяются в других ОО языках, таких, как C++. Деструктор будет вызван при освобождении всех ссылок на определенный объект или при завершении скрипта (порядок выполнения деструкторов не гарантируется).
class MyDestructableClass function __construct () print "Конструктор\n" ;
$this -> name = "MyDestructableClass" ;
>
function __destruct () print "Уничтожается " . $this -> name . "\n" ;
>
>
$obj = new MyDestructableClass ();
?>
Как и в случае с конструкторами, деструкторы, объявленные в родительском классе, не будут вызваны автоматически. Для вызова деструктора, объявленном в классе-родителе, следует обратиться к методу parent::__destruct() в теле деструктора-потомка. Также класс-потомок может унаследовать деструктор из родительского класса, если он не определен в нем.
Деструктор будет вызван даже в том случае, если скрипт был остановлен с помощью функции exit() . Вызов exit() в деструкторе предотвратит запуск всех последующих функций завершения.
Замечание:
Попытка бросить исключение в деструкторе (вызванного во время завершения скрипта) влечет за собой фатальную ошибку.
Конструкторы представляют специальные методы, которые выполняются при создании объекта и служат для начальной инициализации его свойств. Для создания конструктора надо объявить функцию с именем __construct (с двумя подчеркиваниями впереди):
Функция конструктора в данном случае принимает два параметра. Их значения передаются свойствам класса. И теперь чтобы создать объект, нам надо передать значения для соответствующих параметров:
Параметры по умолчанию
Чтобы сделать конструктор более гибким, мы можем обозначить один или несколько параметров в качестве необязательных. Тогда при создании объекта необязательно указывать все параметры. Например, изменим конструктор следующим образом:
Таким образом, если не будут заданы параметры, вместо них будут использоваться значения "Том" и 36. И теперь мы можем создать объект Person несколькими способами:
Объявление свойств через конструктор
Начиная с версии PHP 8 в языке появилась возможность определить свойства через список параметров конструктора. Любой параметр конструктора, который имеет модификатор доступа, например, public , будет автоматически представлять новое свойство.
Например, определим свойства name и age напрямую через параметры конструктора:
Хотя в данном случае в классе явным образом не определены свойства name и age, но поскольку в списке параметров конструктора заданы параметры с такими именами и с модификатором доступа (в данном случае public ), то у класса автоматически создаются подобные переменные.
Можно сочетать оба способа объявления переменных:
При подобном объявлении свойств также можно передавать им значения по умолчанию:
Деструкторы
Деструкторы служат для освобождения ресурсов, используемых программой - для освобождения открытых файлов, открытых подключений к базам данных и т.д. Деструктор объекта вызывается самим интерпретатором PHP после потери последней ссылки на данный объект в программе.
Деструктор определяется с помощью функции __destruct (два подчеркивания впереди):
Функция деструктора определяется без параметров, и когда на объект не останется ссылок в программе, он будет уничтожен, и при этом будет вызван деструктор.
При создании программы на PHP и отдельных ее блоков нам вполне может хватить той функциональности, которую представляют функции. Однако PHP имеет и другие возможности по созданию программ, которые представляет объектно-ориентированное программирование. В ряде случаев программы, использующие ООП, проще в понимании, их легче поддерживать и изменять.
Ключевыми понятиями парадигмы ООП являются понятия "класс" и "объект". Описанием объекта является класс, а объект представляет экземпляр этого класса. Можно провести следующую аналогию: например, у каждого человека есть имя, определенный возраст, вес, какие-то другие параметры. То есть некоторый шаблон, который содержит набор параметров человека - этот шаблон можно назвать классом. А реально же существующий человек с конкретным именем, возрастом, весом и т.д. является объектом или экземпляром этого класса.
Для создания класса в PHP используется ключевое слово class , после которого идет название класса и фигурные скобки <> - блок кода класса. Например, новый класс, представляющий пользователя:
Чтобы создать объект класса Person, применяется ключевое слово new :
В данном случае переменная $person является объектом класса Person . С помощью функции print_r() можно вывести содержимое объекта, как и в случае с массивами.
При этом неважно, определяется класс до или после создания объекта. Например, мы можем сначала определить переменную класса, а потом определить этот класс:
Свойства и методы
Класс может содержать переменные, которые описывают какие-то признаки объекта, его состояние и которые еще назывют свойствами или атрибутам. И также класс класс может содержать функции, которые еще назвают методами и которые определяют его поведение.
Так, добавим в класс Person несколько свойств и методов:
Здесь класс Person содержит два свойства: $name и $age . Свойства объявляются как обычные переменные, перед которыми стоит модификатор доступа - в данном случае модификатор public .
Методы представляют обычные функции, которые выполняют определенные действия. Здесь функция hello() просто выводит приветствие.
После создания объекта класса Person:
Мы можем через имя переменной класса обращаться к его свойствам и методам. Чтобы обратиться к свойствам и методам объекта применяется оператор доступа -> . Например, установить значения свойств:
Или получить значение (например, присвоить его переменной):
Или вызвать методы объекта:
В итоге мы получим следующий вывод браузера:
При этом свойствам можно задать в классе некоторые начальные значения:
Ключевое слово this
Для обращения к свойствам и методам объекта внутри его класса применяется ключевое слово this . Например, определим в классе метод для вывода информации об объекте:
Для обращения к полям и методам внутри класса также применяется оператор доступа -> , перед которым идет $this . Причем это $this указывает именно на текущий объект. Что это значит в практическом плане? Например:
$this фактически будет указывать на переменную $tom . Тогда как при вызове
$this будет указывать на переменную $bob .
Сравнение объектов
При сравнении объектов классов следует принимать во внимание ряд особенностей. В частности, при использовании оператора равенства == два объекта считаются равными, если они представляют один и тот же класс и их свойства имеют одинаковые значения.
А при использовании оператора эквивалентности === оба объекта считаются равными, если обе переменных классах указывают на один и тот же экземпляр класса.
Рассмотрим на примере:
Здесь сравниваются две переменных - $tom и $tomas. Они представляют один и тот же класс Person, и их свойства имеют одни и те же значения. Однако они представляют разные объекты. Поэтому при сравнении оператор == возвратит true , а оператор === - false :
Возьмем другой пример, когда обе переменных представляют один и тот же объект:
Здесь объект класса Person создается только один раз: $person = new Person(); . И затем обе переменных $tom и $tomas будут указывать на этот объект. При этом не имеет значения, для какой именно переменной мы устанавливаем свойства. Так как в реальности это будет один и тот же объект. В итоге и оператор == , и оператор === при сравнении возвратят true
Читайте также: