Понятие и основные принципы ооп

Объе́ктно-ориенти́рованное
программи́рование (ООП) — методология
программирования, основанная на
представлении программы в виде
совокупности объектов, каждый из которых
является экземпляром определенного
класса^[1],
а классы образуют иерархию наследования^[2][3].

Необходимо
обратить внимание на следующие важные
части этого определения: 1)
объектно-ориентированное программирование
использует в качестве основных логических
конструктивных элементов объекты, а не
алгоритмы; 2) каждый объект является
экземпляром определенного класса; 3)
классы образуют иерархии. Программа
считается объектно-ориентированной,
только если выполнены все три указанных
требования. В частности, программирование,
не использующее наследование, называется
не объектно-ориентированным, а
программированием с помощью абстрактных
типов данных^[4].

Основные
принципы:абстракция,инкапсуляция,наследование,полиморфизм.

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

1. С
   большим текстом просто неудобно
   работать.

2. Разделение
   программы на отдельные модули, которые
   решают конкретные подзадачи.

3. Разделение
   программы на отдельные модули, с целью
   повторного использования этих модулей
   в других программах.

4. Разделение
   интерфейса и реализации.

Как
только мы решаем разделить исходный
текст программы на несколько файлов,
возникают две проблемы:

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

2. Необходимо
   решить каким образом разбить текст
   программы на отдельные файлы.

Первая
проблема — чисто техническая. Она
решается чтением руководств по компилятору
и/или линкеру, утилите make или IDE. В
самом худшем случае просто придётся
проштудировать все эти руководства.
Поэтому на решении этой проблемы мы
останавливаться не будем.

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

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

Во-вторых,
нужно определить интерфейсы для модулей.
Здесь есть вполне чёткие правила.

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

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

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

Важно

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

Наследование предполагает:

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

В ООП главное — это объекты, которые в PHP есть не что иное как переменные абстрактного типа данных

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

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

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

Принципы объектно-ориентированного программирования (ООП)

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

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

Раджеш: «Это просто! Мне просто нужно создать класс Car для хранения всех свойств автомобиля и метод рендеринга для рендеринга этих данных. Посмотрите, что я сделал. »

Мохан тем временем подумал про себя: «Кто здесь главные игроки? и как они будут развиваться в будущем?». Поэтому он пошел немного другим путем и решил сделать отдельные классы для каждой машины. С логикой рендеринга каждой машины, встроенной в сам класс.

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

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

Характеристики изменились!

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

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

Раджеш: «Что? У Мохана был дублированный код в его реализации! Как он продвигается, а не я?»

Чтобы понять, почему Мохан получил повышение, важно знать о его встрече с «четырьмя основными принципами», также известными как «четыре столпа объектно-ориентированного программирования».

Абстракция

Абстракция в oops относится к способности объекта представлять пользователю функциональность более высокого уровня, скрывая детали реализации. Например, когда вы думаете об автомобиле, вы не учитываете тысячи деталей, из которых он состоит. Вместо этого вы, вероятно, думаете о нем как о четко определенной машине с четырьмя колесами, которая может доставить вас из одного места в другое. Автомобили бывают разных марок и моделей, например, Ferrari, Tesla или BumbleBee, но все они по-прежнему считаются «автомобилями». Другими словами, реализация автомобилей может различаться, но абстракция «автомобиля» остается неизменной.

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

• Абстракция через классы: Это достигается с помощью ключевого слова «abstract» с классом. В Java пометка класса как «абстрактный» означает, что он не может быть создан.
• Абстракция через интерфейсы : Подобно абстрактным классам, мы можем использовать «интерфейс» ключевое слово для определения интерфейса.

Мохан: «Но какой смысл создавать класс, экземпляр которого нельзя создать?»

«Дело в том, что мы используем абстрактный класс для определения контракта. Контракт о том, что должен делать класс, а не о том, как это делается. Чтобы использовать мощь абстрактных классов, подумайте о расширении, а не об инициализации. » — Мудрый разработчик ответил

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

Другие различия между абстрактными классами и интерфейсами включают:

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

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

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

Мохан: «Но зачем это кому-то нужно? Если я прячу что-то внутри объекта, какой вообще смысл создавать этот атрибут?»

«Инкапсуляция позволяет нам лучше контролировать и избегать непредсказуемых изменений состояния вашей системы. Например, в предыдущем примере с автомобилем, если бы мы напрямую открыли объект двигателя, не думаете ли вы, что кто-нибудь мог бы вызвать engine.ignite() без ключи?» — ответил мудрый разработчик.

Мохан: «Да, это правда. Так как же мы используем инкапсуляцию в нашей системе?»

«Мы можем использовать модификаторы доступа для достижения инкапсуляции в нашей системе.»

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

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

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

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

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

Давайте подумаем с другой точки зрения!

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

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

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

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

Рахул: «Раджеш, хочешь знать, почему я повысил Мохана?»

Раджеш: «Да».

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

Раджеш: «Как ты это придумал?»

Мохан: «Во время моего первого обзора я понял, что дублирование кода не сработает. Поэтому я инкапсулировал общие свойства в отдельный класс под названием «Автомобиль», а затем использовал наследование, чтобы разделить эти общие свойства со всеми конкретными классами. »

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

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

Мохан: «На самом деле они нам больше не нужны. Виртуальная машина Java (JVM) заботится о вызове правильных методов render() и playSound() в зависимости от типа экземпляра. Этот механизм известен как полиморфизм».

Полиморфизм

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

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

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

Например, рассмотрим класс с именем «Форма», который имеет метод с именем «область». Вы можете создать несколько подклассов «Формы», таких как «Окружность» и «Прямоугольник», каждый со своей собственной реализацией «области». метод. При вызове метода «область» для объекта класса «Форма» будет вызвана правильная реализация в зависимости от типа объекта, с которым он работает. Это позволяет использовать одно и то же имя метода в разных контекстах, делая код более гибким и пригодным для повторного использования.

Код Мохана включает несколько конкретных классов, каждый из которых предоставляет собственную реализацию метода render() . Это называется «переопределением метода», когда мы заменяем поведение метода базового класса новой реализацией. Когда мы вызываем render() для переменной родительского класса, виртуальная машина Java (JVM) определяет правильный метод для вызова на основе экземпляра объекта.

Заключение

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

Наслаждайтесь обучением, наслаждайтесь Ой!

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

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

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

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

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

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

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

Многие популярные языки программирования используют эту парадигму программирования, в том числе JavaScript, Python, C#, Java, PHP и многие другие.

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

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

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

Вот  преимущества объектно-ориентированного программирования :

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

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

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

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

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

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

— Классы,
— Объекты,
— Методы,
— Атрибуты.

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

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

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

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

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

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

This entry was posted in Популярное