Что такое ооп в php
Руководство по ООП в PHP
В объектно-ориентированном программировании объект обрабатывается так же, как ссылки или указатели. Это значит, что каждая новая переменная содержит ссылку на объект, а не копию всего объекта.
Что такое ООП в PHP?
Поскольку термин объектно-ориентированное программирование начинается со слова « объект «, то мы можем сказать, что это особый тип программирования, при котором создаются и используются объекты.
Вот объяснение ООП в PHP для чайников. Посмотрите на мир вокруг нас, он полон объектов. Солнце, луна, автомобили, деревья, дома и т.д. и т.п. Все это объекты, они имеют атрибуты и функции. В процессе мышления мы оперируем объектами. Когда мы говорим об автомобиле, вы не думаете о колесах, двигателе, сиденьях, дверях, вы думаете о машине, как о вещи, которой она является. Проще говоря, вы думаете с точки зрения субъекта или объекта. Объектная ориентация — это представление в программировании элементов как объектов.
Автомобиль является объектом. Он имеет атрибуты цвета, размера, веса и функцию перемещения. Любой объект без функционала будет бесполезным. В ООП программист использует объекты; каждый объект имеет некоторые атрибуты и функции. В целом программирование сводится к построению модулей с помощью объектов.
Простое определение объектно-ориентированного программирования
Объектно-ориентированное программирование — это программирование на основе объектов, содержащих данные ( атрибуты ) и методы ( функционал ), которые обрабатывают эти данные. Объекты — это тип данных, определенных программистом, и взаимодействия между различными объектами также определяется программистом.
Другими словами, ООП позволяет программисту группировать аналогичные задачи в классы, класс может содержать данные и функции для доступа к этим данным, связанные друг с другом.
Основы ООП в PHP помогают разработать более простой в обслуживании и управлении код. Чем более чистым и читаемым является код, тем больше шансов многократно использовать его. В результате к системе могут быть применены шаблоны проектирования. В ООП модули создаются и используются в соответствии с требованиями. С помощью объектно-ориентированного программирования на PHP мы можем создавать приложения для сайтов, которые имеют модульную структуру.
Важные термины руководства по ООП в PHP
Класс
В ООП в PHP класс — это тип данных, определенный программистом. Класс содержит данные и функции для работы с этими данными. Данные и функции имеют идентификатор доступа privat. Это означает, что они не видимы за пределами класса. Класс представляет собой шаблон или образец, с которого можно сделать столько копий или экземпляров, сколько необходимо.
Объект
Объект также известен как экземпляр. Когда устанавливается экземпляр класса, создается объект. Если класс — это образец, то объект — это конечное изделие, созданное с помощью образца. После того, как класс был определен, из него может быть создано множество объектов.
Переменная-член
Переменные, определенные в классе, называются переменными-членами. На самом деле это данные, содержащиеся в этом классе, они могут быть изменены функциями только этого класса. Обычно переменные-члены видимы только для этого класса и скрыты от других классов.
Функция-член
Функции, определенные в классе, называются функциями-членами. Они также не видны для других классов. Они используются для изменения переменных-членов, для доступа к данным объекта.
Конструктор
Конструктор — это особый тип функции-члена. Когда устанавливается класс, создается объект, эта функция вызывается автоматически и присваивает начальные значения переменным класса.
Деструктор
Это особый тип функции, которая вызывается автоматически, когда объект удаляется.
Наследование
В PHP 5 ООП наследование – это процесс, при котором класс ( подкласс ) получает все атрибуты и функции другого класса (суперкласса).
Суперкласс
Также известен как базовый или родительский класс — наследуется одним или несколькими подклассами.
Подкласс
Дочерний или производный класс, подкласс наследуется от суперкласса.
Полиморфизм
Инкапсуляция
Одна из важнейших концепций объектно-ориентированного программирования. Данные и функции, которые работают с этими данными, связываются между собой и не видны другим функциям.
Абстракция
Абстракция означает, что детали реализации функций или классов не видны.
Перезагрузка
Классы и объекты
Класс и объект широко используются в объектно-ориентированном программировании как термины-синонимы, однако по своей сути они сильно отличаются друг от друга. Класс представляет собой шаблон, образец или форму, а объект является продуктом или деталью, отлитой из этого конкретного шаблона или формы.
Возьмем, к примеру, дом. Класс является основой для дома; он имеет размеры, форму, количество дверей, проходов и т.д. Но это только проект, а не сам дом. Когда построен физический дом на основе информации, содержащейся в плане, то он является объектом.
До этого объект был кучей дерева, кирпича, цемента и т.д., из которых в соответствии с информацией из плана был построен дом или объект:
Класс в PHP ООП — это план или шаблон, по которому устанавливается экземпляр класса, создается объект. После того, как был создан класс, мы можем создать столько объектов, сколько захотим. На рисунке, приведенном выше, из одного класса ( плана ) были созданы пять объектов ( домов ). Объект всегда будет соответствовать инструкциям, приведенным в классе, используемом для его создания.
Преимущества ООП в PHP
Улучшение архитектуры и более чистый код
Объектно-ориентированный PHP лучше каталогизирован и легко упаковывается, что позволяет задать оптимальную архитектуру. Обычно каждый класс сохраняется в отдельном файле. Процедурные языки характеризуются сложным кодом, который очень трудно читать или понимать. В ООП за счет реализации объектов, содержащих частные данные с четким определением связей между объектами, код является читаемым и чистым.
Повторное использование
Объектно-ориентированное программирование делает код повторно используемым. Объекты, созданные однажды, могут быть использованы снова и снова. Программы могут быть построены путем объединения рабочих модулей вместо того, чтобы писать все с нуля. Это экономит время и повышает производительность.
Простота в обслуживании и обновлении
Объекты имеют собственные данные и функции, вся их структура компактна и сжата, что позволяет легко вносить в код изменения. С помощью обычного процедурного программирования создается код, в котором очень трудно найти точку для внесения изменений. В ООП PHP мы можем добавить новое свойство, а затем добавлять связанные методы для управления этим свойством.
Инкапсуляция
Инкапсуляция означает, что значения переменных объекта не видны извне, следовательно, реализуется безопасность данных. Но если возникает необходимость, доступ к данным может быть получен с помощью модификаторов доступа. Для создания безопасных программ данные и функции-члены в классе могут быть скрыты от других классов. Когда объект создан, для его использования не нужна информация о его реализации.
Наследование
Наследующий класс получает все характеристики родительского класса, а затем в него добавляются его собственные характеристики. Подкласс наследует переменные и методы суперкласса. Мы можем расширить использование уже существующих классов, а также убрать ненужный код.
Меньше ошибок
Потому что существуют четко определенные объекты, с данными и privat функциями. Существуют четкие направления связей, нет блуждающие данных или методов. Поэтому в ООП намного меньше ошибок. Следовательно, объектно-ориентированное программирование является оптимальным решением для новых систем.
Это руководством по ООП в PHP является свободным и полным источником, с помощью которого вы сможете изучить все необходимые приемы.
Что такое ооп в php
Класс может содержать собственные константы, переменные (называемые свойствами) и функции (называемые методами).
Пример #1 Простое определение класса
Результат выполнения данного примера в PHP 7:
Результат выполнения данного примера в PHP 8:
Если с директивой new используется строка ( string ), содержащая имя класса, то будет создан новый экземпляр этого класса. Если имя находится в пространстве имён, то оно должно быть задано полностью.
В случае отсутствия аргументов в конструктор класса, круглые скобки после названия класса можно опустить.
Пример #3 Создание экземпляра класса
Начиная с PHP 8.0.0, поддерживается использование оператора new с произвольными выражениями. Это позволяет создавать более сложные экземпляры, если выражение представлено в виде строки ( string ). Выражения должны быть заключены в круглые скобки.
Пример #4 Создание экземпляра с использованием произвольного выражения
class ClassA extends \ stdClass <>
class ClassB extends \ stdClass <>
class ClassC extends ClassB <>
class ClassD extends ClassA <>
function getSomeClass (): string
<
return ‘ClassA’ ;
>
Результат выполнения данного примера в PHP 8:
Когда происходит присвоение уже существующего экземпляра класса новой переменной, то эта переменная будет указывать на этот же экземпляр класса. То же самое происходит и при передаче экземпляра класса в функцию. Копию уже созданного объекта можно создать через её клонирование.
Пример #5 Присваивание объекта
Результат выполнения данного примера:
Создавать экземпляры объекта можно двумя способами:
Пример #6 Создание новых объектов
class Test
<
static public function getNew ()
<
return new static;
>
>
class Child extends Test
<>
Результат выполнения данного примера:
Обратиться к свойству или методу только что созданного объекта можно с помощью одного выражения:
Пример #7 Доступ к свойствам/методам только что созданного объекта
Результатом выполнения данного примера будет что-то подобное:
Замечание: До PHP 7.1 аргументы не имели значения, если не определена функция конструктора.
Свойства и методы
Пример #8 Доступ к свойству vs. вызов метода
public function bar () <
return ‘метод’ ;
>
>
Результат выполнения данного примера:
Это означает, что вызвать анонимную функцию, присвоенную переменной, напрямую не получится. Вместо этого свойство должно быть назначено, например, переменной. Можно вызвать такое свойство напрямую, заключив его в скобки.
Пример #9 Вызов анонимной функции, содержащейся в свойстве
Результат выполнения данного примера:
extends
Класс может наследовать константы, методы и свойства другого класса используя ключевое слово extends в его объявлении. Невозможно наследовать несколько классов, один класс может наследовать только один базовый класс.
Наследуемые константы, методы и свойства могут быть переопределены (за исключением случаев, когда метод или константа класса объявлены как final) путём объявления их с теми же именами, как и в родительском классе. Существует возможность доступа к переопределённым методам или статическим свойствам путём обращения к ним через parent::
Замечание: Начиная с PHP 8.1.0, константы можно объявлять окончательными (final).
Пример #10 Простое наследование классов
class ExtendClass extends SimpleClass
<
// Переопределение метода родителя
function displayVar ()
<
echo «Расширенный класс\n» ;
parent :: displayVar ();
>
>
Результат выполнения данного примера:
Правила совместимости сигнатуры
Пример #11 Совместимость дочерних методов
Результат выполнения данного примера:
Следующие примеры демонстрируют, что дочерний метод, который удаляет параметр или делает необязательный параметр обязательным, несовместим с родительским методом.
Пример #12 Фатальная ошибка, когда дочерний метод удаляет параметр
class Extend extends Base
<
function foo ()
<
parent :: foo ( 1 );
>
>
Результат выполнения данного примера в PHP 8 аналогичен:
Пример #13 Фатальная ошибка, когда дочерний метод делает необязательный параметр обязательным.
Результат выполнения данного примера в PHP 8 аналогичен:
Переименование параметра метода в дочернем классе не является несовместимостью сигнатуры. Однако это не рекомендуется, так как приведёт к Error во время выполнения, если используются именованные аргументы.
Пример #14 Ошибка при использовании именованных аргументов и параметров, переименованных в дочернем классе
Результатом выполнения данного примера будет что-то подобное:
::class
Пример #15 Разрешение имени класса
namespace NS <
class ClassName <
>
Результат выполнения данного примера:
Разрешение имён класса с использованием ::class происходит на этапе компиляции. Это означает, что на момент создания строки с именем класса автозагрузки класса не происходит. Как следствие, имена классов раскрываются, даже если класс не существует. Ошибка в этом случае не выдаётся.
Пример #16 Отсутствует разрешение имени класса
Результат выполнения данного примера:
Начиная с PHP 8.0.0, константа ::class также может использоваться для объектов. Это разрешение происходит во время выполнения, а не во время компиляции. То же самое, что и при вызове get_class() для объекта.
Пример #17 Разрешение имени объекта
Результат выполнения данного примера:
Методы и свойства Nullsafe
Пример #18 Оператор Nullsafe
Оператор nullsafe лучше всего использовать, когда null считается допустимым и ожидаемым значением для возвращаемого свойства или метода. Для индикации ошибки предпочтительнее выбрасывать исключение.
User Contributed Notes 12 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.
Объектно ориентированный PHP для начинающих
Russian (Pусский) translation by Sergey Zhuk (you can also view the original English article)
Понимание объектно ориентированного программирования
Одним из основных преимуществ программирования по принципу DRY является то, что если в вашей программе изменяется часть информации, обычно требуется только одно изменение для обновления кода. Одним из самых больших кошмаров для разработчиков является поддержание кода, в котором данные объявляются снова и снова, а это означает, что любые изменения в программе становятся похожими на бесконечную игру Where’s Waldo?
ООП пугает многих разработчиков, потому что он вводит новый синтаксис и, на первый взгляд, выглядит гораздо более сложным, чем простой процедурный или встроенный код. Однако при ближайшем рассмотрении ООП на самом деле является очень наглядным и, в конечном счете, более простым подходом к программированию.
Понимание объекты и классы
Прежде чем вы сможете проникнуть в тонкости ООП, необходимо базовое понимание различий между объектами и классами. В этом разделе будут рассмотрены строительные блоки классов, их различные возможности и некоторые виды их использования.
Узнаем различия между объектами и классами
Когда разработчики начинают говорить об объектах и классах, то они кажутся взаимозаменяемыми. Хотя на самом деле это не так.
Сразу же у нас возникает путаница в ООП: опытные разработчики начинают говорить об объектах и классах, и они кажутся взаимозаменяемыми. Это не так, хотя разницу на первый взгляд и тяжело уловить.
Класс, например, это как проект для дома. Он определяет форму дома на бумаге, при этом отношения между различными частями дома так же четко определены и спланированы, хотя дома еще не существует.
Таким образом, объект подобен фактическому дому, построенному в соответствии с этим планом. Данные, хранящиеся в объекте, подобны дереву, проводам и бетону, которые составляют дом: не будучи собранными в соответствии с планом, это всего лишь куча материала. Однако, когда все это объединяется, это становится организованным и полезным домом.
Классы образуют структуру данных и действия, которые затем используют эту информацию для создания объектов. В один и тот же момент времени из одного и того же класса могут быть построены более одного объекта, каждый из которых не зависит от других. Продолжая нашу конструктивную аналогию, она похожа на то, как можно построить целое подразделение по одному и тому же проекту: 150 разных домов, которые все выглядят одинаково, но имеют разные
семьи и декорации внутри.
Структурирование классов
После создания класса новый экземпляр может быть создан и сохранен в переменной с использованием ключевого слова new :
Чтобы увидеть содержимое класса, используйте var_dump ():
Попробуйте выполнить этот процесс, разместив весь предыдущий код в новом файле test.php в [локальной] папке для тестирования:
В своей простейшей форме вы только что завершили свой первый ООП-скрипт.
Определение свойств класса
Для добавления данных в класс используются свойства или переменные класса. Они работают точно так же, как и обычные переменные, за исключением того, что они привязаны к объекту и поэтому могут быть доступны только с помощью объекта.
Ключевое слово public определяет видимость свойства, о котором вы узнаете чуть позже в этой главе. Затем свойство присваивается с использованием стандартного синтаксиса переменных и присваивается значение (хотя свойствам классов не требуется начальное значение).
Чтобы прочитать это свойство и вывести его в браузер, укажите объект, с которого следует читать, и свойство, которое нужно прочитать:
Теперь перезагрузка вашего браузера выводит следующее:
Определение методов класса
Методы являются специфичными для класса функциями. Отдельные действия, которые объект сможет выполнить, определены внутри класса как методы.
Перезагрузите браузер, и вы увидите следующее:
«Сила ООП становится очевидной при использовании нескольких экземпляров
одного класса.»
Когда вы загружаете результаты в свой браузер, они отобразят следующее:
Как вы можете видеть, ООП хранит объекты как отдельные сущности, что позволяет легко разделять различные фрагменты кода на небольшие связанные пакеты.
Волшебные методы в ООП
Чтобы упростить использование объектов, PHP также предоставляет ряд магических методов или специальных методов, вызываемых, когда определенные общие действия происходят внутри объектов. Это позволяет разработчикам выполнять ряд полезных задач с относительной легкостью.
Использование конструкторов и деструкторов
Примечание. __CLASS__ возвращает имя класса, в котором оно вызывается; Это то, что известно как волшебная константа. Существует несколько доступных магических констант, о которых вы можете прочитать в руководстве по PHP.
Перезагрузка файла в вашем браузере приведет к следующему результату:
Вывести сообщение, когда объект уничтожен, определяя магический метод
__destruct() в MyClass :
При определенном деструкторе перезагрузка тестового файла приводит к следующему выводу:
«Когда достигнут конец файла, PHP автоматически освобождает все ресурсы».
Чтобы явно вызвать деструктор, вы можете уничтожить объект, используя
функцию unset() :
Теперь при загрузке в вашем браузере результат будет выглядеть следующим образом:
Преобразование в строку
Без __toString() попытка вывода объекта в виде строки приводит к фатальной ошибке. Попытка использовать echo для вывода объекта без использования магического метода:
Это приводит к следующему результату:
Чтобы избежать этой ошибки, добавим метод __toString() :
В этом случае попытка преобразовать объект в строку приведет к вызову метода getProperty( ). Загрузите тестовый скрипт в свой браузер, чтобы увидеть результат:
Совет. В дополнение к магическим методам, обсуждаемым в этом разделе, доступно еще несколько других. Полный список магических методов приведен на странице руководства PHP.
Использование наследования
После перезагрузки тестового файла в вашем браузере выводится следующее:
Перезапись унаследованных свойств и методов
Чтобы изменить поведение существующего свойства или метода в новом классе, вы можете просто перезаписать его, объявив его снова в новом классе:
Это изменяет вывод в браузере на:
Сохранение оригинальной функциональности метода при перезаписи методов
Чтобы добавить новые функции к унаследованному методу, сохранив исходный метод нетронутым, используйте ключевое слово parent с оператором разрешения области видимости ( :: ):
Это выведет результат как родительского конструктора, так и конструктора нового класса:
Указание видимости свойств и методов
«Для дополнительного контроля над объектами методам и свойствам указывается их видимость.»
Публичные свойства и методы
Все методы и свойства, которые вы использовали до сих пор, были общедоступными. Это означает, что к ним можно получить доступ в любом месте, как внутри класса, так и извне.
Защищенные свойства и методы
Объявите метод getProperty() как защищенный в MyClass и попытайтесь получить к нему доступ непосредственно извне класса:
При попытке запустить этот сценарий появляется следующая ошибка:
Теперь создайте новый метод в MyOtherClass для вызова метода getProperty() :
Это приведет к желаемому результату:
Приватные свойства и методы
Чтобы продемонстрировать это, объявите getProperty() как private в MyClass и попытайтесь вызвать callProtected() из
MyOtherClass :
Перезагрузите браузер, и появится следующая ошибка:
Статические свойства и методы
«Одним из основных преимуществ использования статических свойств является то, что они сохраняют свои значения в течение всего срока действия скрипта».
Когда вы загружаете этот скрипт в своем браузере, выдается следующее:
Комментирование с помощью DocBlocks
Стиль комментирования DocBlock является широко распространенным
методом документирования классов».
Хотя это не официальная часть ООП, стиль комментирования DocBlock является широко распространенным методом документирования классов. Помимо предоставления стандарта для
разработчиков, используемым при написании кода, он также был принят многими из самых популярных наборов разработчика программного обеспечения (SDK), таких как Eclipse и NetBeans, и будет использоваться ими для генерации подсказок кода.
DocBlock определяется с помощью комментария блока, который начинается с дополнительной звездочки:
Реальная сила DocBlocks проявляется с возможностью использовать теги, которые начинаются с символа at ( @ ), за которым сразу следует имя тега и значение тега. Теги DocBlock позволяют разработчикам определять авторов файла, лицензию на класс, информацию о свойствах или методах и другую полезную информацию.
Наиболее часто используемые теги:
Пример класса, прокомментированного с помощью DocBlocks, может выглядеть так:
Когда вы просматриваете предыдущий класс, преимущества DocBlock становятся очевидны: все четко определено, так что следующий разработчик может использовать код и никогда не задаваться вопросом, что делает фрагмент кода или что он должен содержать.
Сравнение объектно-ориентированного и процедурного кода
На самом деле нет правильного и неправильного способа написания кода. При этом в этом разделе излагается весомый аргумент в пользу применения объектно-ориентированного подхода при разработке программного обеспечения, особенно в крупных приложениях.
Причина 1: Простота внедрения
«Хотя вначале это может быть непростой задачей, ООП действительно обеспечивает более простой подход к работе с данными».
Хотя вначале это может быть непростой задачей, ООП действительно обеспечивает более простой подход к работе с данными. Поскольку объект может хранить данные внутри себя, нет необходимости передавать переменны от функции к функции для правильной работы.
Кроме того, поскольку одновременно могут существовать несколько экземпляров одного и того же класса, работа с большими наборами данных становится гораздо проще. Например, представьте, что в файле есть информация двух людей. Нам нужны имена, профессии и возраст.
Процедурный подход
Вот процедурный подход к нашему примеру:
При выполнении код выводит следующее:
Хотя этот код не обязательно плохой, в процессе кодирования нужно помнить о многом. Массив атрибутов измененного человека должен быть передан и возвращен из каждого вызова функции, что оставляет место для ошибок.
Чтобы упростить этот пример, было бы желательно оставить как можно данных меньше разработчику. Необходимо передать только абсолютно необходимую информацию для текущей операции.
Вот как раз где ООП приходит и помогает нам очистить код.
ООП подход
Вот подход ООП к нашему примеру:
В браузере выводится следующее:
«ООП подход значительно сократит вашу рабочую нагрузку, если он будет реализован должным образом».
В небольших масштабах это различие может показаться не таким уж большим, но по мере роста размера ваших приложений ООП значительно снизит вашу рабочую нагрузку, если его реализовать должным образом.
Совет. Не все должно быть объектно-ориентированным. Быстрая функция, которая обрабатывает что-то маленькое в одном месте внутри приложения, необязательно должна быть обернута в класc. Используйте свои умения и знания при выборе между объектно-ориентированным и процедурным подходами.
Причина 2: лучшая организация
Еще одно преимущество ООП заключается в том, насколько хорошо он поддается быстрой упаковке и каталогизации. Каждый класс обычно может храниться в отдельном файле, и если используется общее соглашение об именах, доступ к классам чрезвычайно прост.
Предположим, у вас есть приложение с 150 классами, которые динамически вызываются файлом контроллера в корневой области файловой системы приложения. Все 150 классов следуют классу соглашений об именах class.classname.inc.php и находятся в папке inc вашего приложения.
Контроллер может реализовать функцию PHP __autoload() для динамического подтягивания только тех классов, которые ему нужны, как они вызываются, вместо того, чтобы включать все 150 в файл контроллера на всякий случай или придумать какой-нибудь умный способ включения файлов в свой собственный код :
Каждый класс в отдельном файле также делает код более переносимым и более удобным для повторного использования в новых приложениях без кучи копирования и вставки.
Причина 3: Простота в обслуживании
Из-за более компактной природы ООП, когда все сделано правильно, изменения в коде, как правило, намного легче обнаружить и сделать, чем в процедурной реализации длинного спагетти кода.
Если конкретный массив информации приобретает новый атрибут, процедурная часть программного обеспечения может потребовать (в худшем случае) добавления нового атрибута в каждую функцию, использующую этот массив.
Приложение ООП потенциально может быть обновлено так же легко, как добавление нового свойства, а затем добавление методов, которые имеют дело с указанным свойством.
Многие преимущества, описанные в этом разделе, являются результатом применения ООП в сочетании с практикой DRY. Несомненно, можно создать простой в обслуживании процедурный код, который не вызывает трудностей, и в равной степени можно создать ужасный объектно-ориентированный код. В [Pro PHP и jQuery] продемонстрировано сочетание хороших привычек кодирования в сочетании с ООП для создания чистого кода, который легко читать и поддерживать.
Резюме
Примечание автора. Эта статья была отрывком из книги Pro PHP и jQuery (Apress, 2010).