Php шаблоны проектирования: Паттерны проектирования на PHP

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

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

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

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

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

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

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

Оригинал книги: «How to Use Objects: Code and Concepts», Holger Gast, 832 pages, ISBN 9780321995544, 2016

ЗДЕСЬ — читайте полное СОДЕРЖАНИЕ книги «Объектно-ориентированное проектирование»
ЗДЕСЬ — читайте ВВЕДЕНИЕ из книги «Объектно-ориентированное проектирование»
ЗДЕСЬ — читайте 8 Главу «Краткое введение в потоки выполнения» из книги «Объектно-ориентированное проектирование: концепции и программный код»

(книгу можно заказать-купить в Библио-Глобус)
(заказать-купить книгу «Объектно-ориентированное проектирование» в интернет-магазине biblio-globus.ru)

(книгу можно заказать в КОМБУКе — самая низкая цена в России)
(заказать-купить книгу-справочник «Объектно-ориентированное проектирование» в интернет-магазине ComBook.ru)

(книгу можно заказать-купить в Ozon.ru)
(заказать-купить книгу по «Объектно-ориентированное проектирование» в онлайн-мегамаркете Ozon.ru)

(книгу можно заказать-купить в DiaMail Украина)
(заказать-купить книгу «Объектно-ориентированное проектирование» в diamail.com.ua)

Читайте отдельное сообщение в моем блоге о книге «Объектно-ориентированное проектирование: концепции и программный код»

Назначение книги «Компьютерные науки. Базовый курс» — предоставить читателю всестороннее представление о предмете компьютерных наук (Computer Science), охватывающее все его аспекты, от сугубо практических до полностью абстрактных

В 13-ом издании книги «Компьютерные науки. Базовый курс» Гленна Брукшира и Денниса Брилова учтён новый международный стандарт преподавания компьютерных наук CS2013 — Computer Science Curricula 2013 (ACM/IEEE-CS)

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

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

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

На официальном веб-сайте книги можно найти дополнительные материалы по данному курсу

ОБ АВТОРАХ

Деннис Брилов, доцент отделения математики, статистики и компьютерных наук университета Маркетт с 2005 г., недавно получил высшую педагогическую награду университета — премию Teaching Excellence Award. Привлечен в качестве соавтора при подготовке 12- и 13-го изданий этой книги

_____________
Оригинал книги: «Computer Science: An Overview», Glenn Brookshear, Dennis Brylow, 13th Edition, 736 pages, ISBN 9780134875460, March 2018

ЗДЕСЬ — читайте ВВЕДЕНИЕ из книги «Компьютерные науки. Базовый курс»
ЗДЕСЬ — читайте полное СОДЕРЖАНИЕ книги «Компьютерные науки. Базовый курс»
ЗДЕСЬ — читайте 7 Главу «Технология разработки программного обеспечения» из книги Гленна Брукшира и Денниса Брилова «Компьютерные науки. Базовый курс»

(книгу можно заказать-купить в книжном магазине «Москва»)
(заказать-купить книгу «Компьютерные науки. Базовый курс» (13-е издание) в интернет-магазине www.moscowbooks.ru)

(книгу можно заказать-купить в «Московский Дом Книги» (МДК) на Арбате)
(заказать-купить книгу «Компьютерные науки. Базовый курс» (13-е издание) в интернет-магазине mdk-arbat.ru)

(книгу можно заказать-купить в Библио-Глобус)
(заказать-купить книгу «Компьютерные науки. Базовый курс» (13-е издание) в интернет-магазине biblio-globus.ru)

(книгу можно заказать-купить в КОМБУКе — самая низкая цена в России)
(заказать-купить книгу «Компьютерные науки. Базовый курс» (13-е издание) в интернет-магазине ComBook.ru)

(книгу можно заказать-купить в Ozon.ru)
(заказать-купить книгу «Компьютерные науки. Базовый курс» (13-е издание) в онлайн-мегамаркете Ozon.ru)

(книгу можно заказать-купить в DiaMail Украина)
(заказать-купить книгу «Компьютерные науки. Базовый курс» (13-е издание) в интернет-магазине diamail.com.ua)

(книгу можно заказать-купить в bizbook.ua Украина)
(заказать-купить книгу «Компьютерные науки. Базовый курс» (13-е издание) в интернет-магазине bizbook.ua)

Книга обсуждается в отдельном сообщении моего блога
_________________________________________
СЛЕДИТЕ ЗА ИЗМЕНЕНИЯМИ В ЭТОМ СООБЩЕНИИ —
последнее обновление — 4 декабря 2019 года
_________________________________________

P.S. Только Ваша активная позиция в столь непростое время будет способствовать появлению новых и нужных Вам книг. А также, способствовать повышению качества книг, издаваемых издательской группой «ДИАЛЕКТИКА—ВИЛЬЯМС»

_____________________________________________
Ваши комментарии перед публикацией я просматриваю. Поэтому, я оставляю за собой право публиковать или нет комментарии с подписью Анонимный

PHP. Объекты, шаблоны и методики программирования. Мэтт Зандстра

Четвертое издание книги было пересмотрено и дополнено новым материалом. Книга начинается с обзора объектно-ориентированных возможностей PHP, в который включены важные темы, такие как определение классов, наследование, инкапсуляция, рефлексия и многое другое. Этот материал закладывает основы объектно-ориентированного проектирования и программирования на PHP. Вы изучите также некоторые основополагающие принципы проектирования. В этом издании книги также описаны возможности, появившиеся в PHP версии 5.4, такие как трейты, дополнительные расширения на основе рефлексии, уточнения типов параметров методов, улучшенная обработка исключений и много других мелких расширений языка. Следующая часть книги посвящена шаблонам проектирования, которые органически дополняют тему ООП и являются описанием элегантных решений распространенных проблем, возникающих при проектировании программного обеспечения. В ней описываются концепции шаблонов проектирования и показаны способы реализации нескольких важных шаблонов в приложениях на PHP. В этой же части приведен материал, посвященный шаблонам корпоративных приложений и баз данных. В последней части книги описывается несколько важных утилит и методик, помогающих осуществить успешный проект на основе разрозненных кусков кода. В этой части книги описано, как управлять работой нескольких программистов с помощью Git, как выполнить построение и развертывание проекта с помощью Phing и PEAR. Вы также изучите стратегии автоматического тестирования и построения проектов. Кроме обсуждения передовых средств построения и тестирования проектов, а также серверов непрерывной интеграции, в последней части книги описаны лучшие методики организации работы на основе системы контроля версий Git. Тем самым была отражена общая тенденция перехода на новую платформу, которая наметилась в среде разработчиков с момента выхода третьего издания книги. Эта книга посвящена трем важным темам: основам объектов, принципам объектно-ориентированного проектирования и лучшим методикам их применения. Изучив их в комплексе читатель сможет создавать первоклассные и отказоустойчивые программные системы. 
Основные темы книги: 
Основы объектов: написание классов и методов, создание объектов, разработка сложной иерархии классов на основе наследования. 
Сложные объектно-ориентированные темы, включая статические методы и свойства, обработка ошибочных ситуаций с помощью исключений, создание абстрактных классов и интерфейсов. 
Общие сведения об основных принципах объектно-ориентированного проектирования и их использование для создания эффективной структуры классов и объектов приложения. 
Изучение базовых шаблонов проектирования, их структуры и основных принципов, положенных в их основу. 
Описание ряда основополагающих шаблонов, которые можно применить в собственных проектах. 
Изучение методик и средств, гарантирующих успешное выполнение проекта, включая модульное тестирование, контроль версий, построение и развертывание проекта, управление пакетами, а также сервер непрерывной интеграции Jenkins.

Шаблоны проектирования «банды четырёх (GoF)» — bool.dev

Что такое паттерны проектирования?

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

Концепцию паттернов впервые описал Кристофер Александер в книге «Язык шаблонов. Города. Здания. Строительство».

Идея показалась привлекательной авторам Эриху Гамму, Ричарду Хелму, Ральфу Джонсону и Джону Влиссидесу, их принято называть «бандой четырёх» (Gang of Four). В 1995 году они написали книгу «Design Patterns: Elements of Reusable Object-Oriented Software», в которой применили концепцию типовых паттернов в программировании. В книгу вошли 23 паттерна, решающие различные проблемы объектно-ориентированного дизайна.

Зачем знать паттерны?

Самое главная причина — паттерны упрощают проектирование и поддержку программ.

• Проверенные решения.

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

• Стандартизация кода.

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

• Общий язык.

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

Каталог шаблонов проектирования

Порождающие паттерны:

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

1. Абстрактная фабрика (Abstract Factory)

2. Строитель (Builder)

3. Фабричный метод (Factory Method)

4. Прототип (Prototype)

5. Одиночка (Singleton)

Структурные паттерны:

Структурные паттерны — рассматривает, как классы и объекты образуют более крупные структуры — более сложные по характеру классы и объекты. К таким шаблонам относятся:

1. Адаптер (Adapter)

2. Мост (Bridge)

3. Компоновщик (Composite)

4. Декоратор (Decorator)

5. Фасад (Facade)

6. Приспособленец (Flyweight)

7. Заместитель (Proxy)

Поведенческие паттерны:

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

1. Цепочка обязанностей (Chain of responsibility)

2. Команда (Command)

3. Интерпретатор (Interpreter)

4. Итератор (Iterator)

5. Посредник (Mediator)

6. Хранитель (Memento)

7. Наблюдатель (Observer)

8. Состояние (State)

9. Стратегия (Strategy)

10. Шаблонный метод (Template method)

11. Посетитель (Visitor)

шаблонов проектирования PHP — Netgen

Практические шаблоны проектирования на PHP, Хьюго Хамон

Recorded @ Web Summer Camp 2018

Созданные в 70-х годах «бандой четырех», шаблоны проектирования представляют собой универсальные многократно используемые абстрактные решения для решения часто повторяющихся задач. проблемы в разработке программного обеспечения. Объектно-ориентированные фреймворки, такие как Symfony, используют их для разработки надежного, расширяемого и тестируемого кода, позволяя разработчикам создавать свои приложения на прочном фундаменте. На этом семинаре вы (повторно) откроете для себя полезные шаблоны, такие как Builder, Factory Method, Abstract Factory, Composite, Decorator и Adapter в первом и Flyweight, Memento, Strategy, Template Method, Mediator или Visitor во второй день семинара.

Базовый CQRS и поиск событий с Prooph, Марко Пиветта

Записано в летнем веб-лагере 2017

CQRS и поиск событий являются сложными, особенно если обращаться к ним впервые если делать с нуля. Марко поможет вам с установкой, настройкой и запуском Prooph. Вы создадите довольно простой агрегат на основе событий, чтобы понять, как организовать вещи внутри стека CQRS / ES и как значительно упростить некоторые проблемы, которые обычно вызывают очень большие проблемы с производительностью при масштабировании.

Бережливое и функциональное моделирование предметной области, М. Дуарте

Записано в летнем веб-лагере, 2017 г.

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

Начало работы с шаблонами проектирования в PHP с шаблоном Factory | автор: Якуб Капусчик

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

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

Каждый блок должен расширять абстрактный класс Box и реализовывать метод, который генерирует некоторый HTML-код:

… и принимает экземпляр FileItem в качестве параметра.

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

или Видео:

или Аудио:

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

Давайте иметь минимальный интерфейс того, что нужно сделать.

А с помощью простой реализации мы можем все запустить и запустить.

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

Таким образом, Factory Method состоит из следующих элементов:

1. Product ( Box ) — определяет интерфейс для элементов, созданных на заводе
2. Concrete products ( ImgBox , VideoBox , AudioBox ). ) — реализация продукта
3. Creator ( Factory ) — определяет интерфейс, используемый для создания объекта типа Product
4. Concrete Creator ( BoxFactory ) — реализация Creator, который производит бетонные изделия

Вы должны Завод, когда нужно:

• построить сложный объект данного семейства в зависимости от правил, предоставленных извне
• Отдельный процесс создания новых объектов от их реализаций

Пересмотр концепций паттернов проектирования PHP в Drupal 8

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

Эта техника Ричарда Фейнмана утверждает, что окончательная проверка ваших знаний — это когда вы можете передать их другому человеку.

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

• Шаблон проектирования Singleton
• Заводской образец дизайна
• Шаблон проектирования посредника
• Самоанализ и размышление PHP
• Внедрение служб и зависимостей

Небольшая заметка перед тем, как мы начнем —

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

Шаблоны проектирования описывают взаимодействующие объекты и классы, которые настраиваются для решения проблемы в определенном контексте.

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

Зачем они нужны? (Сверхспособности шаблонов проектирования)

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

Классификация GoF (Группа четырех шаблонов проектирования)

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

Они называются шаблонами дизайна GoF, потому что шаблоны были первоначально написаны и разработаны Эрихом Гаммой, Ричардом Хелмом, Ральфом Джонсоном и Джоном Влиссидесом,

Начнем с:

1. Шаблон проектирования Singleton

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

Льготы —

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

Давайте посмотрим на пример, который объясняет, как это работает.В этом примере предполагается, что вы знакомы с созданием настраиваемого модуля и создания маршрутизации и контроллеров в Drupal 8-

1. 1. Здесь я создал собственный маршрут с path / get-connection, который вызывает метод makeConnection класса контроллера MakeConnection:
      
   2. Давайте взглянем на метод makeConnection контроллера MakeConnection:
      Здесь вы можете увидеть, что метод создает экземпляр (объект) класса GetConnection, вызывая его метод get_instance ().Используя объект, я вызываю метод getConnection () 2 раза и распечатываю вывод каждой переменной с помощью функции отладчика, предоставляемой модулем Kint.
   4. В этом классе вы можете видеть, что внутри метода get_instance () я создаю объект класса (GetConnection) и возвращаю объект, если он уже создан / создан.
      

      Также в моем методе getConnection () я возвращаю хэш-код объекта, используя встроенную функцию php spl_object_hash ().Давайте посмотрим на вывод этого кода. Результат показывает одинаковые хэш-коды для обоих вызовов методов.
      Так экономится потребление памяти объектами. Также обратите внимание, что процесс создания объекта контролируется самим классом создания объекта.

2. Заводской шаблон проектирования (шаблон создания)

Заводской метод используется для создания объектов вместо прямого вызова конструктора.Шаблон фабрики просто отделяет процесс «создания объекта» от «бизнес-логики», создавая «фабричный класс», единственная ответственность которого заключается в создании «объектов».

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

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

Давайте посмотрим на пример, чтобы лучше понять это.

1. 1. Посмотрите на маршрутизацию YAML, которая инициирует создание объекта на основе некоторой логики:

      Здесь я создал маршрут с путем / get-content / {role} , который принимает роль пользователя в качестве аргумента и вызывает метод getContent () класса контроллера GetContent.

   2. В классе GetContent я создал объект класса ContentFactory , используя метод конструктора. Класс содержит метод getContent () со значением роли по умолчанию как null .
      
      Затем я вызвал метод класса ContentFactory в строке №. 22 и передали роль, которая добавлялась к URL-адресу в качестве аргумента.
      В конце концов, я вызвал метод getUserNameWithRole () для этой конкретной роли и вернул результат тем же методом.
   3. Класс фабрики :

      
      Здесь класс фабрики содержит процесс создания объекта на основе роли, переданной в URL-адресе. Это создает пользовательский объект класса UserRoleAuthenticated и UserRoleOther , с помощью которого я вызываю метод ( getUserNameWithRole () ) класса UserRoleAuthenticated и UserRoleOther .

   4. Давайте посмотрим на бизнес-логику в методе getUserNameWithRole () .

Этот метод содержит бизнес-логику для создания роли пользователя и возврата созданного пользователем с его ролью и именем пользователя.

Вот как разделение логики и создание объектов работает в фабричных шаблонах.

Примечание: Идеальный заводской шаблон будет включать логику создания динамического объекта.Для простоты я жестко запрограммировал роль пользователя в условии if для создания объекта определенного класса.

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

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

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

Используя пример, упомянутый в https://www.drupal.org/docs/8/creating-custom-modules/subscribe-to-and-dispatch-events, я создал простую реализацию в Drupal, которая подписывается на определенное событие и запускает действие, основанное на инициированном событии.

На основе события ConfigEvents :: Save я показываю сообщение с именем сохраненной конфигурации и выполненными с ней действиями, как показано ниже:

Вы можете обратиться к примеру в приведенной выше ссылке, чтобы узнать, как создавать События в Drupal и создавать свои собственные.

4. Самоанализ и рефлексия

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

Это полезно, когда выполнение классов или методов неизвестно во время разработки.

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

Функции самоанализа PHP:

1. 1. get_class (): метод, используемый для получения имени класса объекта
   2. class_exists (): проверяет, определен ли класс
   3. is_subclass_of (): метод, используемый для проверки, является ли объект подклассом родительского класса, переданного в качестве параметра
   4. get_parent_class (): метод, который возвращает имя класса родительского класса объекта

PHP поддерживает отражение через свой класс Reflection API.Он предоставляет большое количество классов и методов, которые можно использовать для решения задач отражения.

1. 1. Прекрасным примером самоанализа и отражения PHP является модуль Devel в Drupal.
   2. Назначение модуля Devel — разбить и отобразить информацию об элементе, которая включает имя класса, источник и информацию о методах.
   3. Точно так же модуль Kint, который поставляется с установкой Devel, отображает, какие методы включены в конкретный класс, а также их документацию и видимость методов / переменных.
   4. Взгляните на приведенный ниже пример фрагмента, который использует класс отражения и методы для отображения информации об объекте:

Вы можете узнать больше об этом здесь —

5. Внедрение служб и зависимостей

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

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

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

Подробнее о сервисах и внедрении зависимостей можно узнать здесь .

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

Никогда не переставай учиться!

% PDF-1.6 % 980 0 объект> эндобдж xref 980 128 0000000016 00000 н. 0000006940 00000 п. 0000007085 00000 н. 0000007146 00000 н. 0000007741 00000 н. 0000007881 00000 н. 0000008042 00000 н. 0000008063 00000 н. 0000012373 00000 п. 0000012511 00000 п. 0000017868 00000 п. 0000018005 00000 п. 0000018138 00000 п. 0000023396 00000 п. 0000023535 00000 п. 0000028624 00000 п. 0000033937 00000 п. 0000038739 00000 п. 0000042736 00000 п. 0000047047 00000 п. 0000195644 00000 н. 0000196733 00000 н. 0000196934 00000 н. 0000197004 00000 н. 0000197205 00000 н. 0000197233 00000 н. 0000197567 00000 н. 0000201435 00000 н. 0000201634 00000 н. 0000201704 00000 н. 0000202095 00000 н. 0000202123 00000 н. 0000202644 00000 н. 0000204977 00000 н. 0000205176 00000 н. 0000205246 00000 н. 0000205522 00000 н. 0000205550 00000 н. 0000205958 00000 н. 0000207145 00000 н. 0000207349 00000 н. 0000207419 00000 н. 0000207621 00000 н. 0000207649 00000 н. 0000207985 00000 н. 0000235335 00000 п. 0000235532 00000 н. 0000235602 00000 н. 0000235862 00000 н. 0000235890 00000 н. 0000236276 00000 н. 0000236353 00000 п. 0000237127 00000 н. 0000237842 00000 п. 0000260211 00000 н. 0000279484 00000 н. 0000296512 00000 н. 0000300892 00000 п. 0000321723 00000 н. 0000337354 00000 н. 0000360987 00000 н. 0000378115 00000 н. 0000401268 00000 н. 0000426720 00000 н. 0000448445 00000 н. 0000473750 00000 н. 0000499318 00000 н. 0000521928 00000 н. 0000536148 00000 н. 0000558279 00000 н. 0000570805 00000 н. 0000592442 00000 н. 0000614562 00000 н. 0000637139 00000 п. 0000663797 00000 н. 0000686644 00000 н. 0000706485 00000 н. 0000713065 00000 н. 0000713139 00000 н. 0000713265 00000 н. 0000713418 00000 н. 0000713526 00000 н. 0000713575 00000 н. 0000713663 00000 н. 0000713712 00000 н. 0000713788 00000 н. 0000713837 00000 н. 0000713955 00000 н. 0000714004 00000 н. 0000714117 00000 н. 0000714166 00000 н. 0000714265 00000 н. 0000714314 00000 н. 0000714436 00000 н. 0000714485 00000 н. 0000714597 00000 н. 0000714646 00000 н. 0000714765 00000 н. 0000714814 00000 н. 0000714928 00000 н. 0000714977 00000 н. 0000715085 00000 н. 0000715134 00000 н. 0000715244 00000 н. 0000715293 00000 н. 0000715399 00000 н. 0000715448 00000 н. 0000715562 00000 н. 0000715611 00000 н. 0000715721 00000 н. 0000715770 00000 н. 0000715880 00000 н. 0000715929 00000 н. 0000716039 00000 н. 0000716088 00000 н. 0000716200 00000 н. 0000716249 00000 н. 0000716359 00000 н. 0000716408 00000 н. 0000716519 00000 н. 0000716568 00000 н. 0000716677 00000 н. 0000716726 00000 н. 0000716848 00000 н. 0000716896 00000 н. 0000717007 00000 н. 0000717055 00000 п. 0000002856 00000 н. трейлер ] >> startxref 0 %% EOF 1107 0 obj> поток xZ {tSe»9I [(2; q | O܀ C S 84 BCyC8 @ (W: * qĩG5 {$ TκO ~ oo i

Паттернов проектирования состояний и стратегий в PHP | Якуб Капусчик

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

У нас есть три возможных настроения, которые имеют один и тот же интерфейс.

Наш человек может быть счастлив. Тогда он очень милый и говорит хорошие вещи.

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

Последнее возможное настроение — гнев.

Отлично. Давайте посмотрим на наше приложение в действии и на то, как Ян будет себя вести.

Размышляя об использовании шаблонов проектирования, важно рассмотреть альтернативные способы достижения того же поведения. Мы могли бы:

1. Включить ifs, изменение ответов в методах Person в зависимости от его состояния
2. Создание специальных классов, таких как AngryPerson , NeutralPerson , HappyPerson

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

Шаблон состояния состоит из трех элементов:

• Context ( Person ) — использует состояния и определяет интерфейс для клиентов
• State ( Mood ) — интерфейс каждого состояния
• Concrete State ( Happy , Neutral , Angry ) — реализация State

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

Популярные примеры использования Государственного паттерна:

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

(PDF) Использование шаблонов проектирования на основе PHP Фреймворки веб-приложений

2.4 Позиционирование проблемы

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

в настоящее время, и, если да, то чтобы в какой степени.

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

шаблонов проектирования также используются при разработке веб-приложений.Следовательно, обзор

нескольких проектов может привести к обнаружению общих тенденций в использовании шаблонов дизайна

.

Существует множество различных шаблонов проектирования, но многие популярные шаблоны проектирования ООП

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

были рассмотрены следующие: Абстрактная фабрика, Контроллер приложений,

Active Record, Адаптер, Строитель, Команда, Составной, Пользовательский тег, Отображение данных,

Декоратор, Внедрение зависимостей, Модель домена, Заводской метод Front Controller,

Handle-Body, Iterator, MockObject, Model-View-Controller, Mono State, Observer,

Proxy, Registry, Server Stub, Singleton, Specification, State, Strategy, Table Data

Gateway, Template View, Шаблонный метод, преобразование представления, ValueObject, View

Помощник, посетитель.Подробное описание этих шаблонов проектирования см. В Приложении A.

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

и сколько проектов их используют. Результаты могут быть использованы в качестве гипотез

относительно целей, для которых используются шаблоны проектирования — используются ли они для повторного использования

фрагментов исходного кода? Используются ли они для разделения проекта на логические

компонентов, чтобы упростить понимание и разработку? Или

— это просто модное заявление, направленное на рекламу собственного продукта?

2.5 Преимущества исследования существующей ситуации

Преимущества изучения существующей ситуации при использовании шаблонов проектирования

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

x Информация о существующей ситуации помогает другим начать использовать дизайн шаблонов,

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

в более быстром тестировании предложенных шаблонов проектирования. Новичок может сразу

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

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

x Получена дополнительная информация о разнообразии и использовании шаблонов проектирования.

Исследование не может сразу привести к точным ответам на все возможные вопросы,

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

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

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

, которые вообще не используются.

x Можно сделать выводы, выполняют ли шаблоны проектирования свою миссию на первом месте

. Помогают ли они людям понять архитектуру и логику программного обеспечения? До

в какой степени шаблоны проектирования поддерживают принцип «разделяй и властвуй», т.е.

, в какой степени логика систем описывается шаблонами проектирования?

56 DATORZINĀTNE UN INFORMĀCIJAS TEHNOLOĢIJAS

LURaksti733-datorzin.indd 56LURaksti733-datorzin.indd 56 2008.31.03. 15: 05: 402008.03.31. 15:05:40

Шаблоны проектирования для людей

Шаблоны проектирования — это решения повторяющихся проблем; Рекомендации по решению определенных проблем . Это не классы, пакеты или библиотеки, которые вы можете подключить к своему приложению и дождаться волшебства. Это, скорее, рекомендации о том, как решать определенные проблемы в определенных ситуациях.

Шаблоны проектирования — это решения повторяющихся проблем; рекомендации по решению определенных проблем

Википедия описывает их как

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

Будьте осторожны

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

• Шаблоны проектирования — не панацея от всех ваших проблем.
• Не пытайтесь заставить их; плохие вещи должны произойти, если это произойдет.
• Имейте в виду, что шаблоны проектирования — это решения – проблем, а не решения , находящие проблемы; так что не задумывайтесь.
• При правильном использовании в правильном месте они могут оказаться спасителем; иначе они могут привести к ужасному беспорядку в коде.

Также обратите внимание, что приведенные ниже примеры кода относятся к PHP-7, однако это не должно вас останавливать, потому что концепции в любом случае одинаковы.

Типы шаблонов проектирования

Это руководство посвящено шаблонам проектирования «Банда четырех» (GoF) и относится к четырем авторам книги, которые представили эти шаблоны проектирования. Существует три типа шаблонов проектирования:

Шаблоны проектирования

Простыми словами

Шаблоны создания ориентированы на создание экземпляров объекта или группы связанных объектов.

Википедия говорит:

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

Существует 6 типов шаблонов создания

🏠 Simple Factory

Пример из реальной жизни

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

Простыми словами

Простая фабрика просто генерирует экземпляр для клиента без предоставления клиенту какой-либо логики создания экземпляра

Википедия говорит

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

Программный пример

Прежде всего у нас есть интерфейс двери и реализация

  интерфейс Дверь
{
    публичная функция getWidth (): float;
    публичная функция getHeight (): float;
}

класс WoodenDoor реализует Door
{
    защищенная ширина $;
    защищенная высота $;

    публичная функция __construct (float $ width, float $ height)
    {
        $ this-> width = $ width;
        $ this-> height = $ height;
    }

    публичная функция getWidth (): float
    {
        вернуть $ this-> width;
    }

    публичная функция getHeight (): float
    {
        вернуть $ this-> height;
    }
}
  

Затем у нас есть наша дверная фабрика, которая делает двери и возвращает их

  class DoorFactory
{
    общедоступная статическая функция makeDoor ($ width, $ height): Дверь
    {
        вернуть новую WoodenDoor ($ width, $ height);
    }
}
  

И затем его можно использовать как

 
$ door = DoorFactory :: makeDoor (100, 200);

echo 'Ширина:'.$ door-> getWidth ();
echo 'Высота:'. $ door-> getHeight ();


$ door2 = DoorFactory :: makeDoor (50, 100);
  

Когда использовать?

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

🏭 Заводской метод

Пример из реальной жизни

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

Простыми словами

Он предоставляет способ делегировать логику создания экземпляров дочерним классам.

Википедия говорит:

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

Программный пример

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

  интерфейс Interviewer
{
    публичная функция askQuestions ();
}

class Developer реализует Interviewer
{
    публичная функция askQuestions ()
    {
        echo 'Спрашиваем о шаблонах проектирования!';
    }
}

class CommunityExecutive реализует Interviewer
{
    публичная функция askQuestions ()
    {
        echo «Спрашивать о строительстве общины»;
    }
}
  

Теперь давайте создадим наш HiringManager

  абстрактный класс HiringManager
{

    
    абстрактная защищенная функция makeInterviewer (): Interviewer;

    публичная функция takeInterview ()
    {
        $ интервьюер = $ this-> makeInterviewer ();
        $ интервьюер-> askQuestions ();
    }
}

  

Теперь любой ребенок может расширить его и предоставить необходимого интервьюера

  class DevelopmentManager extends HiringManager
{
    защищенная функция makeInterviewer (): Interviewer
    {
        вернуть новый Разработчик ();
    }
}

class MarketingManager расширяет HiringManager
{
    защищенная функция makeInterviewer (): Interviewer
    {
        вернуть новый CommunityExecutive ();
    }
}
  

, а затем его можно использовать как

  $ devManager = new DevelopmentManager ();
$ devManager-> takeInterview ();

$ marketingManager = новый MarketingManager ();
$ marketingManager-> takeInterview ();
  

Когда использовать?

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

🔨 Абстрактная фабрика

Реальный пример

Расширение нашего примера двери из Simple Factory. В зависимости от ваших потребностей вы можете получить деревянную дверь в магазине деревянных дверей, железную дверь в магазине железа или дверь из ПВХ в соответствующем магазине. Кроме того, вам может понадобиться парень с разными специальностями, чтобы приспособиться к двери, например, плотник для деревянной двери, сварщик для железной двери и т. Д.Как видите, теперь существует зависимость между дверьми, деревянной двери нужен плотник, железной двери нужен сварщик и т. Д.

Проще говоря

Завод фабрик; фабрика, которая группирует отдельные, но связанные / зависимые фабрики вместе без указания их конкретных классов.

Википедия говорит:

Шаблон абстрактной фабрики предоставляет способ инкапсулировать группу отдельных фабрик, имеющих общую тему, без указания их конкретных классов

Программный пример

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

  интерфейс Door
{
    публичная функция getDescription ();
}

класс WoodenDoor реализует Door
{
    публичная функция getDescription ()
    {
        эхо «Я - деревянная дверь»;
    }
}

класс IronDoor реализует Door
{
    публичная функция getDescription ()
    {
        эхо «Я железная дверь»;
    }
}
  

Тогда у нас есть несколько специалистов по установке для каждого типа дверей

  интерфейс DoorFittingExpert
{
    публичная функция getDescription ();
}

класс Welder реализует DoorFittingExpert
{
    публичная функция getDescription ()
    {
        echo «Я могу поставить только железные двери»;
    }
}

класс Carpenter реализует DoorFittingExpert
{
    публичная функция getDescription ()
    {
        echo «Я могу установить только деревянные двери»;
    }
}
  

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

  interface DoorFactory
{
    публичная функция makeDoor (): Door;
    публичная функция makeFittingExpert (): DoorFittingExpert;
}


Класс WoodenDoorFactory реализует DoorFactory
{
    публичная функция makeDoor (): Дверь
    {
        return new WoodenDoor ();
    }

    публичная функция makeFittingExpert (): DoorFittingExpert
    {
        вернуть новый Carpenter ();
    }
}


Класс IronDoorFactory реализует DoorFactory
{
    публичная функция makeDoor (): Дверь
    {
        вернуть новый IronDoor ();
    }

    публичная функция makeFittingExpert (): DoorFittingExpert
    {
        вернуть новый Welder ();
    }
}
  

И тогда его можно использовать как

  $ WoodenFactory = new WoodenDoorFactory ();

$ door = $ WoodenFactory-> makeDoor ();
$ expert = $ WoodenFactory-> makeFittingExpert ();

$ door-> getDescription ();
$ expert-> getDescription ();


$ ironFactory = новый IronDoorFactory ();

$ door = $ ironFactory-> makeDoor ();
$ expert = $ ironFactory-> makeFittingExpert ();

$ door-> getDescription ();
$ expert-> getDescription ();
  

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

Когда использовать?

Когда есть взаимосвязанные зависимости с непростой логикой создания

👷 Builder

Пример из реального мира

Представьте, что вы в Hardee’s и заказываете конкретную сделку, скажем, «Big Hardee», и они передать вам без вопросов ; это пример простой фабрики.Но бывают случаи, когда логика создания может включать больше шагов. Например, вам нужно индивидуальное предложение в Subway, у вас есть несколько вариантов приготовления гамбургера, например, какой хлеб вы хотите? какие соусы вы хотите? Какой сыр вы хотите? и т.д. В таких случаях на помощь приходит выкройка-строитель.

Простыми словами

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

Википедия говорит:

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

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

  общедоступная функция __construct ($ size, $ cheese = true, $ пепперони = true, $ Tomato = false, $ lettuce = true)
{
}
  

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

Программный пример

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

  class Burger
{
    защищенный размер $;

    защищенный $ сыр = ложь;
    защищенный $ пепперони = ложь;
    защищенный салат $ = false;
    защищенный $ томат = ложь;

    публичная функция __construct (BurgerBuilder $ builder)
    {
        $ this-> size = $ builder-> size;
        $ this-> сыр = $ builder-> сыр;
        $ this-> пепперони = $ builder-> пепперони;
        $ this-> lettuce = $ builder-> салат;
        $ this-> помидор = $ builder-> помидор;
    }
}
  

А потом у нас есть строитель

  class BurgerBuilder
{
    общедоступный размер $;

    общедоступный $ сыр = ложь;
    public $ пепперони = ложь;
    public $ lettuce = false;
    общедоступный $ помидор = ложь;

    публичная функция __construct (int $ size)
    {
        $ this-> size = $ size;
    }

    публичная функция addPepperoni ()
    {
        $ this-> пепперони = правда;
        вернуть $ this;
    }

    публичная функция addLettuce ()
    {
        $ this-> салат = правда;
        вернуть $ this;
    }

    публичная функция addCheese ()
    {
        $ this-> сыр = правда;
        вернуть $ this;
    }

    публичная функция addTomato ()
    {
        $ this-> помидор = правда;
        вернуть $ this;
    }

    публичная функция build (): Burger
    {
        вернуть новый бургер ($ this);
    }
}
  

И тогда его можно использовать как:

  $ burger = (новый BurgerBuilder (14))
                    -> addPepperoni ()
                    -> addLettuce ()
                    -> addTomato ()
                    -> build ();
  

Когда использовать?

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

🐑 Прототип

Реальный пример

Помните тележку? Клонированная овца! Не будем вдаваться в подробности, но ключевым моментом здесь является то, что все дело в клонировании

Простыми словами

Создание объекта на основе существующего объекта путем клонирования.

Википедия говорит:

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

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

Программный пример

В PHP это легко сделать с помощью клона

  class Sheep
{
    защищенное имя $;
    защищенная категория $;

    публичная функция __construct (строка $ name, строка $ category = 'Mountain Sheep')
    {
        $ this-> name = $ имя;
        $ this-> category = $ category;
    }

    публичная функция setName (строка $ имя)
    {
        $ this-> name = $ имя;
    }

    публичная функция getName ()
    {
        вернуть $ this-> name;
    }

    общедоступная функция setCategory (строка $ категория)
    {
        $ this-> category = $ category;
    }

    публичная функция getCategory ()
    {
        вернуть $ this-> category;
    }
}
  

Затем его можно клонировать, как показано ниже.

  $ original = new Sheep ('Jolly');
эхо $ оригинал-> getName ();
эхо $ оригинал-> getCategory ();


$ cloned = клонировать $ оригинал;
$ cloned-> setName ('Долли');
эхо $ cloned-> getName ();
эхо $ cloned-> getCategory ();
  

Также вы можете использовать волшебный метод __clone для изменения поведения клонирования.

Когда использовать?

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

💍 Синглтон

Пример из реальной жизни

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

Простыми словами

Гарантирует, что когда-либо создается только один объект определенного класса.

Википедия говорит:

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

Шаблон Singleton фактически считается анти-шаблоном, и его следует избегать чрезмерного использования. Это не обязательно плохо и может иметь некоторые допустимые варианты использования, но его следует использовать с осторожностью, потому что он вводит глобальное состояние в ваше приложение, и его изменение в одном месте может повлиять на другие области, и его может быть довольно сложно отлаживать.Другая плохая вещь в них — это то, что ваш код сильно связан, а издевательство над синглтоном может быть затруднено.

Программный пример

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

  final class President
{
    частный статический экземпляр $;

    частная функция __construct ()
    {
        
    }

    публичная статическая функция getInstance (): президент
    {
        if (! self :: $ instance) {
            self :: $ instance = new self ();
        }

        вернуть self :: $ instance;
    }

    частная функция __clone ()
    {
        
    }

    частная функция __wakeup ()
    {
        
    }
}
  

Тогда для использования

  $ President1 = President :: getInstance ();
$ President2 = Президент :: getInstance ();

var_dump ($ президент1 === $ президент2);
  

Структурные шаблоны проектирования

Простыми словами

Структурные шаблоны в основном связаны с композицией объекта или, другими словами, как объекты могут использовать друг друга.Или еще одно объяснение: они помогают ответить на вопрос «Как создать программный компонент?»

Википедия говорит:

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

Существует 7 типов структурных шаблонов

🔌 Адаптер

Пример из реальной жизни

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

Простыми словами

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

Википедия говорит:

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

Программный пример

Рассмотрим игру, в которой охотник охотится на львов.

Сначала у нас есть интерфейс Lion , который должны реализовывать все типы львов

  interface Lion
{
    публичная функция roar ();
}

класс AfricanLion реализует Lion
{
    публичная функция рев ()
    {
    }
}

класс AsianLion реализует Lion
{
    публичная функция рев ()
    {
    }
}
  

И охотник ожидает любой реализации интерфейса Lion для охоты.

  класс Охотник
{
    общественная охота (Lion $ lion)
    {
        $ lion-> рев ();
    }
}
  

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

 
класс WildDog
{
    публичная функция bark ()
    {
    }
}


класс WildDogAdapter реализует Lion
{
    охраняемая собака $;

    публичная функция __construct (WildDog $ dog)
    {
        $ this-> dog = $ dog;
    }

    публичная функция рев ()
    {
        $ this-> dog-> bark ();
    }
}
  

И теперь WildDog можно использовать в нашей игре, используя WildDogAdapter .

  $ wildDog = новый WildDog ();
$ wildDogAdapter = новый WildDogAdapter ($ wildDog);

$ hunter = новый охотник ();
$ hunter-> hunt ($ wildDogAdapter);
  

🚡 Bridge

Пример из реальной жизни

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

Простыми словами

Мостовой паттерн — это предпочтение композиции перед наследованием. Детали реализации передаются из иерархии в другой объект с отдельной иерархией.

Википедия говорит:

Шаблон моста — это шаблон проектирования, используемый в разработке программного обеспечения, который предназначен для «отделения абстракции от ее реализации, чтобы они могли изменяться независимо друг от друга»

Программный пример

Перевод нашей веб-страницы пример сверху.Здесь у нас есть WebPage иерархия

  interface WebPage
{
    публичная функция __construct (Theme $ theme);
    публичная функция getContent ();
}

класс О реализует WebPage
{
    защищенная тема $;

    публичная функция __construct (Theme $ theme)
    {
        $ this-> theme = $ theme;
    }

    публичная функция getContent ()
    {
        вернуть «О странице в». $ this-> тема-> getColor ();
    }
}

class Careers реализует WebPage
{
    защищенная тема $;

    публичная функция __construct (Theme $ theme)
    {
        $ this-> theme = $ theme;
    }

    публичная функция getContent ()
    {
        верните «страницу карьеры в».$ this-> тема-> getColor ();
    }
}
  

И отдельная иерархия тем

 
Тема интерфейса
{
    публичная функция getColor ();
}

класс DarkTheme реализует тему
{
    публичная функция getColor ()
    {
        вернуть Dark Black;
    }
}
класс LightTheme реализует тему
{
    публичная функция getColor ()
    {
        вернуть Off white;
    }
}
класс AquaTheme реализует тему
{
    публичная функция getColor ()
    {
        вернуть "Голубой";
    }
}
  

И обе иерархии

  $ darkTheme = new DarkTheme ();

$ about = новое О программе ($ darkTheme);
$ careers = новые карьеры ($ darkTheme);

эхо $ about-> getContent ();
эхо $ карьера-> getContent ();
  

🌿 Composite

Пример из реальной жизни

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

Проще говоря

Составной шаблон позволяет клиентам обращаться с людьми объекты единообразно.

Википедия говорит:

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

Программный пример

Возьмем пример наших сотрудников сверху. Здесь у нас есть разные типы сотрудников

  интерфейс Сотрудник
{
    публичная функция __construct (строка $ name, float $ salary);
    публичная функция getName (): строка;
    публичная функция setSalary (float $ salary);
    публичная функция getSalary (): float;
    публичная функция getRoles (): массив;
}

класс Developer реализует Employee
{
    защищенная $ зарплата;
    защищенное имя $;
    защищенные роли $;
    
    публичная функция __construct (строка $ name, float $ salary)
    {
        $ this-> name = $ имя;
        $ this-> зарплата = $ зарплата;
    }

    публичная функция getName (): строка
    {
        вернуть $ this-> name;
    }

    публичная функция setSalary (float $ salary)
    {
        $ this-> зарплата = $ зарплата;
    }

    публичная функция getSalary (): float
    {
        вернуть $ this-> зарплату;
    }

    публичная функция getRoles (): массив
    {
        вернуть $ this-> роли;
    }
}

конструктор классов реализует Employee
{
    защищенная $ зарплата;
    защищенное имя $;
    защищенные роли $;

    публичная функция __construct (строка $ name, float $ salary)
    {
        $ this-> name = $ имя;
        $ this-> зарплата = $ зарплата;
    }

    публичная функция getName (): строка
    {
        вернуть $ this-> name;
    }

    публичная функция setSalary (float $ salary)
    {
        $ this-> зарплата = $ зарплата;
    }

    публичная функция getSalary (): float
    {
        вернуть $ this-> зарплату;
    }

    публичная функция getRoles (): массив
    {
        вернуть $ this-> роли;
    }
}
  

Затем у нас есть организация, которая состоит из нескольких различных типов сотрудников

  класс Организация
{
    защищенные сотрудники $;

    публичная функция addEmployee (Сотрудник $ сотрудник)
    {
        $ this-> сотрудники [] = $ сотрудник;
    }

    публичная функция getNetSalaries (): float
    {
        $ netSalary = 0;

        foreach ($ this-> сотрудники как $ employee) {
            $ netSalary + = $ employee-> getSalary ();
        }

        return $ netSalary;
    }
}
  

И затем его можно использовать как

 
$ john = новый разработчик («Джон Доу», 12000);
$ jane = новый дизайнер («Джейн Доу», 15000);


$ организация = новая организация ();
$ организация-> addEmployee ($ john);
$ организация-> addEmployee ($ jane);

echo "Чистые зарплаты:".$ организация-> getNetSalaries ();
  

☕ Decorator

Пример из реальной жизни

Представьте, что вы управляете автосервисом, предлагающим несколько услуг. Как теперь рассчитать счет к оплате? Вы выбираете одну услугу и динамически добавляете к ней цены на предоставленные услуги, пока не получите окончательную стоимость. Здесь каждый вид услуг — декоратор.

Простыми словами

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

Википедия говорит:

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

Программный пример

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

  интерфейс Кофе
{
    публичная функция getCost ();
    публичная функция getDescription ();
}

класс SimpleCoffee реализует кофе
{
    публичная функция getCost ()
    {
        возврат 10;
    }

    публичная функция getDescription ()
    {
        вернуть «Простой кофе»;
    }
}
  

Мы хотим сделать код расширяемым, чтобы при необходимости можно было изменять его. Сделаем надстройки (декораторы)

  class MilkCoffee инструменты Coffee
{
    защищенный кофе $;

    публичная функция __construct (Кофе $ кофе)
    {
        $ this-> coffee = $ кофе;
    }

    публичная функция getCost ()
    {
        вернуть $ this-> coffee-> getCost () + 2;
    }

    публичная функция getDescription ()
    {
        вернуть $ this-> coffee-> getDescription ().', молоко';
    }
}

class WhipCoffee реализует Coffee
{
    защищенный кофе $;

    публичная функция __construct (Кофе $ кофе)
    {
        $ this-> coffee = $ кофе;
    }

    публичная функция getCost ()
    {
        вернуть $ this-> coffee-> getCost () + 5;
    }

    публичная функция getDescription ()
    {
        вернуть $ this-> coffee-> getDescription (). ', хлыст';
    }
}

класс VanillaCoffee реализует кофе
{
    защищенный кофе $;

    публичная функция __construct (Кофе $ кофе)
    {
        $ this-> coffee = $ кофе;
    }

    публичная функция getCost ()
    {
        вернуть $ this-> coffee-> getCost () + 3;
    }

    публичная функция getDescription ()
    {
        вернуть $ this-> coffee-> getDescription ().', ваниль';
    }
}
  

Давайте приготовим кофе

  $ someCoffee = new SimpleCoffee ();
эхо $ someCoffee-> getCost ();
echo $ someCoffee-> getDescription ();

$ someCoffee = новый MilkCoffee ($ someCoffee);
эхо $ someCoffee-> getCost ();
echo $ someCoffee-> getDescription ();

$ someCoffee = новый WhipCoffee ($ someCoffee);
эхо $ someCoffee-> getCost ();
echo $ someCoffee-> getDescription ();

$ someCoffee = новый VanillaCoffee ($ someCoffee);
эхо $ someCoffee-> getCost ();
echo $ someCoffee-> getDescription ();
  

📦 Фасад

Пример из реальной жизни

Как включить компьютер? Вы говорите: «Нажмите кнопку питания»! Это то, во что вы верите, потому что вы используете простой интерфейс, который компьютер предоставляет снаружи, внутри он должен делать много вещей, чтобы это произошло.Этот простой интерфейс со сложной подсистемой является фасадом.

Простыми словами

Фасадный паттерн обеспечивает упрощенный интерфейс для сложной подсистемы.

Википедия утверждает, что

Фасад — это объект, который обеспечивает упрощенный интерфейс для большей части кода, такой как библиотека классов.

Программный пример

Возьмем наш компьютерный пример сверху. Здесь у нас компьютер класса

  класс Компьютер
{
    публичная функция getElectricShock ()
    {
        эхо «Ой!»;
    }

    публичная функция makeSound ()
    {
        echo «Пип гудок!»;
    }

    публичная функция showLoadingScreen ()
    {
        echo "Загрузка.. ";
    }

    публичная функция bam ()
    {
        echo "Готово к использованию!";
    }

    публичная функция closeEverything ()
    {
        echo "Буп буп жужжание!";
    }

    публичная функция sooth ()
    {
        эхо "Zzzzz";
    }

    публичная функция pullCurrent ()
    {
        эхо «Хаааа!»;
    }
}
  

Вот и фасад

  class ComputerFacade
{
    защищенный компьютер $;

    публичная функция __construct (Компьютер $ компьютер)
    {
        $ this-> компьютер = $ компьютер;
    }

    публичная функция TurnOn ()
    {
        $ this-> компьютер-> getElectricShock ();
        $ this-> компьютер-> makeSound ();
        $ this-> computer-> showLoadingScreen ();
        $ this-> компьютер-> бам ();
    }

    публичная функция turnOff ()
    {
        $ this-> компьютер-> closeEverything ();
        $ this-> компьютер-> pullCurrent ();
        $ this-> компьютер-> sooth ();
    }
}
  

Теперь использовать фасад

  $ компьютер = новый ComputerFacade (новый компьютер ());
$ компьютер-> TurnOn ();
$ компьютер-> TurnOff ();
  

🍃 Наилегчайший

Пример из реальной жизни

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

Простыми словами

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

Википедия говорит:

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

Программный пример

Перевод нашего примера чая сверху. В первую очередь у нас есть сорта чая и чайник

 

класс KarakTea
{
}


class TeaMaker
{
    защищенный $ availableTea = [];

    общедоступная функция make ($ предпочтение)
    {
        if (empty ($ this-> availableTea [$ preference])) {
            $ this-> availableTea [$ предпочтение] = новый KarakTea ();
        }

        вернуть $ this-> availableTea [$ предпочтение];
    }
}
  

Затем у нас есть TeaShop , который принимает и обслуживает заказы

  class TeaShop
{
    защищенные $ заказы;
    защищенный $ teaMaker;

    публичная функция __construct (TeaMaker $ teaMaker)
    {
        $ this-> teaMaker = $ teaMaker;
    }

    публичная функция takeOrder (строка $ teaType, int $ table)
    {
        $ this-> orders [$ table] = $ this-> teaMaker-> сделать ($ teaType);
    }

    публичная функция serve ()
    {
        foreach ($ this-> заказывается как $ table => $ tea) {
            echo "Подавать чай к столу №".$ table;
        }
    }
}
  

И его можно использовать как показано ниже

  $ teaMaker = new TeaMaker ();
$ shop = новый TeaShop ($ teaMaker);

$ shop-> takeOrder ('меньше сахара', 1);
$ shop-> takeOrder ('больше молока', 2);
$ shop-> takeOrder ('без сахара', 5);

$ shop-> serve ();



  

🎱 Прокси-сервер

Пример из реальной жизни

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

Простыми словами

Используя шаблон прокси, класс представляет функциональность другого класса.

Википедия говорит:

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

Программный пример

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

  Дверь
{
    публичная функция open ();
    публичная функция close ();
}

class LabDoor реализует Door
{
    публичная функция open ()
    {
        эхо «Открывающаяся дверь лаборатории»;
    }

    публичная функция close ()
    {
        эхо «Закрытие двери лаборатории»;
    }
}
  

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

  class SecuredDoor
{
    защищенная $ дверь;

    публичная функция __construct (Door $ door)
    {
        $ this-> door = $ door;
    }

    открытая публичная функция ($ пароль)
    {
        if ($ this-> аутентифицировать ($ пароль)) {
            $ this-> дверь-> open ();
        } еще {
            echo "Большое нет! Это невозможно.";
        }
    }

    общедоступная функция аутентификации ($ пароль)
    {
        вернуть $ password === '$ ecr @ t';
    }

    публичная функция close ()
    {
        $ это-> дверь-> закрыть ();
    }
}
  

А вот как это можно использовать

  $ door = new SecuredDoor (new LabDoor ());
$ door-> open ('недействительно');

$ дверь-> открыть ('$ ecr @ t');
$ дверь-> закрыть ();
  

Еще одним примером может быть некая реализация преобразователя данных. Например, я недавно сделал ODM (Object Data Mapper) для MongoDB, используя этот шаблон, где я написал прокси для классов mongo, используя волшебный метод __call () .Все вызовы методов были переданы исходному классу mongo, и полученный результат был возвращен как есть, но в случае find или данные findOne были сопоставлены с требуемыми объектами класса, и объект был возвращен вместо Cursor .

Шаблоны поведенческого проектирования

Простыми словами

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

Википедия утверждает, что

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

Существует 10 типов шаблонов поведенческого проектирования

🔗 Цепочка ответственности

Пример из реальной жизни

Например, у вас есть три способа оплаты ( A , B и C ), настроенные в вашей учетной записи. ; в каждой разное количество. A имеет 100 долларов США, B имеет 300 долларов США и C имеет 1000 долларов США, и предпочтение для платежей выбрано как A , затем B , затем C . Вы пытаетесь приобрести что-то стоимостью 210 долларов США. Используя цепочку ответственности, в первую очередь проверяется, может ли он совершить покупку, счет A , если да, то покупка будет сделана и цепочка будет разорвана. Если нет, запрос переместится на счет B , проверяя сумму, если да, цепочка будет разорвана, в противном случае запрос будет пересылаться до тех пор, пока не будет найден подходящий обработчик.Здесь A , B и C являются звеньями цепи, а весь феномен — это цепочка ответственности.

Проще говоря

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

Википедия говорит:

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

Программный пример

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

  абстрактный класс Account
{
    защищенный преемник $;
    защищенный $ баланс;

    общедоступная функция setNext (Аккаунт $ account)
    {
        $ this-> преемник = $ аккаунт;
    }

    публичная функция pay (float $ amountToPay)
    {
        if ($ this-> canPay ($ amountToPay)) {
            echo sprintf ('Оплачено% s с использованием% s'.PHP_EOL, $ amountToPay, get_called_class ());
        } elseif ($ this-> преемник) {
            echo sprintf ('Невозможно оплатить с помощью% s. Продолжается ...'. PHP_EOL, get_called_class ());
            $ this-> преемник-> платить ($ amountToPay);
        } еще {
            выбросить новое исключение («Ни на одном из аккаунтов недостаточно баланса»);
        }
    }

    публичная функция canPay ($ amount): bool
    {
        вернуть $ this-> balance> = $ amount;
    }
}

класс Банк расширяет счет
{
    защищенный $ баланс;

    публичная функция __construct (float $ balance)
    {
        $ this-> balance = $ баланс;
    }
}

класс Paypal расширяет счет
{
    защищенный $ баланс;

    публичная функция __construct (float $ balance)
    {
        $ this-> balance = $ баланс;
    }
}

класс Биткойн расширяет Аккаунт
{
    защищенный $ баланс;

    публичная функция __construct (float $ balance)
    {
        $ this-> balance = $ баланс;
    }
}
  

Теперь давайте подготовим цепочку, используя указанные выше звенья (т.е.е. Банк, Paypal, Биткойн)

 






$ bank = новый банк (100);
$ paypal = новый Paypal (200);
$ bitcoin = новый биткойн (300);

$ bank-> setNext ($ PayPal);
$ paypal-> setNext ($ биткойн);


$ банк-> оплата (259);






  

👮 Команда

Пример из реальной жизни

Общий пример: вы заказываете еду в ресторане. Вы (например, Client ) просите официанта (например, Invoker ) принести немного еды (например, Command ), и официант просто пересылает запрос шеф-повару (т.е.е. Ресивер ) кто знает, что и как готовить. Другой пример: вы (например, Client ) включаете (например, Command ) телевизор (например, Receiver ) с помощью пульта дистанционного управления ( Invoker ).

Простыми словами

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

Википедия говорит:

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

Программный пример

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

 
класс Bulb
{
    публичная функция TurnOn ()
    {
        эхо «Лампочка зажжена»;
    }

    публичная функция turnOff ()
    {
        эхо «Тьма!»;
    }
}
  

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

  interface Command
{
    публичная функция execute ();
    публичная функция undo ();
    публичная функция redo ();
}


класс TurnOn реализует команду
{
    защищенная лампочка $;

    публичная функция __construct (Bulb $ bulb)
    {
        $ this-> bulb = $ bulb;
    }

    публичная функция execute ()
    {
        $ this-> лампочка-> TurnOn ();
    }

    публичная функция отменить ()
    {
        $ это-> лампочка-> TurnOff ();
    }

    публичная функция redo ()
    {
        $ this-> execute ();
    }
}

Класс TurnOff реализует Command
{
    защищенная лампочка $;

    публичная функция __construct (Bulb $ bulb)
    {
        $ this-> bulb = $ bulb;
    }

    публичная функция execute ()
    {
        $ this-> лампочка-> TurnOff ();
    }

    публичная функция отменить ()
    {
        $ this-> лампочка-> TurnOn ();
    }

    публичная функция redo ()
    {
        $ this-> execute ();
    }
}
  

Затем у нас есть Invoker , с которым клиент будет взаимодействовать для обработки любых команд

 
класс RemoteControl
{
    публичная функция submit (Command $ command)
    {
        $ команда-> выполнить ();
    }
}
  

Наконец, давайте посмотрим, как мы можем использовать его в нашем клиенте

  $ bulb = new Bulb ();

$ turnOn = новый TurnOn ($ bulb);
$ turnOff = новый TurnOff ($ bulb);

$ remote = новый RemoteControl ();
$ remote-> submit ($ turnOn);
$ remote-> отправить ($ turnOff);
  

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

➿ Итератор

Пример реального мира

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

Простыми словами

Он представляет способ доступа к элементам объекта без раскрытия лежащей в основе презентации.

Википедия говорит:

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

Программный пример

В PHP это довольно легко реализовать с помощью SPL (стандартной библиотеки PHP). Пример перевода наших радиостанций сверху. Прежде всего у нас есть RadioStation

  class RadioStation
{
    защищенная частота $;

    публичная функция __construct (float $ frequency)
    {
        $ this-> частота = $ частота;
    }

    публичная функция getFrequency (): float
    {
        вернуть $ this-> frequency;
    }
}
  

Затем у нас есть итератор

  use Countable;
используйте Iterator;

class StationList реализует Countable, Iterator
{
   
    защищенные станции $ = [];

   
    защищенный счетчик $;

    публичная функция addStation (RadioStation $ station)
    {
        $ this-> station [] = $ station;
    }

    публичная функция removeStation (RadioStation $ toRemove)
    {
        $ toRemoveFrequency = $ toRemove-> getFrequency ();
        $ this-> station = array_filter ($ this-> станции, функция (RadioStation $ station) use ($ toRemoveFrequency) {
            return $ station-> getFrequency ()! == $ toRemoveFrequency;
        });
    }

    публичная функция count (): int
    {
        счетчик возврата ($ this-> станции);
    }

    публичная функция current (): RadioStation
    {
        вернуть $ this-> station [$ this-> counter];
    }

    открытый функциональный ключ ()
    {
        вернуть $ this-> counter;
    }

    публичная функция next ()
    {
        $ this-> counter ++;
    }

    публичная функция rewind ()
    {
        $ this-> counter = 0;
    }

    публичная функция действительна (): bool
    {
        return isset ($ this-> station [$ this-> counter]);
    }
}
  

И тогда его можно использовать как

  $ stationList = new StationList ();

$ stationList-> addStation (новый RadioStation (89));
$ stationList-> addStation (новый RadioStation (101));
$ stationList-> addStation (новый RadioStation (102));
$ stationList-> addStation (новый RadioStation (103.2));

foreach ($ stationList as $ station) {
    echo $ station-> getFrequency (). PHP_EOL;
}

$ stationList-> removeStation (новый RadioStation (89));
  

Пример из реальной жизни

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

Простыми словами

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

Википедия говорит:

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

Программный пример

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

Во-первых, у нас есть посредник — чат

  интерфейс ChatRoomMediator
{
    общедоступная функция showMessage (Пользователь $ user, строка $ message);
}


класс ChatRoom реализует ChatRoomMediator
{
    общедоступная функция showMessage (Пользователь $ user, строка $ message)
    {
        $ time = date ('М д, г Ч: я');
        $ отправитель = $ пользователь-> getName ();

        эхо $ время. '['. $ отправитель. ']:'. $ message;
    }
}
  

Затем у нас есть пользователи i.е. коллеги

  класс Пользователь {
    защищенное имя $;
    защищенный $ chatMediator;

    публичная функция __construct (строка $ name, ChatRoomMediator $ chatMediator) {
        $ this-> name = $ имя;
        $ this-> chatMediator = $ chatMediator;
    }

    public function getName () {
        вернуть $ this-> name;
    }

    общедоступная функция send ($ message) {
        $ this-> chatMediator-> showMessage ($ this, $ message);
    }
}
  

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

  $ mediator = new ChatRoom ();

$ john = новый пользователь ('Джон Доу', $ посредник);
$ jane = новый пользователь ('Джейн Доу', $ посредник);

$ john-> send ('Привет!');
$ jane-> send ('Эй!');




  

💾 Memento

Пример реального мира

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

Проще говоря,

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

Википедия говорит:

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

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

Программный пример

Давайте рассмотрим пример текстового редактора, который сохраняет состояние время от времени и который вы можете восстановить, если хотите.

Прежде всего у нас есть объект-мементо, который сможет удерживать состояние редактора

  class EditorMemento
{
    защищенный контент $;

    публичная функция __construct (строка $ content)
    {
        $ this-> content = $ content;
    }

    публичная функция getContent ()
    {
        вернуть $ this-> content;
    }
}
  

Затем у нас есть редактор i.е. оригинатор, который будет использовать объект-памятку

  class Editor
{
    защищенный $ content = '';

    тип публичной функции (строка $ слова)
    {
        $ this-> content = $ this-> content. ''. $ words;
    }

    публичная функция getContent ()
    {
        вернуть $ this-> content;
    }

    публичная функция save ()
    {
        вернуть новый EditorMemento ($ this-> content);
    }

    восстановление публичной функции (EditorMemento $ memento)
    {
        $ this-> content = $ memento-> getContent ();
    }
}
  

И тогда его можно использовать как

  $ editor = new Editor ();


$ editor-> type ('Это первое предложение.');
$ editor-> type ('Это второй.');


$ сохранено = $ редактор-> сохранить ();


$ editor-> type ('А это третий.');


эхо $ редактор-> getContent ();


$ редактор-> восстановить ($ сохранено);

$ редактор-> getContent ();
  

😎 Observer

Пример из реальной жизни

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

Простыми словами

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

Википедия говорит:

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

Программный пример

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

  class JobPost
{
    защищенный заголовок $;

    публичная функция __construct (строка $ title)
    {
        $ this-> title = $ title;
    }

    публичная функция getTitle ()
    {
        вернуть $ this-> title;
    }
}

класс JobSeeker реализует Observer
{
    защищенное имя $;

    публичная функция __construct (строка $ имя)
    {
        $ this-> name = $ имя;
    }

    публичная функция onJobPosted (JobPost $ job)
    {
        
        эхо «Привет».$ this-> имя. '! Опубликована новая вакансия: '. $ job-> getTitle ();
    }
}
  

Затем у нас есть объявления о вакансиях, на которые соискатели подпишутся.

  class EmploymentAgency реализует Observable
{
    защищенные наблюдатели $ = [];

    уведомление о защищенной функции (JobPost $ jobPosting)
    {
        foreach ($ this-> наблюдатели как $ наблюдатель) {
            $ наблюдатель-> onJobPosted ($ jobPosting);
        }
    }

    общедоступная функция прикреплена (Observer $ Observer)
    {
        $ this-> наблюдатели [] = $ наблюдатель;
    }

    публичная функция addJob (JobPost $ jobPosting)
    {
        $ this-> уведомить ($ jobPosting);
    }
}
  

Тогда его можно использовать как

 
$ johnDoe = новый JobSeeker ('Джон Доу');
$ janeDoe = новый соискатель ('Джейн Доу');


$ jobPostings = новое агентство занятости ();
$ jobPostings-> прикрепить ($ johnDoe);
$ jobPostings-> прикрепить ($ janeDoe);


$ jobPostings-> addJob (новый JobPost («Инженер-программист»));




  

🏃 Посетитель

Пример из реальной жизни

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

Простыми словами

Шаблон посетителя позволяет добавлять дополнительные операции к объектам, не изменяя их.

Википедия говорит

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

Программный пример

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

 .
интерфейс Animal
{
    публичная функция accept (операция AnimalOperation $);
}


интерфейс AnimalOperation
{
    публичная функция visitMonkey (Обезьяна $ обезьяна);
    публичная функция visitLion (Lion $ lion);
    общедоступная функция visitDolphin (Дельфин $ дельфин);
}
  

Затем у нас есть реализации для животных

  class Monkey реализует Animal
{
    публичная функция крик ()
    {
        echo 'Ooh oo aa aa!';
    }

    общественная функция accept (операция AnimalOperation $)
    {
        $ операция-> visitMonkey ($ this);
    }
}

класс Lion реализует Animal
{
    публичная функция рев ()
    {
        echo 'Roaaar!';
    }

    общественная функция accept (операция AnimalOperation $)
    {
        $ операция-> visitLion ($ this);
    }
}

класс Dolphin реализует Animal
{
    публичная функция говорит ()
    {
        echo 'Tuut tuttu tuutt!';
    }

    общественная функция accept (операция AnimalOperation $)
    {
        $ операция-> visitDolphin ($ this);
    }
}
  

Давайте реализуем нашего посетителя

  class Speak реализует AnimalOperation
{
    общедоступная функция visitMonkey (Обезьяна $ обезьяна)
    {
        $ обезьяна-> крик ();
    }

    публичная функция visitLion (Lion $ lion)
    {
        $ lion-> рев ();
    }

    публичная функция visitDolphin (Дельфин $ дельфин)
    {
        $ дельфин-> говорить ();
    }
}
  

И тогда его можно использовать как

  $ monkey = new Monkey ();
$ lion = новый Лев ();
$ дельфин = новый дельфин ();

$ Speak = новый Speak ();

$ monkey-> accept ($ говорить);
$ lion-> accept ($ говорить);
$ dolphin-> accept ($ говорить);
  

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

  класс Jump реализует AnimalOperation
{
    общедоступная функция visitMonkey (Обезьяна $ обезьяна)
    {
        echo 'Подпрыгнул на 20 футов! на дерево! ';
    }

    публичная функция visitLion (Lion $ lion)
    {
        echo 'Прыгнул на 7 футов! Снова на землю! ';
    }

    публичная функция visitDolphin (Дельфин $ дельфин)
    {
        echo «Немного погулял по воде и исчез»;
    }
}
  

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

  $ jump = new Jump ();

$ monkey-> accept ($ говорить);
$ обезьяна-> принять ($ прыжок);

$ lion-> accept ($ говорить);
$ lion-> accept ($ прыжок);

$ dolphin-> accept ($ говорить);
$ дельфин-> принять ($ прыжок);
  

💡 Стратегия

Пример из реальной жизни

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

Простыми словами

Шаблон стратегии позволяет вам переключать алгоритм или стратегию в зависимости от ситуации.

Википедия утверждает, что

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

Программный пример

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

  интерфейс SortStrategy
{
    публичная функция sort (array $ dataset): array;
}

класс BubbleSortStrategy реализует SortStrategy
{
    публичная функция sort (array $ dataset): array
    {
        echo "Сортировка пузырьковой сортировкой";

        
        вернуть набор данных $;
    }
}

класс QuickSortStrategy реализует SortStrategy
{
    публичная функция sort (array $ dataset): array
    {
        echo "Сортировка с помощью быстрой сортировки";

        
        вернуть набор данных $;
    }
}
  

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

  class Sorter
{
    защищенный сортировщик $;

    публичная функция __construct (SortStrategy $ sorter)
    {
        $ this-> sorter = $ сортировщик;
    }

    публичная функция sort (array $ dataset): array
    {
        вернуть $ this-> sorter-> sort ($ dataset);
    }
}
  

И его можно использовать как

  $ dataset = [1, 5, 4, 3, 2, 8];

$ sorter = новый сортировщик (new BubbleSortStrategy ());
$ sorter-> sort ($ набор данных);

$ sorter = новый сортировщик (new QuickSortStrategy ());
$ sorter-> sort ($ набор данных);
  

💢 Состояние

Пример из реальной жизни

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

Простыми словами

Это позволяет вам изменить поведение кисти. класс при изменении состояния.

Википедия говорит:

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

Программный пример

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

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

  интерфейс WritingState.
{
    публичная функция write (строка $ words);
}

класс UpperCase реализует WritingState
{
    запись публичной функции (строка $ слова)
    {
        echo strtoupper ($ words);
    }
}

class LowerCase реализует WritingState
{
    запись публичной функции (строка $ слова)
    {
        echo strtolower ($ words);
    }
}

класс DefaultText реализует WritingState
{
    запись публичной функции (строка $ слова)
    {
        echo $ words;
    }
}
  

Затем у нас есть наш редактор

  class TextEditor
{
    защищенное $ состояние;

    публичная функция __construct (WritingState $ state)
    {
        $ this-> state = $ state;
    }

    публичная функция setState (WritingState $ state)
    {
        $ this-> state = $ state;
    }

    тип публичной функции (строка $ слова)
    {
        $ это-> состояние-> написать ($ слова);
    }
}
  

И тогда его можно использовать как

  $ editor = new TextEditor (new DefaultText ());

$ editor-> type ('Первая строка');

$ editor-> setState (новый UpperCase ());

$ editor-> type ('Вторая строка');
$ editor-> type ('Третья строка');

$ editor-> setState (новый нижний регистр ());

$ editor-> type ('Четвертая строка');
$ editor-> type ('Пятая строка');







  

📒 Шаблонный метод

Пример из реальной жизни

Предположим, мы строим дом.Шаги для строительства могут выглядеть так:

• Подготовить фундамент дома
• Построить стены
• Добавить крышу
• Добавить другие этажи

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

Простыми словами

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

Википедия говорит:

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

Программный пример

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

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

  абстрактный класс Builder
{

    
    финальная публичная функция build ()
    {
        $ this-> test ();
        $ this-> lint ();
        $ this-> assembly ();
        $ this-> deploy ();
    }

    абстрактная публичная функция test ();
    абстрактная публичная функция lint ();
    абстрактная публичная функция Assembly ();
    абстрактная публичная функция deploy ();
}
  

Тогда у нас могут быть наши реализации

  class AndroidBuilder extends Builder
{
    общедоступная функция test ()
    {
        echo 'Запуск тестов Android';
    }

    публичная функция lint ()
    {
        echo 'Линтинг кода андроида';
    }

    публичная функция Assembly ()
    {
        echo 'Сборка сборки андроида';
    }

    публичная функция deploy ()
    {
        echo 'Развертывание сборки Android на сервере';
    }
}

class IosBuilder расширяет Builder
{
    общедоступная функция test ()
    {
        echo 'Запуск тестов ios';
    }

    публичная функция lint ()
    {
        echo 'Анализ кода ios';
    }

    публичная функция Assembly ()
    {
        echo 'Сборка сборки ios';
    }

    публичная функция deploy ()
    {
        echo 'Развертывание сборки ios на сервере';
    }
}
  

И тогда его можно использовать как

  $ androidBuilder = new AndroidBuilder ();
$ androidBuilder-> build ();







$ iosBuilder = новый IosBuilder ();
$ iosBuilder-> build ();






  

Подводя итоги, ребята

И на этом все заканчивается.