В чем состоит суть объектно-ориентированного программирования (ООП) в PHP


Содержание материала:

Объектно-ориентированное программирование в PHP

Мы можем представить нашу вселенную из разных объектов, таких как солнце, земля, луна и т. Д. Подобным же образом мы можем представить нашу машину из разных предметов, таких как колесо, рулевое управление, редуктор и т. Д. Таким же образом существуют объектно-ориентированные концепции программирования, которые предполагают все как объект и реализовать программное обеспечение с использованием разных объектов.

Объектно-ориентированные концепции

Прежде чем идти подробно, давайте определим важные термины, связанные с объектно-ориентированным программированием.

  • Класс — это тип данных, определенный программистом, который включает в себя локальные функции, а также локальные данные. Вы можете рассматривать класс как шаблон для создания множества экземпляров одного и того же типа (или класса) объекта.
  • Объект — отдельный экземпляр структуры данных , определенного класса. Вы определяете класс один раз, а затем создаете много объектов, принадлежащих ему. Объекты также известны как экземпляр.
  • Переменный члена — Они являются переменными , определенным внутри класса. Эти данные будут невидимы вне класса и могут быть доступны через функции-члены. Эти переменные называются атрибутом объекта после создания объекта.
  • Функция члена — Это есть функция , определенная внутри класса и используется для доступа к данным объекта.
  • Наследование. Когда класс определяется путем наследования существующей функции родительского класса, он называется наследованием. Здесь дочерний класс наследует все или несколько функций-членов и переменных родительского класса.
  • Родительский класс — класс, унаследованный от другого класса. Это также называется базовым классом или суперклассом.
  • Child Class — класс, который наследуется от другого класса. Это также называется подклассом или производным классом.
  • Полиморфизм — Это является концепцией объектно — ориентированным , где тем же функция может быть использована для различных целей. Например, имя функции останется таким же, но оно принимает разные аргументы и может выполнять разные задачи.
  • Перегрузка — тип полиморфизма, в котором некоторые или все операторы имеют разные реализации в зависимости от типов своих аргументов. Аналогичным образом функции также могут быть перегружены с другой реализацией.
  • Данные Абстракт — Любое представление данных , в которых скрыты детали реализации (отведенный).
  • Инкапсуляция — относится к концепции, в которой мы инкапсулируем все данные и функции-члены вместе, чтобы сформировать объект.
  • Конструктор — относится к специальному типу функции, который будет вызываться автоматически всякий раз, когда есть образование объекта из класса.
  • Деструктор — относится к специальному типу функции, который будет вызываться автоматически всякий раз, когда объект удаляется или выходит за рамки.

Определение классов PHP

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

Вот описание каждой строки —

  • Специальный класс формы , за которым следует имя класса, который вы хотите определить.
  • Набор фигурных скобок, охватывающий любое количество объявлений переменных и определений функций.
  • Объявления переменной начинаются со специальной формы var , за которой следует обычное имя переменной $; они также могут иметь начальное назначение для постоянного значения.
  • Определения функций очень похожи на автономные функции PHP, но являются локальными для класса и будут использоваться для установки и доступа к данным объекта.

пример

Вот пример, который определяет класс типа Books —

Переменная $this специальная переменная, и это относится к тому же объекту , т.е. . сам к себе.

Создание объектов в PHP

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

Здесь мы создали три объекта, и эти объекты независимы друг от друга, и они будут иметь свое существование отдельно. Далее мы увидим, как получить доступ к элементам-членам и переменным-членам процесса.

Вызов функций-членов

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

В следующем примере показано, как установить заголовок и цены для трех книг, вызывая функции-члены.

Теперь вы вызываете другие функции-члены, чтобы получить значения, установленные в приведенном выше примере —

Это приведет к следующему результату —

Physics for High School
Advanced Chemistry
Algebra
10
15
7

Функции конструктора

Конструкторские функции — это особый тип функций, которые вызываются автоматически всякий раз, когда создается объект. Поэтому мы полностью используем это поведение, инициализируя многие вещи через функции конструктора.

PHP предоставляет специальную функцию __construct() для определения конструктора. Вы можете передать столько аргументов, сколько хотите в функцию конструктора.

В следующем примере будет создан один конструктор для класса Books, и он будет инициализировать цену и название для книги во время создания объекта.

Теперь нам не нужно вызывать функцию set отдельно, чтобы установить цену и название. Мы можем инициализировать эти две переменные-члены во время создания объекта. Проверьте следующий пример ниже —

Это приведет к следующему результату —

Physics for High School
Advanced Chemistry
Algebra
10
15
7

Destructor — деструктор

Как и функция конструктора, вы можете определить функцию деструктора, используя функцию __destruct(). Вы можете освободить все ресурсы с помощью деструктора.

Наследование

Определения классов PHP могут необязательно наследоваться от определения родительского класса, используя предложение extends . Синтаксис следующий:

Эффект наследования заключается в том, что дочерний класс (или подкласс или производный класс) имеет следующие характеристики:

  • Автоматически имеет все объявления переменной-члена родительского класса.
  • Автоматически имеет все те же функции-члены, что и родительский, который (по умолчанию) будет работать так же, как эти функции в родительском.

Следующий пример наследует класс Books и добавляет больше функциональности на основе этого требования.

Теперь, помимо унаследованных функций, класс Novel сохраняет две дополнительные функции-члены.

Переопределение функции

Определения функций в дочерних классах переопределяют определения с тем же именем в родительских классах. В дочернем классе мы можем изменить определение функции, унаследованной от родительского класса.

В следующем примере функции getPrice и getTitle переопределяются для возврата некоторых значений.

Public — Публичные члены

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

  • Снаружи класс, в котором он объявлен
  • В классе, в котором он объявлен
  • Из другого класса, который реализует класс, в котором он объявлен

До сих пор мы видели всех членов как публичных членов. Если вы хотите ограничить доступность членов класса, вы определяете членов класса как частные или защищенные.

Private — Частные члены

Назначая элемент private, вы ограничиваете его доступность классу, в котором он объявлен. Частный член не может быть отнесен к классам, которые наследуют класс, в котором он объявлен, и не могут быть доступны извне класса.

Член класса может быть закрыт, используя закрытое ключевое слово infront члена.

Когда класс MyClass наследуется другим классом с помощью extends, myPublicFunction() будет виден, как и $ driver. Расширяющийся класс не будет иметь никакого представления или доступа к myPrivateFunction и $ car, потому что они объявлены частными.

Protected — Защищенные члены

Защищенное свойство или метод доступно в классе, в котором он объявлен, а также в классах, которые расширяют этот класс. Защищенные члены недоступны вне этих двух классов. Член класса может быть защищен с помощью защищенного ключевого слова перед членом.

Вот другая версия MyClass —

Интерфейсы

Интерфейсы определены так, чтобы предоставить разработчикам общие имена функций. Различные разработчики могут реализовать эти интерфейсы в соответствии с их требованиями. Вы можете сказать, что интерфейсы представляют собой скелеты, которые реализуются разработчиками.

Начиная с PHP5, можно определить интерфейс, например:

Затем, если другой класс реализовал этот интерфейс, например:

Константы

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

Объявление одной константы легко, как это делается в этой версии MyClass —

В этом классе requiredMargin является константой. Он объявляется с ключевым словом const и ни при каких обстоятельствах не может быть изменен ни на что иное, кроме 1.7. Обратите внимание, что имя константы не имеет ведущего значения $, как это делают имена переменных.

Абстрактные классы

Абстрактный класс — это тот, который не может быть инстанцирован, только унаследован. Вы объявляете абстрактный класс с ключевым словом abstract , например: При наследовании от абстрактного класса все методы, помеченные как абстрактные в объявлении класса родителя, должны определяться дочерним элементом; кроме того, эти методы должны быть определены с одинаковой видимостью.

Обратите внимание, что в определениях функций внутри абстрактного класса также должен предшествовать абстрактный текст. Нелогично иметь абстрактные определения функций внутри не-абстрактного класса.

Статические классы или методы

Объявление классов или методов как статических делает их доступными без необходимости создания экземпляра класса. Член, объявленный как статический, не может быть доступен с помощью экземпляра объекта класса (хотя может использоваться статический метод).

Попробуйте следующий пример —

Конечное ключевое слово

PHP 5 представляет последнее ключевое слово, которое мешает дочерним классам переопределять метод, префикс определения с помощью final. Если сам класс определяется окончательным, то он не может быть расширен.

Следующий пример приводит к фатальной ошибке: невозможно переопределить конечный метод BaseClass::moreTesting()

Вызов родительских конструкторов

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

В этом примере у нас есть родительский класс (Name), который имеет конструктор с двумя аргументами и подкласс (NameSub1), который имеет конструктор с тремя аргументами. Конструктор функций NameSub1, вызвав его родительский конструктор явно , используя в: : синтаксисе (проходящие два своих аргументов вместе) , а затем установить дополнительное поле. Аналогично, NameSub1 определяет функцию non constructor toString ( ) в терминах родительской функции, которую он переопределяет.

ПРИМЕЧАНИЕ. Конструктор может быть определен с тем же именем, что и имя класса. Он определен в приведенном выше примере.

Объектно-ориентированное программирование

Объектно-ориентированное программирование (ООП) организует данные и алгоритмы, обрабатываемые программой. При этом программист создает формы данных и алгоритмы, соответствующие основным характеристикам решаемой проблемы. Модели данных и алгоритмы, их обрабатывающие, называются классами, а объекты — это конкретные их представители, используемые в программе.

Из общих объектов создаются другие, более специализированные. Механизм создания таких подобъектов называется наследованием. В итоге данные программы представляют из себя объектную модель — дерево объектов, начиная с самого верхнего наиболее абстрактного и общего объекта.

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

Примером объектно-ориентированных языков являются: Object Pascal, C++, Java.

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

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

Объект – это комбинация данных и кода. Другими словами, объект, называемый ещё представителем (какого-нибудь класса), — это порция данных, значение которых определяют его текущее состояние, и набор подпрограмм, называемых методами, оперирующих с этими данными и определяющими поведение объекта, т.е. его реакцию на внешние воздействия.

Объект состоит из следующих трех частей:

— состояние (переменные состояния);

Каждый объект является представителем (экземпляром) определенного класса. Во время выполнения программы объекты взаимодействуют друг с другом, вызывая методы, которые являются подпрограммами, характерными для определённого класса.

Класс (class) – это группа данных и методов (функций) для работы с этими данными. Это шаблон. Объекты с одинаковыми свойствами, то есть с одинаковыми наборами переменных состояния и методов, образуют класс. Объект (object) – это конкретная реализация, экземпляр класса. В программировании отношения объекта и класса можно сравнить с описанием переменной, где сама переменная (объект) является экземпляром какого-либо типа данных (класса).

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

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

Практический подход. В современных объектно-ориентированных языках программирования (php, Java, C++, Oberon, Python, Ruby, Smalltalk, Object Pascal) создание класса сводится к написанию некоторой структуры, содержащей набор полей и методов. Практически класс может пониматься как некий шаблон, по которому создаются объекты — экземпляры данного класса. Экземпляры одного класса созданы по одному шаблону, поэтому имеют один и тот же набор полей и методов.

Отношения между классами:

— Наследование (Генерализация) — объекты дочернего класса наследуют все свойства родительского класса.

— Ассоциация — объекты классов вступают во взаимодействие между собой.

— Агрегация — объекты одного класса входят в объекты другого.

— Композиция — объекты одного класса входят в объекты другого и зависят друг от друга по времени жизни.

— Класс-Метакласс — отношение, при котором экземплярами одного класса являются другие классы.

Виды классов:

— базовый (родительский) класс;

— производный класс (наследник, потомок);

Класс – это структурный тип данных, который включает описание полей данных, а также процедур и функций, работающих с этими полями данных. Применительно к классам такие процедуры и функции получили название методов.

Методы – инкапсулированные в классе процедуры и функции, то есть способы работы с данными.

В основу классов и объектно-ориентированного программирования положены три принципа – инкапсуляция, наследование и полиморфизм.

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

Чаще всего инкапсуляция выполняется посредством скрытия информации, то есть маскировкой всех внутренних деталей, не влияющих на внешнее поведение. Обычно скрываются и внутренняя структура объекта и реализация его методов.

Цели инкапсуляции:

§ предельная локализация изменений при необходимости таких изменений,

§ прогнозируемость изменений (какие изменения в коде надо сделать для заданного изменения функциональности) и прогнозируемость последствий изменений.

Инкапсуляция – это процесс отделения друг от друга элементов объекта, определяющих его устройство и поведение. Часто инкапсуляция может быть достигнута простейшими организационными мерами: знание того, что «вот так-то делать нельзя» иногда является самым эффективным средством инкапсуляции!

Инкапсуляция – комбинирование записей с процедурами и функциями, манипулирующими полями этих записей, формирует новый тип данных — объект.

Инкапсуляция – изолирование составляющих класса (полей, методов и свойств) от остальных частей программы.

Суть инкапсуляции: Переменные состояния объекта скрыты от внешнего мира. Изменение состояния объекта (его переменных) возможно ТОЛЬКО с помощью его методов (операций). Почему это так важно? Этот принцип позволяет защитить переменные состояния объекта от неправильного их использования.

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

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

Наследование – это процесс, посредством которого, один объект может наследовать свойства другого объекта и добавлять к ним черты, характерные только для него. Смысл и универсальность наследования заключается в том, что не надо каждый раз заново (с нуля) описывать новый объект, а можно указать родителя (базовый класс) и описать отличительные особенности нового класса. В результате, новый объект будет обладать всеми свойствами родительского класса плюс своими собственными отличительными особенностями.

Наследование – представляет собой возможность построения иерархии объек­тов с использованием наследования их характеристик.

Наследование. Наследование – это такое свойство объекта, которое позволяет ему использовать поля и методы объекта родителя, без описания их в своей структуре.

Наследование – возможность создания новых классов на базе имеющихся с возможностью использования их составляющих. Объект, принадлежащий классу-потомку, может использовать поля, свойства и методы класса-родителя и новые составляющие своего класса.

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

Для реализации таких иерархий в языке программирования предусмотрен полиморфизм. Слово полиморфизм имеет греческое происхождение и переводится как «имеющий много форм».

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

Полиморфизм – это свойство, которое позволяет одно и тоже имя использовать для решения нескольких технически разных задач.

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

Таким образом, существует единственное для всего перечня интерфейсных кнопок действие (вывод изображения кнопки на экран), которое реализуется специфическим для каждой кнопки способом. Это и является проявлением полиморфизма.

Полиморфизм – способность классов решать похожие задачи разными способами. При перекрытии метода родителя в потомке реализуется новый алгоритм решения задачи. Получается, что в объекте-родителе и объекте-потомке действуют два одноименных метода, имеющих разную алгоритмическую основу.

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

В общем смысле, концепцией полиморфизма является идея «один интерфейс, множество методов». Это означает, что можно создать общий интерфейс для группы близких по смыслу действий.

Преимуществом полиморфизма является то, что он помогает снижать сложность программ, разрешая использование одного интерфейса для единого класса действий. Выбор конкретного действия, в зависимости от ситуации, возлагается на компилятор.

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

Топ-пост этого месяца:  OpenCart – модуль просмотренные товары

Механизм работы ООП в таких случаях можно описать примерно так: при вызове того или иного метода класса сначала ищется метод у самого класса. Если метод найден, то он выполняется и поиск этого метода на этом завершается. Если же метод не найден, то обращаемся к родительскому классу и ищем вызванный метод у него. Если найден – поступаем как при нахождении метода в самом классе. А если нет – продолжаем дальнейший поиск вверх по иерархическому дереву. Вплоть до корня (верхнего класса) иерархии.

Не нашли то, что искали? Воспользуйтесь поиском:

Лучшие изречения: Сдача сессии и защита диплома — страшная бессонница, которая потом кажется страшным сном. 8760 — | 7142 — или читать все.

ООП в PHP: продвинутый курс

Изучаем объектно-ориентированное программирование
Первые 5 уроков бесплатно!

Об авторе курса

Привет! Меня зовут Артём Ивашкевич. Я работаю веб-разработчиком более трёх лет. Сейчас я работаю в компании Зарплата.ру — это крупный проект, над которым трудятся более 50 разработчиков, его ежемесячная посещаемость более 4 млн человек.

В свободное время я обучаю программированию других людей, потому что мне это просто нравится. Если Вам интересно узнать, как я к этому пришёл, прочитайте историю как я стал программистом.

Привет! Меня зовут Артём Ивашкевич. Я работаю веб-разработчиком более двух с половиной лет. Сейчас я работаю в компании Зарплата.ру — это крупный проект, над которым трудятся более 50 разработчиков, его ежемесячная посещаемость более 4 млн человек.

В свободное время я обучаю программированию других людей, потому что мне это просто нравится. Если Вам интересно узнать, как я к этому пришёл, прочитайте историю как я стал программистом.

Что Вы получите в продвинутом курсе ООП в PHP

В данном курсе вы научитесь программировать на PHP в объектно-ориентированном стиле. Данное умение просто необходимо для разработки проектов, в которых участвует более одного человека – то есть на настоящей работе.


В ходе курса вы ознакомитесь с принципами ООП. Узнаете что такое классы и объекты. Далее мы изучим такие понятия как инкапсуляция, наследование и полиморфизм – это три кита, на которых стоит всё ООП.

Кроме того, вы познакомитесь с архитектурным паттерном MVC, который является фундаментальным для построения подавляющего большинства всех веб-приложений.

Разумеется, что это за продвинутый курс, если в нём не будет уроков о работе с базой данных. Здесь вы узнаете, как правильно работать с MySQL, используя технологию ORM и паттерн ActiveRecord.

Ну и конечно, всё это было бы неинтересно и непонятно без хороших примеров. Поэтому в ходе прохождения курса мы с вами самостоятельно напишем мини-фреймворк, на основе которого сделаем настоящий блог!

Отзывы учеников

Сертификат

Преимущества

Проверка домашек

К урокам есть домашние задания, которые я ежедневно проверяю. По факту вы платите не столько за уроки, сколько за мою работу.

Быстрая помощь

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

Честная цена

Не, ну Вы видели эти цены на курсы в десятки тысяч рублей?
У меня Вы пройдёте обучение по цене, сравнимой с покупкой книги.

Гарантия

Если Вас что-то не устроит — просто напишите мне любым удобным способом. И я верну Вам деньги в тот же день.

Программа курса

Уровень 1. Основы ООП

  • 1. Классы и объекты в PHP как основа ООП
  • 2. Инкапсуляция в PHP
  • 3. Наследование в PHP
  • 4. Интерфейсы в PHP
  • 5. Трейты в PHP
  • 6. Полиморфизм в PHP
  • 7. Изучаем абстрактные классы в PHP
  • 8. Статические методы и свойства в PHP
  • 9. Объектно-ориентированный подход в PHP

Уровень 2. Архитектура приложения

  • 10. Неймспейсы и автозагрузка в PHP
  • 11. Архитектура MVC — Model, View, Controller
  • 12. Controller в MVC
  • 13. Фронт-контроллер и роутинг в PHP
  • 14. View в MVC
  • 15. Создаём базу данных для будущего блога
  • 16. Класс для работы с базой данных
  • 17. Делаем вывод статей на сайте из базы данных
  • 18. ORM — Object Relational Mapping
  • 19. Реализуем Active Record в PHP
  • 20. Паттерн Singleton в PHP
  • 21. PHP Reflection API
  • 22. Обновление с помощью Active Record
  • 23. Вставка с помощью Active Record
  • 24. Удаление в Active Record
  • 25. CRUD-операции
  • 26. M в MVC
  • 27. Работа с исключениями в PHP

Уровень 3. Пишем блог на PHP

  • 28. Пишем регистрацию на сайте на PHP
  • 29. Система активации пользователей по email на PHP
  • 30. Пишем систему авторизации на PHP
  • 31. Добавляем статьи в блог на PHP
  • 32. Редактируем статьи в блоге на PHP
  • 33. Задание для самостоятельной работы – доводим блог до ума
  • 34. Пишем свой фреймворк на PHP

Уровень 4. Заключение

Для чего нужен продвинутый курс ООП в PHP

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

Курс ООП в PHP позволяет обучить лучшим практикам и современным инструментам программирования. Также здесь можно научиться разрабатывать сложный работающий проект. Для осуществления веб-программирования на достойном уровне и понимания процесса разработки сайтов важно также получить необходимое количество актуальной информации по данному вопросу.

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

Для обучения созданию современной архитектуры сайтов невозможно обойтись без объектно-ориентированного программирования или ООП. Вначале у многих разработчиков веб-приложений объектно-ориентированный подход вызывает небольшое недоумение, ведь более привычным для них является процедурный подход. Но курс ООП в PHP поможет быстро справиться с данными трудностями. На занятиях будут рассмотрены теоретические аспекты ООП, после чего пройдет подробное обучение их применению на практике. В течение всего периода курсов последовательно будут изучаться основы ООП, что позволит создавать приложения в объектно-ориентированном стиле.

Пройдя подобный продвинутый курс, можно легко разобраться в довольно сложном объектно-ориентированном программировании. Слушатели познакомятся также с такими понятиями, как классы, объекты и узнают об отличиях между ними. Кроме того, на курсах их познакомят со свойствами, методами и константами класса. Данная обучающая программа позволяет использовать наследование классов для того, чтобы создаваемые веб-приложения были более удобными и подчинялись строгой логике.

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

Какие возможности получают ученики после курсов?

Для разработки многих современных сайтов и web приложений полностью или частично используются готовые решения на основе классов, объектов или пакетов. Они соответствуют определённым международным стандартам. При владении основными общими принципами программирования из объектно-ориентированного PHP разработчик может легко и быстро переходить из одной системы в другую. Также важно иметь знания проектирования пакетов и платформ.

Продвинутый курс PHP предназначен для тех, кто имеет знания основного курса и стремится к повышению своего профессионализма в разработке до уровня junior PHP developer. Кроме того, обучение позволит приобрести необходимые навыки работы в команде.

Что такое объектно-ориентированное программирование

Автор: Сергей Никонов

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

Введение в объектно-ориентированное программирование

Объектно-ориентированное программирование (ООП) — это популярная парадигма программирования, пришедшая на смену процедурному подходу в программировании.

Процедурное программирование — это монолитная программа с набором инструкций для выполнения, с ветвлениями и подпрограммами.

Для понимания разницы между процедурным программированием и ООП программированием, я приведу примеры одного и того же кода в разных парадигмах.

Пример кода на PHP процедурного программирования:

Пример кода на PHP в объектно-ориентированном стиле программирования:

На первый взгляд, может показаться, что во втором примере, где мы используем объектно-ориентированное программирование, слишком много лишнего кода и первый пример процедурного программирования лучше. Это утверждение и верно и неверно одновременно.

Какой подход использовать вам ООП или процедурный, зависит от задачи поставленной перед вами. Если вам нужно создать код для одноразового использования и этот код можно написать четырьмя или пяти строчками, тогда вы можете использовать процедурный подход программирования.

В том случае, если задача будет повторяться и постоянно меняться условия выполнения программы — лучше использовать объектно-ориентированное программирование.

Что такое класс (class)

Класс — это набор полей и методов программы. Рассмотрим прошлый пример. У нас есть класс Human:

Human — это имя класса.
$words — это поле класса (или переменная класса)
setWords, getWords(), sayIt() — это методы класса

Базовые принципы объектно-ориентированного программирования

Объектно-ориентированное программирование базируется на трех основных принципах. Это инкапсуляция, полиморфизм и наследование. На этих трех базовых принципах мы остановимся подробнее.

Для лучшего понимания я буду приводить примеры из реальных объектов в жизни. Это кстати одна из особенностей объектно-ориентированного программирования.

Что такое инкапсуляция

Инкапсуляция — это понятие в объектно-ориентированном программирование обозначающее защиту данных (сокрытие данных) от внешнего пользователя.

Для лучшего понимания, приведу пример инкапсуляции в жизни на примере телефона:

Чтобы совершить звонок по сотовому телефону, вам необязательно знать как работают сотовые сети, где расположены вышки связи, как у них организованно хранение данных и прочее. Все что вам нужно знать, чтобы совершить звонок по сотовому телефону — это что у вас должен быть номер того абонента, кому вы хотите позвонить и деньги на счету.

Свойство инкапсуляции в объектно-ориентированном программировании обозначает то, что нужно дать пользователю вашей программы доступ только к нужным интерфейсам (методам) и скрыть доступы к внутренним приватным методам и полям вашего класса.

Пример инкапсуляции на примере класса Human:

В этом примере мы добавили в класс Human приватное поле пол ($sex). Ключевое слово private обозначает, что мы не сможем получить доступ к переменной $sex из вне класса.

Если мы попытаемся обратиться к полю $seх из вне класса, тогда мы получим ошибку:

$human->sex = «11»; Fatal error: Cannot access private property Human::$sex

Для того, чтобы задать поле пол, нам нужно обратиться к методу setSex() и передать ему в качестве параметра пол Human. В этом методе стоит проверка, male или female (мужчина или женщина).

Если в качестве параметра мы попробуем передать другой параметр в этот метод, например $human->setSex(“123″), тогда метод вернет нам ошибку.

Инкапсуляция очень полезное свойство объектно-ориентированного подхода в программировании и оно используется очень часто. Инкапсуляция также полезна, когда над проектом работают одновременное несколько человек.

Вы заранее можете дать другим программистам список методов вашего класса (или интерфейса), а они в свою очередь могу работать над своими классами.

Что такое наследование

Наследование — это второе свойство объектно-ориентированного программирования, позволяющее наследовать функционал (набор полей и методов) одного класса в другой.

Пример наследования из жизни очень простой:

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

За вами тянется целая эволюционная цепочка генов, начиная с генов древних предков обезьян, заканчивая генами современного человека — вашими родителями. В объектно-ориентированном программирование, наследование тоже самое свойство.

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

Наследование в объектно-ориентированном программированием обозначается ключевым словом extends. Давайте изменим класс Human и применив наследование ООП, создадим классы мужчины и женщины.

В результате выполнения программы, мы увидим следующее:

Меня зовут Sergey и у меня растет борода

Меня зовут Maria и я рожаю детей

В этом примере, классы Мужчина и Женщина унаследовали от родительского класса Human общий метод say(), то есть, и Мужчина и Женщина у нас умеют говорить, но для Мужчины и Женщины, мы ввели свои особенности: У мужчины растет борода, а женщина умеет рожать детей.

Метод под названием __construct — это конструктор класса. Что такое конструктор класса, читайте в статье.

Что такое полиморфизм

Полиморфизм — это свойство объектно-ориентированного программирования, позволяющее одному и тому же методу вести себя по разному. Звучит сложно, я приведу пример полиморфизма из жизни, чтобы вам сразу все стало ясно 🙂

Пример полиморфизма из жизни:

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

Как вы видите, полиморфизм это не такое уж сложное для понимания свойство объектно-ориентированного программирования.

Если полиморфизм перенести на пример с классами — то это общий метод для объектов.

Давайте посмотрим на примере реализацию полиморфизма в PHP:

В результате выполнения программы, мы увидим следующее:

У меня мужской голос, меня зовут Sergey и у меня растет борода
У меня женский голос, меня зовут Maria и я рожаю детей

Мы модифицировали наши прошлые классы и добавили такие понятия объектно-ориентированного программирования как Интерфейс и Абстрактный класс.

Обратите внимание, что метод say() в классах Man и Women мы реализуем по-разному. Это и есть полиморфизм.

Что такое интерфейс в ООП

Интерфейс — это шаблонный класс без реализации. То есть в интерфейсе мы только задаем методы и эти методы обязаны реализовать классы.

В нашем прошлом примере наш интерфейс Say с единственным методом say():

Этот интерфейс мы имплементируем в абстрактном классе Human. Для того чтобы имплементировать интерфейс, после названия класса нужно дописать ключевое слово implements.

Что такое абстрактный класс в ООП

Абстрактный класс в ООП — это класс шаблонный класс от которого нельзя создать экземпляр класса.

Это значит, что мы не можем с абстрактным классом сделать так:

Если мы попытаемся создать экземпляр абстрактного класса, интерпретатор PHP выдаст ошибку.

Абстрактный класс мы можем только наследовать. Взгляните еще раз на абстракный класс. Перед классом он содержит ключевое слово abstract. Также он имплементирует интерфейс Say (implements).

Выводы о ООП

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

Обратите внимание, я сознательно очень упростил примеры, для того, чтобы начинающим программистам проще было разобраться с ООП.

В следущих статьях мы поговорим о таких ключевых словах как public, private, protected, static и рассмотрим еще примеры. Если у вас остались вопросы, пишите комментарии и мы обязательно попробуем вам подсказать решение.

Вступайте в нашу группу VK и следите за новыми материалами.


Для того, чтобы посмотреть видео, зарегистрируйтесь в личном кабинете

Правая Скобка ]

Энциклопедия веб разработчика. Все что интересно HTML, CSS, PHP, MySQL и не только !

PHP объектно-ориентированное программирование

Можно представить нашу вселенную состоящую из различных объектов — солнце, земля, луна и т.д. Так же можно представить автомобиль сделанный из различных узлов — колес, кузова, различных механизмов и т.д. Точно так же в объектно-ориентированном программировании вводятся понятия объектов с которыми и осуществляются различные операции.

Объектно-ориентированные концепции
Для начала определим важные термины, связанные с объектно-ориентированным программированием.

  • Class— это тип данных, определенный программистом, который включает в себя локальные функции, а также локальные данные. Можно рассматривать класс как шаблон для создания множества экземпляров одного и того же типа (или класса) объекта.
  • Object— индивидуальный экземпляр структуры данных, определенный классом. Класс определяется один раз, а затем создается много объектов, принадлежащих этому классу. Объекты также известны как экземпляры.
  • Member Variable — это переменные, определенные внутри класса. Эти данные будут невидимы вне класса и могут быть доступны через функции-члены. Эти переменные называются атрибутом объекта после создания объекта.
  • Member function — это функция, определенная внутри класса и используемая для доступа к данным объекта.
  • Наследование. Когда класс определяется путем наследования существующей функции родительского класса, он называется наследованием. Здесь дочерний класс наследует все или несколько функций-членов и переменных родительского класса.
  • Родительский класс — класс, унаследованный от другого класса. Это также называется базовым классом или суперклассом.
  • Дочерний класс — класс, который наследуется от другого класса. Он также называется подклассом или производным классом.
  • Полиморфизм. Это объектно-ориентированная концепция, в которой одна и та же функция может использоваться для разных целей. Например, имя функции останется таким же, но оно принимает разные аргументы и может выполнять разные задачи.
  • Перегрузка — тип полиморфизма, в котором некоторые или все операторы имеют разные реализации в зависимости от типов своих аргументов. Аналогичным образом функции также могут быть перегружены с другой реализацией.
  • Абстракция данных — любое представление данных, в которых детали реализации скрыты (абстрагированы).
  • Инкапсуляция — относится к концепции, в которой мы инкапсулируем все данные и функции-члены вместе, чтобы сформировать объект.
  • Конструктор — относится к специальному типу функции, который будет вызываться автоматически всякий раз, когда есть образование объекта из класса.
  • Диструктор — относится к специальному типу функции, который будет вызываться автоматически всякий раз, когда объект удаляется или выходит за рамки обьекта.

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

Объектно ориентированный PHP для начинающих

Russian (Pусский) translation by Sergey Zhuk (you can also view the original English article)

Для многих программистов на PHP объектно-ориентированное программирование — пугающая концепция, полная сложного синтаксиса и других препятствий. Как подробно описано в моей книге Pro PHP и jQuery, вы узнаете концепции объектно-ориентированного программирования (ООП) — стиля кодирования, в котором связанные действия группируются в классы, чтобы облегчить создание более компактного и эффективного кода.

Понимание объектно ориентированного программирования

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

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

Одним из основных преимуществ программирования по принципу DRY является то, что если в вашей программе изменяется часть информации, обычно требуется только одно изменение для обновления кода. Одним из самых больших кошмаров для разработчиков является поддержание кода, в котором данные объявляются снова и снова, а это означает, что любые изменения в программе становятся похожими на бесконечную игру Where’s Waldo?

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

Понимание объекты и классы

Прежде чем вы сможете проникнуть в тонкости ООП, необходимо базовое понимание различий между объектами и классами. В этом разделе будут рассмотрены строительные блоки классов, их различные возможности и некоторые виды их использования.

Узнаем различия между объектами и классами

Когда разработчики начинают говорить об объектах и классах, то они кажутся взаимозаменяемыми. Хотя на самом деле это не так.

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

Класс, например, это как проект для дома. Он определяет форму дома на бумаге, при этом отношения между различными частями дома так же четко определены и спланированы, хотя дома еще не существует.

Таким образом, объект подобен фактическому дому, построенному в соответствии с этим планом. Данные, хранящиеся в объекте, подобны дереву, проводам и бетону, которые составляют дом: не будучи собранными в соответствии с планом, это всего лишь куча материала. Однако, когда все это объединяется, это становится организованным и полезным домом.

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

Структурирование классов

Синтаксис для создания класса довольно прост: объявить класс с помощью ключевого слова class , за которым следует имя класса и набор фигурных скобок ( <> ):

Топ-пост этого месяца:  Как установить яндекс счетчик на сайт за 1 минуту

После создания класса новый экземпляр может быть создан и сохранен в переменной с использованием ключевого слова new :

Чтобы увидеть содержимое класса, используйте var_dump ():

Попробуйте выполнить этот процесс, разместив весь предыдущий код в новом файле test.php в [локальной] папке для тестирования:

Загрузите страницу в браузере по адресу http: //localhost/test.php , и на экране должно появиться следующее:

В своей простейшей форме вы только что завершили свой первый ООП-скрипт.

Определение свойств класса

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

Чтобы добавить свойство в MyClass , добавьте следующий код в свой скрипт:

Ключевое слово public определяет видимость свойства, о котором вы узнаете чуть позже в этой главе. Затем свойство присваивается с использованием стандартного синтаксиса переменных и присваивается значение (хотя свойствам классов не требуется начальное значение).

Чтобы прочитать это свойство и вывести его в браузер, укажите объект, с которого следует читать, и свойство, которое нужно прочитать:

Поскольку могут существовать несколько экземпляров класса, если отдельный объект не ссылается, то сценарий не сможет определить, с какого объекта следует читать свойство. Использование стрелки ( -> ) является конструкцией ООП, которая обращается к содержащимся в нем свойствам и методам данного объекта.

Измените скрипт в test.php , чтобы считать свойство, вместо того, чтобы выводить весь класс, изменив код, как показано ниже:

Теперь перезагрузка вашего браузера выводит следующее:

Определение методов класса

Методы являются специфичными для класса функциями. Отдельные действия, которые объект сможет выполнить, определены внутри класса как методы.

Например, чтобы создать методы, которые будут устанавливать и получать значение свойства класса $prop1 , добавьте в свой код следующее:

Примечание. ООП позволяет объектам ссылаться на себя, используя $this . При работе внутри метода используйте $this таким же образом, как вы использовали бы имя объекта вне класса.

Чтобы использовать эти методы, вызовите их так же, как обычные функции, но сначала укажите ссылку на объект, к которому они принадлежат. Прочитайте свойство из MyClass , измените его значение и прочитайте его еще раз, внеся следующие изменения:

Перезагрузите браузер, и вы увидите следующее:

«Сила ООП становится очевидной при использовании нескольких экземпляров
одного класса.»

Когда вы загружаете результаты в свой браузер, они отобразят следующее:

Как вы можете видеть, ООП хранит объекты как отдельные сущности, что позволяет легко разделять различные фрагменты кода на небольшие связанные пакеты.

Волшебные методы в ООП

Чтобы упростить использование объектов, PHP также предоставляет ряд магических методов или специальных методов, вызываемых, когда определенные общие действия происходят внутри объектов. Это позволяет разработчикам выполнять ряд полезных задач с относительной легкостью.

Использование конструкторов и деструкторов

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

В целях иллюстрации концепции конструкторов добавьте конструктор в MyClass , который будет выводить сообщение всякий раз, когда создается новый экземпляр класса:

Примечание. __CLASS__ возвращает имя класса, в котором оно вызывается; Это то, что известно как волшебная константа. Существует несколько доступных магических констант, о которых вы можете прочитать в руководстве по PHP.

Перезагрузка файла в вашем браузере приведет к следующему результату:

Чтобы вызвать функцию, когда объект разрушен, доступен магический метод __destruct() . Это полезно для очистки класса (например, закрытие соединения с базой данных).

Вывести сообщение, когда объект уничтожен, определяя магический метод
__destruct() в MyClass :

При определенном деструкторе перезагрузка тестового файла приводит к следующему выводу:

«Когда достигнут конец файла, PHP автоматически освобождает все ресурсы».

Чтобы явно вызвать деструктор, вы можете уничтожить объект, используя
функцию unset() :

Теперь при загрузке в вашем браузере результат будет выглядеть следующим образом:

Преобразование в строку

Чтобы избежать ошибки, если скрипт пытается вывести MyClass в виде строки, используется другой магический метод, называемый __toString() .

Без __toString() попытка вывода объекта в виде строки приводит к фатальной ошибке. Попытка использовать echo для вывода объекта без использования магического метода:

Это приводит к следующему результату:

Чтобы избежать этой ошибки, добавим метод __toString() :

В этом случае попытка преобразовать объект в строку приведет к вызову метода getProperty( ). Загрузите тестовый скрипт в свой браузер, чтобы увидеть результат:

Совет. В дополнение к магическим методам, обсуждаемым в этом разделе, доступно еще несколько других. Полный список магических методов приведен на странице руководства PHP.

Использование наследования

Классы могут наследовать методы и свойства другого класса с помощью ключевого слова extends . Например, чтобы создать второй класс, который расширяет MyClass и добавить метод, вы должны добавить следующее в свой тестовый файл:

После перезагрузки тестового файла в вашем браузере выводится следующее:

Перезапись унаследованных свойств и методов

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

Это изменяет вывод в браузере на:

Сохранение оригинальной функциональности метода при перезаписи методов

Чтобы добавить новые функции к унаследованному методу, сохранив исходный метод нетронутым, используйте ключевое слово parent с оператором разрешения области видимости ( :: ):

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

Указание видимости свойств и методов

Для дополнительного контроля над объектами методам и свойствам можно указать видимость. Это определяет, как и откуда можно получить доступ к свойствам и методам. Существует три ключевых слова: public , protected и private . В дополнение к своей видимости метод или свойство могут быть объявлены static , что позволяет им получать доступ без экземпляра класса.

«Для дополнительного контроля над объектами методам и свойствам указывается их видимость.»

Примечание. Видимость — новая функция в PHP, начиная с версии 5. Информацию о совместимости ООП с PHP 4 смотрите на странице руководства PHP.

Публичные свойства и методы

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

Защищенные свойства и методы

Если свойство или метод объявлен как protected , доступ к нему можно получить только внутри самого класса или в классах-потомках (классы, которые расширяют класс, содержащий защищенный метод).

Объявите метод getProperty() как защищенный в MyClass и попытайтесь получить к нему доступ непосредственно извне класса:

При попытке запустить этот сценарий появляется следующая ошибка:

Теперь создайте новый метод в MyOtherClass для вызова метода getProperty() :

Это приведет к желаемому результату:

Приватные свойства и методы

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

Чтобы продемонстрировать это, объявите getProperty() как private в MyClass и попытайтесь вызвать callProtected() из
MyOtherClass :

Перезагрузите браузер, и появится следующая ошибка:

Статические свойства и методы

Доступ к методу или свойству, объявленному static , возможен без создания экземпляра класса; Вы просто указываете имя класса, оператор разрешения области и имя свойства или метода.

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

Чтобы продемонстрировать это, добавьте статическое свойство $count и статический метод с именем plusOne() в MyClass . Затем установите цикл do . while для вывода приращенного значения $count , пока значение меньше 10:

Примечание. При доступе к статическим свойствам знак доллара
( $ ) идет после оператора разрешения области видимости.

Когда вы загружаете этот скрипт в своем браузере, выдается следующее:

Комментирование с помощью DocBlocks

Стиль комментирования DocBlock является широко распространенным
методом документирования классов».

Хотя это не официальная часть ООП, стиль комментирования DocBlock является широко распространенным методом документирования классов. Помимо предоставления стандарта для
разработчиков, используемым при написании кода, он также был принят многими из самых популярных наборов разработчика программного обеспечения (SDK), таких как Eclipse и NetBeans, и будет использоваться ими для генерации подсказок кода.

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

Реальная сила DocBlocks проявляется с возможностью использовать теги, которые начинаются с символа at ( @ ), за которым сразу следует имя тега и значение тега. Теги DocBlock позволяют разработчикам определять авторов файла, лицензию на класс, информацию о свойствах или методах и другую полезную информацию.

Наиболее часто используемые теги:

  • @author: автор текущего элемента (который может быть классом, файлом, методом или любым битом кода) указан в этом теге. Несколько тегов автора могут использоваться в одном и том же DocBlock, если нужно указать несколько авторов. Формат имени автора — John Doe [email protected] .
  • @copyright: это означает год и имя хозяина авторских прав для текущего элемента. Формат такой: 2010 Copyright Holder .
  • @license: Ссылка на лицензию для текущего элемента. Формат информации о лицензии:
    http://www.example.com/path/to/license.txt License Name .
  • @var: содержит тип и описание свойства переменной или класса. Формат: type element description .
  • @param: Этот тег показывает тип и описание параметра функции или метода. Формат: type $element_name element description .
  • @return: тип и описание возвращаемого значения функции или метода приведены в этом теге. Формат type return element description .

Пример класса, прокомментированного с помощью DocBlocks, может выглядеть так:

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

Сравнение объектно-ориентированного и процедурного кода

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

Причина 1: Простота внедрения

«Хотя вначале это может быть непростой задачей, ООП действительно обеспечивает более простой подход к работе с данными».

Хотя вначале это может быть непростой задачей, ООП действительно обеспечивает более простой подход к работе с данными. Поскольку объект может хранить данные внутри себя, нет необходимости передавать переменны от функции к функции для правильной работы.

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

Процедурный подход

Вот процедурный подход к нашему примеру:

«; echo «»; // Tom got a promotion and had a birthday $person1 = changeJob($person1, ‘Box-Mover’); $person1 = happyBirthday($person1); // John just had a birthday $person2 = happyBirthday($person2); // Output the new values for the people echo «»; echo «»; ?>

При выполнении код выводит следующее:

Хотя этот код не обязательно плохой, в процессе кодирования нужно помнить о многом. Массив атрибутов измененного человека должен быть передан и возвращен из каждого вызова функции, что оставляет место для ошибок.

Чтобы упростить этот пример, было бы желательно оставить как можно данных меньше разработчику. Необходимо передать только абсолютно необходимую информацию для текущей операции.

Вот как раз где ООП приходит и помогает нам очистить код.

ООП подход

Вот подход ООП к нашему примеру:

«; echo «»; // Give Tom a promotion and a birthday $person1->changeJob(«Box-Mover»); $person1->happyBirthday(); // John just gets a year older $person2->happyBirthday(); // Output the ending values echo «»; echo «»; ?>

В браузере выводится следующее:

В этом коде можно еще кое-что улучишь, чтобы сделать код еще более объектно-ориентированным, но после того, как класс определен, создание и модификация людей — легкий процесс; Информация о человеке не нужно передавать или возвращать из методов, и наоборот, только абсолютно необходимая информация передается каждому методу.

«ООП подход значительно сократит вашу рабочую нагрузку, если он будет реализован должным образом».

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

Совет. Не все должно быть объектно-ориентированным. Быстрая функция, которая обрабатывает что-то маленькое в одном месте внутри приложения, необязательно должна быть обернута в класc. Используйте свои умения и знания при выборе между объектно-ориентированным и процедурным подходами.

Причина 2: лучшая организация

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

Предположим, у вас есть приложение с 150 классами, которые динамически вызываются файлом контроллера в корневой области файловой системы приложения. Все 150 классов следуют классу соглашений об именах class.classname.inc.php и находятся в папке inc вашего приложения.

Контроллер может реализовать функцию PHP __autoload() для динамического подтягивания только тех классов, которые ему нужны, как они вызываются, вместо того, чтобы включать все 150 в файл контроллера на всякий случай или придумать какой-нибудь умный способ включения файлов в свой собственный код :

Каждый класс в отдельном файле также делает код более переносимым и более удобным для повторного использования в новых приложениях без кучи копирования и вставки.

Причина 3: Простота в обслуживании

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


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

Приложение ООП потенциально может быть обновлено так же легко, как добавление нового свойства, а затем добавление методов, которые имеют дело с указанным свойством.

Многие преимущества, описанные в этом разделе, являются результатом применения ООП в сочетании с практикой DRY. Несомненно, можно создать простой в обслуживании процедурный код, который не вызывает трудностей, и в равной степени можно создать ужасный объектно-ориентированный код. В [Pro PHP и jQuery] продемонстрировано сочетание хороших привычек кодирования в сочетании с ООП для создания чистого кода, который легко читать и поддерживать.

Резюме

Теперь вы уже должны чувствовать себя комфортно в стиле объектно-ориентированного программирования. Изучение ООП — отличный способ перенести свое программирование на следующий уровень. При правильном внедрении ООП поможет вам создать легко читаемый и простой в обслуживании переносимый код, который сэкономит вам (и разработчикам, работающим с вами) часы дополнительной работы. Вы зациклились на чем-то, что не было рассмотрено в этой статье? Вы уже используете ООП и имеете несколько советов для новичков? Поделитесь ими в комментариях!

Примечание автора. Эта статья была отрывком из книги Pro PHP и jQuery (Apress, 2010).

Объектно-ориентированное программирование. Часть 1: что такое классы и объекты

Почти всё современное программирование построено на принципах ООП, поэтому их должен понимать каждый разработчик. Узнайте основы из этой статьи.

Введение

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

Цикл будет состоять из статей, которые будут посвящены определенным аспектам ООП:

  1. Введение в ООП: создание классов и объектов.
  2. Особенности работы с объектами.
  3. Инкапсуляция и зависимости.
  4. Полиморфизм.
  5. Наследование, абстрактные классы, интерфейсы.

Все примеры в этой серии будут рассмотрены на языке C#. Для наглядности они будут связаны с разработкой игр, потому что в них активно используются объекты.

Перед чтением этой серии статей вам нужно ознакомиться с такими понятиями, как:

  • переменные и типы данных;
  • условные конструкции;
  • циклы;
  • коллекции (желательно).

Работа будет происходить в Visual Studio 2020, но вполне подойдет и VS 2020. В конце каждой статьи будут задания, которые помогут закрепить тему.

Пишет о разработке сайтов, в свободное время создает игры. Мечтает открыть свою студию и выпускать ламповые RPG.

Что такое ООП

Объектно-ориентированное программирование (сокращенно ООП) — это парадигма разработки программных систем, в которой приложения состоят из объектов.

Объекты — это сущности, у которых есть свойства и поведение. Обычно объекты являются экземплярами какого-нибудь класса. Например, в игре может быть класс Character (персонаж), а его экземплярами будут hero или npc.

Свойства — это данные, которые связаны с конкретным объектом:

Поведение объекта определяется с помощью методов — специальных блоков кода, которые можно вызывать из разных частей программы. Например, у того же объекта Character могут быть следующие методы:

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

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

Такую парадигму используют многие популярные языки:

Плюсы и минусы объектно-ориентированного программирования

Плюсы Минусы
Легко читается.
Не нужно выискивать в коде функции и выяснять, за что они отвечают.
Потребляет больше памяти.
Объекты потребляют больше оперативной памяти, чем примитивные типы данных.
Быстро пишется.
Можно быстро создать сущности, с которыми должна работать программа.
Снижает производительность.
Многие вещи технически реализованы иначе, поэтому они используют больше ресурсов.
Проще реализовать большой функционал.
Так как на написание кода уходит меньше времени, можно гораздо быстрее создать приложение с множеством возможностей.
Сложно начать.
Парадигма ООП сложнее функционального программирования, поэтому на старт уходит больше времени.
Меньше повторений.
Не нужно писать однотипные функции для разных сущностей

Как использовать классы и объекты

Изучая C#, разработчик в первый же день сталкивается с классами и объектами. Например, вот как выглядит первая программа любого новичка:

Здесь создается класс Program, у которого есть метод Main () — с него начинается выполнение программы, поэтому его называют точкой входа.

Для вывода текста используется следующий оператор:

Тут программа обращается к объекту Console и вызывает метод WriteLine (), который выводит переданное значение в консоль.

Также у объекта Console есть разные свойства:

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

Объектно-ориентированное программирование в PHP для начинающих

Доброго времени суток, уважаемые читатели нашего блога! Добро пожаловать на первый урок из серии уроков по объектно-ориентированному программированию в PHP. На нашем блоге уже были уроки о том, что такое PHP, также было рассказано о работе с сылками в PHP и о многом другом.

А в этой серии уроков вы сможете изучить различные понятия объектно-ориентированного программирования и узнать, как быстро и легко создавать надежные объектно-ориентированные PHP приложения. В этой статье мы начнем с рассмотрения некоторых базовых принципов объектно-ориентированного программирования.

Содержание

Понятие объектно-ориентированного программирования в PHP

Вы когда-нибудь работали с PHP? Тогда вы знаете, как создавать и использовать функции в PHP. Наверняка вы знакомы с процедурным программированием в PHP. Посредством процедурного программирования обычно создаются структуры данных — номеров, строк, массивов и так далее — для хранения ваших данных, а затем эти структуры данных передаются в функции, которые работают с этими данными.

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

Часто объекты, которые вы создаете с помощью ООП, отражают реальные объекты. Например, если бы вы писали свой веб-сайт, вы бы создали объект User, который содержит всю информацию о том или ином пользователе вашего сайта (псевдоним, имя пользователя, адрес электронной почты, пароль, и так далее), а также функции для работы с данными (регистрация, имя для входа, выход из системы, запрет и так далее).

Для чего нужно объектно-ориентированное программирование в PHP?

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

Тем не менее у ООП есть ряд преимуществ:

  1. Написание модульного кода: С помощью ООП вы можете написания код в отдельных модулях. Разделяя код на отдельные модули, вы можете сделать код более управляемым, и простым в отладке и расширении.
  2. Может отражать, то что происходит в реальном мире: Как я уже говорил ранее, объекты могут легко отображаться на реальных «объектах», таких как животные, транспорт, архитектура и так далее. Благодаря этому задача упрощается, когда вы приступаете к проектированию ваших объектно-ориентированных приложений, поскольку цель каждого объекта, а также связь между объектами, и без того уже достаточно ясны.
  3. Использование кода для многократного применения: Код многократного использования поможет вам сэкономить много времени при написании приложений, и с течением времени вы можете создать библиотеку кодов многократного использования, которые вы можете использовать в различных приложениях. ООП облегчает написание кода многократного использования, поскольку структуры данных и функции красиво содержатся в одном объекте многократного использования. Также можно воспользоваться уже существующим объектом и расширить его для того, чтобы добавить новые функции для конкретного приложения, что в свою очередь облегчает повторное использование объектов.

Основополагающие понятия ООП в PHP

Прежде чем перейти к написанию объектно-ориентированного кода на PHP, важно понимать 4 основных понятия ООП: Классы, объекты, свойства и методы.

Классы

Класс является основой для объектов. Это блок кода, который определяет:
Типы данных, которые объекты, созданные из класса, будут хранить и функции, которые эти объекты будут содержать.
При создании объектно-ориентированного приложения, вы обычно создаете один или более классов, представляющих различные типы объектов в вашем приложении. Например, если вы пишете сайт, вы можете создать классы, называемые Site, Article, Category и User.

Объекты

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

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

Часто говорят, что объект — это экземпляр класса, и процесс создания объекта из класса называется созданием экземпляра.

Свойства

Значения данных, которые содержит объект, хранятся в специальных переменных, известных как свойства. Свойства объекта тесно связаны с объектом. Несмотря на то, что все объекты, созданные из данного класса, имеют одни и те же свойства, свойства одного объекта могут иметь различные значения для свойств другого объекта.

Методы

Функции, которые определены в пределах класса и используются в объекте, известны как методы. Во многих отношениях, они подобны обычным функциям; им можно присваивать значения, они могут содержать локальные переменные и возвращать значения. Однако методы объекта обычно работают в основном со свойствами объекта. Например, метод signin() для входа на сайт может установить свойство SignIn для пользователя сайта в значение true.

Создание классов в PHP

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

Во-первых, давайте рассмотрим создание класса. Базовый синтаксис для создания класса в PHP выглядит так:

Например, если бы вы создали класс User на своём веб-сайте, тогда бы вы написали следующий код:

Довольно просто не правда ли?! Конечно, этот класс ничего не может делать, до тех пор пока вы не добавите свойства и методы этого класса. Тем не менее, приведенный выше код создает настоящий класс, пригодный для использования в PHP.

Хорошим тоном в ООП программировании является то, что для каждого класса нужно создавать свой собственный файл, с тем же именем, что и имя класса. Например, вы могли бы записать указанный выше код класса User в файл User.php и сохранить файл в папку classes.

Создание объектов в PHP

Вы можете создать объект класса с помощью ключевого слова new, следующим образом:

Эта конструкция создает объект на базе класса «Имя_класса» . Обычно, чтобы хранить вновь созданный объект, нужно присвоить его переменной, которую можно использовать позже для доступа к объекту. Например, давайте создадим новый объект User и сохраним его в переменную $User:

Также мы можем создать еще один объект в этом же классе:

Даже если мы создали эти классы из одного и того же класса User, то эти объекты $User и $User2 абсолютно не зависят друг от друга.

Свойства класса

Теперь, когда мы знаем, как создавать классы и объекты PHP, давайте рассмотрим добавление свойств. Существует 3 типа свойств, которые можно добавить в класс:

  • Свойства с ключевым словом public они будут доступны везде. Эти свойства можно прочитать или изменить с помощью любого кода в вашем сценарии, будь этот код внутри или вне класса.
  • Свойства с ключевым словом private доступны только с помощью методов в пределах класса. Если это возможно, то лучше всего делать ваши свойства недоступными извне, с помощью ключевого слова private, поскольку это помогает сохранить объекты отделенными от остальной части вашего кода.
  • Свойства с ключевым словом protected могут быть доступны с помощью методов внутри класса, а также в классах, которые являются наследниками родительского класса. Чтобы добавить в класс свойство, нужно перед ним написать одно из ключевых слов public, private или protected:

Добавим в класс User свойство для хранения имени пользователя:

Обратите внимание, что при создании свойства, мы присваиваем ему пустую строку — «» . Это означает, что, когда новое свойство объекта $username будет создано, то ему будет присвоена пустая строка. Как и в случае с обычными переменными, при создании свойств им не обязательно присваивать какие-то значения, но часто это очень хорошая идея. Если вы не присвоите свойству значие, то ему по умолчанию будет установлено значение null.

Доступ к свойствам

Чтобы получить доступ к объекту нужно использовать оператор «->», следующим образом:

Попробуйте так сделать. Давайте создадим скрипт, который объявляет класс User и его свойства, создает новые объекты User, а затем устанавливает и считывает свойство username:

Если вы запустите указанный выше код, то в результате будет выведена строка «Петя», которая является значением свойства $User->username. Как можно заметить, свойство объекта используется обычная переменная. Можно прочитать его значение и присвоить ему новое.

Методы класса

Что можно сказать о добавлении методов класса? Как уже упоминалось ранее, методы это обычные функции, которые являются частью класса. Поэтому нет ничего удивительного в том, что можно создавать методы, как любые другие функции с помощью ключевого слова function. Единственное различие заключается в том, что вам следует также добавлять ключевые слова public, private или protected перед объявлением метода, также как в случае свойств:

Как и в случае со свойствами, методы с ключевым словом public могут быть использованы в любом месте. Методы с ключевым словом private могут вызываться только с помощью других методов внутри класса. И методы с ключевым словом protected могут быть вызваны методами внутри класса и в любых производных классах, то есть те, которые являются потомками родительского класса.

Добавим некоторые методы для нашего класса User:

  • Свойство $SignIn с ключевым словом private со значением, которое указывает, вошёл ли пользователь на сайт или нет.
  • Метод, называемый signin(), который «пропускает» пользователя на сайт, устанавливая значение свойства $SignIn в значение true.
  • Метод, называемый signout(), который «выпускает» пользователя с сайта, устанавливая значение свойства $SignInв значение false.
  • Метод, называемый isSignIn() возвращает значение свойства $SignIn.

Обратите внимание на то, что мы использовали новое ключевое слово $this внутри наших методов. В контексте метода объект ссылается на самого себя с помощью специальной переменной $this. С помощью $this метод может получить доступ к любому другому свойству и методу объекта. Подробнее о том, как в случае $this работает механизм ссылок в PHP.

Например, метод signin() имеет доступ к свойству $SignIn этого же объекта, используя конструкцию $this->SignIn.

Кстати, свойство $SignIn является недоступным (private), поэтому доступ к нему осуществляется только через методы signin(), signout() и isSignIn(). Это хороший подход, поскольку он сохраняет внутреннюю информацию об объекте. Он запрещает доступ во внешнем коде к тому, как происходит запись входа или выхода пользователя на сайт. Использование недоступных (private) свойств, там где это возможно, позволяет сохранить объекты самостоятельными, переносимыми и безопасными.

Свойство $username сделано доступным (public) главным образом для того, чтобы показать, как это работает. В реальных условиях вы, возможно, захотите сделать $username недоступным и добавите доступные (public) методы для чтения и записи имени пользователя, если это необходимо в вашем случае.

Примеры работы с методами в ООП

Для вызова объекта, нужно использовать оператор «->»:

Этот код работает как обычный вызов функции. Вы можете передавать аргументы в круглых скобках (при условии, что метод может принимать аргументы). Кроме того метод может возвращать значения, которые вы можете использовать по своему усмотрению. Теперь добавим некоторые методы в наш класс User и попробуем использовать их:

Указанные выше скрипт отображает следующее:

Вот как работает скрипт:

  • После определения класса User мы создаем новый объект User и храним его значение в переменной $User. Установим имя пользователя, как «Петя».
  • Затем вызовем метод $User->isSignIn(), чтобы определить, вошёл ли пользователь на сайт. Метод IsSignIn() возвращает значение свойства $SignIn. Пока свойство $SignIn по умолчанию false , метод isSignIn() возвращает значение false в вызывающий код, в результате чего появляется сообщение «Петя вышел из системы».
  • Далее мы вызываем метод signin(). Он устанавливает свойство $SignIn в значение true .
    Теперь, когда мы вызываем метод isSignIn() он возвращает значение true и выводит строку «Петя вошел в систему».
  • Затем вызываем метод signout(), который устанавливает $SignIn в значение false.
    И наконец, мы вызываем метод isSignIn() в третий раз. В этот раз метод возвращает значение false, так как свойство $SignIn имеет значение false. Поэтому ещё раз появляется строка «Петя вышел из системы».

В случае, если вы не знакомы с тернарным оператором «?:», который используется в примере, то можете больше узнать о нём. Это компактный вариант условного оператора «if … else».

Успешного вам освоения языка программирования PHP на реальных примерах!

10 принципов ООП, о которых стоит знать каждому программисту

Многим опытным разработчикам, вероятно, знакома методология объектно-ориентированного программирования (ООП). Кроме известных её принципов (абстракция, инкапсуляция, полиморфизм, наследование и т. д.) существуют и другие — менее известные, но не менее важные и полезные для реализации. Некоторые из них собраны в специальный блок и известны по акрониму SOLID. Эта статья расскажет об этих и других существующих принципах объектно-ориентированной разработки и о том, какие преимущества они предлагают.

Принцип единственной ответственности (SRP)

Соответствует букве S акронима SOLID. Согласно этому принципу, не должно быть более одной причины для изменения класса, или класс должен всегда обрабатывать одну функциональность.

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

Принцип открытости/закрытости (OCP)

Соответствует букве O акронима SOLID. Принцип можно выразить так: «Классы, методы или функции должны быть открыты для расширения (добавления новой функциональности) и закрыты для модификации». Такой подход запрещает кому-либо изменять уже опробованный и протестированный код, а значит, он не ломается. В этом и состоит основное преимущество такого подхода.

Ниже приведён пример кода на Java, который нарушает этот принцип:

А вот пример после рефакторинга. Теперь соблюдается принцип открытости/закрытости: при добавлении новой реализации Shape не нужно менять код GraphicEditor .

Принцип подстановки Барбары Лисков (LSP)

Соответствует букве L акронима SOLID. Согласно этому принципу подтипы должны быть заменяемыми для супертипа. Другими словами, методы или функции, работающие с суперклассом, должны иметь возможность без проблем работать также и с его подклассами.

«Росбанк», Москва, до 60 000 ₽ (до налогов)

LSP тесно связан с принципом единственной ответственности и принципом разделения интерфейса.

Если класс реализует больше функциональности, чем подкласс, то последний может не поддерживать некоторые функции и тем самым нарушает данный принцип.

Ниже приведён пример такого кода на Java:

Функция resize() провоцирует неявную ошибку при работе с экземпляром класса Square , потому что позволяет устанавливать отличные друг от друга значения ширины и высоты. Согласно принципу LSP, функции, использующие ссылки на базовые классы, должны иметь возможность использовать объекты производных классов, не зная об этом. Поэтому для корректной работы функция resize() должна проверять, является ли передаваемый объект экземпляром класса Square, и в этом случае не позволять установить разные значения ширины и высоты. Отсюда идёт нарушение принципа.

Принцип разделения интерфейса (ISP)

Соответствует букве I акронима SOLID. Этот принцип подразумевает, что интерфейс, который не используется, не должен быть реализован.

В основном это происходит, когда один интерфейс содержит несколько функциональностей, и клиенту нужна только одна из них, а другие — нет.

Написание интерфейса — сложная задача. Когда он готов, вы не сможете изменить его, не нарушив всю реализацию.

Ещё одно преимущество этого принципа в Java заключается в том, что интерфейс имеет недостаток. Необходимо сначала реализовать все методы, прежде чем какой-либо класс сможет их использовать. Поэтому наличие единственной функциональности означает меньшее количество методов для реализации.

Принцип инверсии зависимостей (DIP)

Соответствует букве D акронима SOLID. Прелесть этого принципа проектирования в том, что любой класс легко тестируется с помощью фиктивного объекта и проще в обслуживании, потому что код создания объекта централизован, а клиентский код не перегружен им.

Ниже приведён пример кода Java, который нарушает принцип инверсии зависимости:

Пример демонстрирует, что AppManager зависит от EventLogWriter . Если вам нужно использовать другой способ уведомления клиента (например push-уведомления, SMS или электронную почту), необходимо изменить класс AppManager .

Эту проблему можно решить с помощью принципа инверсии зависимостей. Вместо того, чтобы AppManager запрашивал EventLogWriter , последний следует внедрить в AppManager явно. Плюсом реализации общего интерфейса позволить внедрять любую реализацию для других способов уведомления.

Теперь перейдём к принципам, которые не входят в пятёрку SOLID, но не менее важны.

DRY (Don’t Repeat Yourself)

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

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

Но важно не злоупотреблять этим принципом. Например, один и тот же код не подойдёт для проверки OrderId и SSN. Их форматы могут не совпадать, и на выходе функция выдаст некорректный результат. В качестве решения можно предусмотреть в методе проверку форматов для подобных наборов чисел.

Инкапсуляция изменяющегося кода

Сервисы стремительно развиваются. Продакшн подразумевает постоянные изменения кода и его поддержку. Отсюда следует второй принцип ООП — инкапсуляция кода, который с большой вероятностью будет изменён в будущем.

Преимущество этого принципа ООП заключается в том, что инкапсулированный код легко тестировать и поддерживать.

Воспользуйтесь алгоритмом, по которому переменные и методы по умолчанию имеют спецификатор private. Затем шаг за шагом увеличиваете доступ при необходимости (с private на protected, с protected на public).

Одним из вариантов инкапсуляции является Фабричный метод. Он инкапсулирует код создания объекта и обеспечивает гибкость для последующего создания новых объектов без влияния на существующий код.

Композиция вместо наследования

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

Композиция позволяет изменять поведение класса прямо во время выполнения через установку его свойств. Реализуя интерфейсы, вы, таким образом, используете полиморфизм, который обеспечивает более гибкую реализацию.

«Effective Java» Джошуа Блоха также советует отдавать предпочтение композиции вместо наследования. Если вы всё ещё не уверены, вы также можете посмотреть здесь, чтобы узнать, почему композиция лучше, чем наследование для повторного использования кода и его функциональности.

Программирование для интерфейса

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

Другими словами, нужно использовать тип интерфейса для переменных, возвращаемых типов или типа аргумента метода. Например, использовать для хранения объекта суперкласс, а не подкласс.

Это также рекомендовано во многих книгах по Java, в том числе в Effective Java и Head First design pattern.

Ниже приведён пример для интерфейса в Java:

Принцип делегирования

Не делайте всё самостоятельно, делегируйте это в соответствующий класс. Классическим примером этого принципа являются методы equals() и hashCode() в Java. Если нужно сравнить два объекта, это действие поручается соответствующему классу вместо клиентского.

Основным преимуществом этого принципа является отсутствие дублирования кода и довольно простое изменение поведения. Этот принцип относится также к делегированию событий (событие делегируется соответствующему обработчику).

Заключение

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

Просто о сложном: что такое объектно-ориентированное программирование (ООП)?

Объектно-ориентированное программирование — это шаблон проектирования ПО, позволяющий решать задачи разработчика с точки зрения взаимодействия объектов. При этом большая часть объектно-ориентированных языков, например, Ruby, Python, Java, C++ наследуют на основе классов. Если говорить о JavaScript, то в нём ООП реализуется через прототипное наследование.

Наиболее удачное и популярное определение ООП звучит следующим образом — это методология программирования, которая основана на представлении программы в виде совокупности ряда объектов, причём каждый из этих объектов — это экземпляр определённого класса.

На сегодняшний день ООП — наиболее распространённый метод разработки ПО. Но использование этого метода предполагает понимание ряда принципов. О них и поговорим.

Сущность, определения и принципы ООП

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

Наследование

Это механизм, позволяющий описать новый класс на основании родительского (существующего). Причём функциональность и свойства родительского класса заимствуются новым.

Иными словами, когда вы применяете наследование в программировании, отпадает необходимость реализовывать общий базовый функционал прочих классов, так как вполне достаточно применить наследование, благодаря которому ваш класс сразу будет обладать нужными родительскими знаниями.

Для чего нужно наследование в ООП, и какие преимущества оно даёт программированию? Главный плюс — повторное использование кода. Как правило, методы и поля, описанные в родительских классах, можно переиспользовать в классах-потомках. В результате: — приходится писать меньше кода; — повышается качество кода, он упрощается.

При этом сам механизм довольно гибок, поэтому недостающую в потомках функциональность всегда можно дописать отдельно.

Абстракция

Тут всё предельно просто. При абстракции выделяются главные и наиболее значимые характеристики предмета, одновременно с этим отбрасываются второстепенные и незначительные.

Простой пример: представьте, что мы создаём картотеку сотрудников компании. Естественно, мы вносим их основные характеристики: дату рождения, ИНН, ФИО, номер социального страхования. Разумеется, нас не интересуют ни рост, ни цвет глаз, ни длина волос. То есть мы абстрагируемся от ненужной информации.

А что если нужно создать картотеку модельного агентства? Согласитесь, что здесь ситуация кардинально меняется и вряд ли нам понадобится индивидуальный номер налогоплательщика, а вот данные о внешности будут очень кстати.

Инкапсуляция

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

Поясним термин на примере вашего имени. Его знают друзья, коллеги, родственники. Но они не могут изменить ваше имя, т. к., согласно методу ООП, у них нет к этому доступа. Всё потому, что изменения «инкапсулированы» в паспортном столе и только вы сами можете что-либо подправить. Пример инкапсуляции в объектно-ориентированном программировании — модификаторы доступа, геттеры-сеттеры и т. д.

Полиморфизм

Полиморфизм позволяет работать с несколькими типами таким образом, как будто это один и тот же тип. И поведение объектов в данном случае будет разным и зависит от того, к какому типу они принадлежат. В общем, полиморфизм указывает, какую версию метода текущего объекта необходимо запустить. Также полиморфизмом называют способность функции обрабатывать данные разных типов. Пример — автомат на вокзале, принимающий для оплаты как наличные, так и банковские карты.

Причины появления объектно-ориентированного программирования

Некоторые задаются вопросом, а почему вообще возник метод ООП? Вроде бы и работающие инструменты у программистов были, и процедурные языки, и методов реализации хватало.

Тем не менее пришло время, когда без ООП стало невозможно быстро и качественно решать поставленные задачи. Во многом это связано с усложнением этих самых задач. Усложнились типы данных, возникла необходимость делить задачу на части. В итоге программы стали представлять собой древа с кучей ветвлений и вариантов работы. Реализовать всё это, используя лишь процедурное программирование, стало весьма сложным и малореалистичным.

Топ-пост этого месяца:  Актуальные тренды веб-дизайна полноэкранные домашние страницы
Добавить комментарий