Green-sell.info

Новые технологии
1 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Объектом объектно ориентированного программирования называется

Основные понятия в объектно-ориентированном программировании ИЛИ
моя шпаргалка по ООП

С целью освежения базовых знаний по ООП, я решила перечитать потрясающую книгу «Объектно-ориентированный анализ и проектирование с примерами приложений», Гради Буч

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

А теперь для ленивых и для себя любимой я составила краткий конспект-шпаргалку по этой книги.

ШПАРГАЛКА ПО ООП

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

Основные принципы ООП

  • абстрагирование
  • инкапсуляция
  • модульность
  • иерархия

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

Объекты и классы — основные абстракции предметной области.

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

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

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

Иерархия — это упорядочение абстракций, расположение их по уровням.

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

Тип — точная характеристика некоторой совокупности однородных объектов, включающая структуру и поведение.

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

Параллелизм — это свойство, отличающее активные объекты от пассивных.

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

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

Устойчивость — способность объекта сохранять свое существование во времени и/или пространстве (адресном, в частности при перемещении между узлами вычислительной системы). В частности, устойчивость объектов может быть обеспечена за счет их хранения в базе данных.

Основные понятия объектно-ориентированного подхода или элементы объектной модели

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

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

Любой объект обладает состоянием, поведением и индивидуальностью.

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

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

Индивидуальность это свойства объекта, отличающие его от всех других объектов.

Структура и поведение схожих объектов определяют общий для них класс.

Объект в JavaScript создаётся с помощью функции Object.create. Эта функция из родителя и опционального набора свойств создаёт новую сущность. Пока что мы не будем беспокоиться о параметрах.

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

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

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

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

var s = new String();

Деструктор — специальный метод класса, служащий для деинициализации объекта (например освобождения памяти).

Атрибут — поименованное свойство класса, определяющее диапазон допустимых значений, которые могут принимать экземпляры данного свойства. Атрибуты могут быть скрыты от других классов, это определяет видимость атрибута: рublic (общий, открытый); private (закрытый, секретный); protected (защищенный).

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

Дескриптор — это атрибут объекта со связанным поведением (англ. binding behavior), т.е. такой, чьё поведение при доступе переопределяется методами протокола дескриптора.

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

Метод — это функция или процедура, принадлежащая какому-то классу или объекту.

Различают простые методы и статические методы (методы класса):

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

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

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

  • открытый (public) интерфейс — общий интерфейс для всех пользователей данного класса;
  • защищённый (protected) интерфейс — внутренний интерфейс для всех наследников данного класса;
  • закрытый (private) интерфейс — интерфейс, доступный только изнутри данного класса.

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

Полиморфизм — способность скрывать множество различных реализаций под единственным общим именем или интерфейсом.

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

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

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

Компонент представляет собой физическую реализацию проектной абстракции и может быть: компонентом исходного кода (cpp-шник); компонентом времени выполнения (dll, ActiveX и т. п.); исполняемый компонентом (exe-шник). Компонент обеспечивает физическую реализацию набора интерфейсов. Компонентная разработка (component-based development) представляет собой создание программных систем, состоящих из компонентов (не путать с объектно-ориентированным программированием (ООП).

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

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

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

-единицей управления конфигурацией.

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

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

Классы

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

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

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

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

В соответствии с UML ( Unified Modelling Language — унифицированный язык моделирования ), класс имеет следующее графическое представление .

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

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

  • конструктор (constructor) — выполняется при создании объектов ;
  • деструктор ( destructor ) — выполняется при уничтожении объектов .
Читать еще:  Безопасность баз данных

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

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

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

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

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

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

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

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

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

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

Наследование (inheritance) — это отношение между классами , при котором класс использует структуру или поведение другого класса (одиночное наследование ), или других (множественное наследование ) классов . Наследование вводит иерархию «общее/частное», в которой подкласс наследует от одного или нескольких более общих суперклассов . Подклассы обычно дополняют или переопределяют унаследованную структуру и поведение .

В качестве примера можно рассмотреть задачу, в которой необходимо реализовать классы «Легковой автомобиль» и «Грузовой автомобиль». Очевидно, эти два класса имеют общую функциональность. Так, оба они имеют 4 колеса, двигатель, могут перемещаться и т.д. Всеми этими свойствами обладает любой автомобиль, независимо от того, грузовой он или легковой, 5- или 12-местный. Разумно вынести эти общие свойства и функциональность в отдельный класс , например, «Автомобиль» и наследовать от него классы «Легковой автомобиль» и «Грузовой автомобиль», чтобы избежать повторного написания одного и того же кода в разных классах .

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

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

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

Все животные в зоомагазине являются наследниками класса «Животное», а также наследниками класса «Товар». Т.е. все они имеют возраст, нуждаются в пище и воде и в то же время имеют цену и могут быть проданы.

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

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

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

Полиморфизм

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

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

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

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

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

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

Для описанной выше иерархии классов, используя полиморфизм , можно написать следующий код:

В описанном выше примере массив p[] может содержать любые объекты , порожденные от наследников класса Point . При вызове какого-либо метода у любого из элементов этого массива будет выполнен метод того объекта , который содержится в ячейке массива. Например, если в ячейке p[0] находится объект Circle , то при вызове метода draw следующим образом:

нарисуется круг, а не точка.

В заключение приведем формальное определение полиморфизма .

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

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

Примером использования перегрузки методов в языке Java может служить класс PrintWriter , который применяется, в частности, для вывода сообщений на консоль. Этот класс имеет множество методов println , которые различаются типами и/или количеством входных параметров. Вот лишь несколько из них:

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

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

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

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

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

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

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

Класс – это описание множества объектов программирования (объектов) и выполняемых над ними действий.

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

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

Любая функция в программе представляет собой метод для объекта некоторого класса.

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

Вся программа в таком виде представляет собой объект некоторого класса с единственным методом run (выполнить).

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

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

Внутри объекта коды и данные могут быть закрытыми или открытыми.

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

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

Читать еще:  Политика безопасности организации это

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

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

Иначе говоря, новый класс наследует как данные старого класса, так и методы их обработки.

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

Пример наследования – определение структуры, отдельный член которой является ранее определенной структурой.


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

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

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

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

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

Объектно-ориентированное программирование: на пальцах

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

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

Обычное программирование (процедурное)

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

Напри­мер, в интернет-магазине может быть функ­ция «Про­ве­рить email». Она полу­ча­ет на вход какой-то текст, сопо­став­ля­ет со сво­и­ми пра­ви­ла­ми и выда­ёт ответ: это пра­виль­ный элек­трон­ный адрес или нет. Если пра­виль­ный, то true, если нет — то false.

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

Что не так с процедурным программированием

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

Напри­мер, вы пише­те функ­цию «Заре­ги­стри­ро­вать поль­зо­ва­те­ля интернет-магазина». Внут­ри неё вам нуж­но про­ве­рить его элек­трон­ный адрес. Вы вызы­ва­е­те функ­цию «Про­ве­рить email» внут­ри функ­ции «Заре­ги­стри­ро­вать поль­зо­ва­те­ля», и в зави­си­мо­сти от отве­та функ­ции вы либо реги­стри­ру­е­те поль­зо­ва­те­ля, либо выво­ди­те ошиб­ку. И у вас эта функ­ция встре­ча­ет­ся ещё в деся­ти местах. Функ­ции как бы пере­пле­те­ны.

Тут при­хо­дит продакт-менеджер и гово­рит: «Хочу, что­бы поль­зо­ва­тель точ­но знал, в чём ошиб­ка при вво­де элек­трон­но­го адре­са». Теперь вам нуж­но научить функ­цию выда­вать не про­сто true — false, а ещё и код ошиб­ки: напри­мер, если в адре­се опе­чат­ка, то код 01, если адрес спа­мер­ский — код 02 и так далее. Это неслож­но реа­ли­зо­вать.

Вы зале­за­е­те внутрь этой функ­ции и меня­е­те её пове­де­ние: теперь она вме­сто true — false выда­ёт код ошиб­ки, а если ошиб­ки нет — пишет «ОК».

И тут ваш код лома­ет­ся: все десять мест, кото­рые ожи­да­ли от про­ве­ряль­щи­ка true или false, теперь полу­ча­ют «ОК» и из-за это­го лома­ют­ся.

Теперь вам нуж­но:

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

Зада­ча, конеч­но, реша­е­мая за час-другой.

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

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

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

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

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

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

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

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

Инкап­су­ля­ция — объ­ект неза­ви­сим: каж­дый объ­ект устро­ен так, что нуж­ные для него дан­ные живут внут­ри это­го объ­ек­та, а не где-то сна­ру­жи в про­грам­ме. Напри­мер, если у меня есть объ­ект «Поль­зо­ва­тель», то у меня в нём будут все дан­ные о поль­зо­ва­те­ле: и имя, и адрес, и всё осталь­ное. И в нём же будут мето­ды «Про­ве­рить адрес» или «Под­пи­сать на рас­сыл­ку».

Абстрак­ция — у объ­ек­та есть «интер­фейс»: у объ­ек­та есть мето­ды и свой­ства, к кото­рым мы можем обра­тить­ся извне это­го объ­ек­та. Так же, как мы можем нажать кноп­ку на блен­де­ре. У блен­де­ра есть мно­го все­го внут­ри, что застав­ля­ет его рабо­тать, но на глав­ной пане­ли есть толь­ко кноп­ка. Вот эта кноп­ка и есть абстракт­ный интер­фейс.

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

Напри­мер, над мага­зи­ном рабо­та­ют два про­грам­ми­ста: один пишет модуль зака­за, а вто­рой — модуль достав­ки. У пер­во­го в объ­ек­те «заказ» есть метод «отме­нить». И вот вто­ро­му нуж­но из-за достав­ки отме­нить заказ. И он спо­кой­но пишет: «заказ.отменить()». Ему неваж­но, как дру­гой про­грам­мист будет реа­ли­зо­вы­вать отме­ну: какие он отпра­вит пись­ма, что запи­шет в базу дан­ных, какие выве­дет пре­ду­пре­жде­ния.

Насле­до­ва­ние — спо­соб­ность к копи­ро­ва­нию. ООП поз­во­ля­ет созда­вать мно­го объ­ек­тов по обра­зу и подо­бию дру­го­го объ­ек­та. Это поз­во­ля­ет не копи­па­стить код по две­сти раз, а один раз нор­маль­но напи­сать и потом мно­го раз исполь­зо­вать.

Напри­мер, у вас может быть некий иде­аль­ный объ­ект «Поль­зо­ва­тель»: в нём вы про­пи­сы­ва­е­те всё, что может про­ис­хо­дить с поль­зо­ва­те­лем. У вас могут быть свой­ства: имя, воз­раст, адрес, номер кар­ты. И могут быть мето­ды «Дать скид­ку», «Про­ве­рить заказ», «Най­ти зака­зы», «Позво­нить».

На осно­ве это­го иде­аль­но­го поль­зо­ва­те­ля вы може­те создать реаль­но­го «Поку­па­те­ля Ива­на». У него при созда­нии будут все свой­ства и мето­ды, кото­рые вы зада­ли у иде­аль­но­го поку­па­те­ля, плюс могут быть какие-то свои, если захо­ти­те.

Иде­аль­ные объ­ек­ты про­грам­ми­сты назы­ва­ют клас­са­ми.

Поли­мор­физм — еди­ный язык обще­ния. В ООП важ­но, что­бы все объ­ек­ты обща­лись друг с дру­гом на понят­ном им язы­ке. И если у раз­ных объ­ек­тов есть метод «Уда­лить», то он дол­жен делать имен­но это и писать­ся вез­де оди­на­ко­во. Нель­зя, что­бы у одно­го объ­ек­та это было «Уда­лить», а у дру­го­го «Сте­реть».

При этом внут­ри объ­ек­та мето­ды могут быть реа­ли­зо­ва­ны по-разному. Напри­мер, уда­лить товар — это выдать пре­ду­пре­жде­ние, а потом поме­тить товар в базе дан­ных как уда­лён­ный. А уда­лить поль­зо­ва­те­ля — это отме­нить его покуп­ки, отпи­сать от рас­сыл­ки и заар­хи­ви­ро­вать исто­рию его поку­пок. Собы­тия раз­ные, но для про­грам­ми­ста это неваж­но. У него про­сто есть метод «Уда­лить()», и он ему дове­ря­ет.

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

Читать еще:  2 системы программирования

Плюсы и минусы ООП

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

  1. Визу­аль­но код ста­но­вит­ся про­ще, и его лег­че читать. Когда всё раз­би­то на объ­ек­ты и у них есть понят­ный набор пра­вил, мож­но сра­зу понять, за что отве­ча­ет каж­дый объ­ект и из чего он состо­ит.
  2. Мень­ше оди­на­ко­во­го кода. Если в обыч­ном про­грам­ми­ро­ва­нии одна функ­ция счи­та­ет повто­ря­ю­щи­е­ся сим­во­лы в одно­мер­ном мас­си­ве, а дру­гая — в дву­мер­ном, то у них боль­шая часть кода будет оди­на­ко­вой. В ООП это реша­ет­ся насле­до­ва­ни­ем.
  3. Слож­ные про­грам­мы пишут­ся про­ще. Каж­дую боль­шую про­грам­му мож­но раз­ло­жить на несколь­ко бло­ков, сде­лать им мини­маль­ное напол­не­ние, а потом раз за разом подроб­но напол­нить каж­дый блок.
  4. Уве­ли­чи­ва­ет­ся ско­рость напи­са­ния. На стар­те мож­но быст­ро создать нуж­ные ком­по­нен­ты внут­ри про­грам­мы, что­бы полу­чить мини­маль­но рабо­та­ю­щий про­то­тип.

А теперь про мину­сы:

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

Что дальше

Впе­ре­ди нас ждёт раз­го­вор о клас­сах, объ­ек­тах и всём осталь­ном важ­ном в ООП. Кре­пи­тесь, будет инте­рес­но!

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

$human = new Human(«name»);

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

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

Выводы о ООП

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

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

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

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

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

Ссылка на основную публикацию
Adblock
detector