Объектно-ориентированное программирование для самых маленьких | by NOP | NOP::Nuances of Programming

Перевод статьи Alexander Petkov: How to explain object-oriented programming concepts to a 6-year-old

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

Уверен, вы поняли, что я имею ввиду.

Ну вот, к примеру:

Кем вы видите себя через 5 лет?

Или еще «лучше»:

Какой ваш главный недостаток?

Боже, ответ на этот вопрос станет моим главным недостатком.

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

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

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

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

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

В 90% случаев его задают новичкам, потому что он помогает разъяснить три вопроса:

1. Готовился ли кандидат к этому интервью?
   Если ответ дается незамедлительно — кандидат ответственно подошел к делу.
2. Прошел ли кандидат начальный этап?
   Понимание принципов объектно-ориентированного программирования (ООП) показывает, что кандидат прошел начальный этап — теперь он видит вещи с более продвинутой точки зрения.
3. Его понимание ООП находится на глубоком или поверхностном уровне?
   Уровень компетентности по данному вопросу часто равен уровню компетентности по большинству других. Доверьтесь мне.

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

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

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

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

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

Теперь допустим, что мы играем в Sims. У нас есть семья из нескольких людей и кошки. Они общаются друг с другом. Мы хотим применить инкапсуляцию, поэтому инкапсулируем всю логику «cat» в класс Cat. Это выглядит следующим образом:

Здесь внутренним состоянием кошки являются частные(private) переменные: настроение(mood), голод(hungry) и энергия(energy). Она также имеет частный(private) метод meow (). Кошка может вызвать его в любой момент, когда захочет, другие классы не могут говорить кошке, когда ей можно мяукать.

То, что им можно делать, определяется в публичных(public) методах sleep (), play () и feed (). Каждый из них каким-то образом влияет на внутреннее состояние кошки и может вызвать meow (). Таким образом, устанавливается связь между внутренним состоянием объекта и публичными методами.

Вот что такое инкапсуляция.

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

Абстракция нацелена на решение этой проблемы.

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

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

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

Хотите еще один пример? Возьмите свой смартфон.

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

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

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

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

Например:

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

На греческом, полиморфизм означает «многообразие форм».

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

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

Эту проблему можно решить, используя полиморфизм.

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

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

Данный принцип позволяет повысить коэффициент повторного использования кода.

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

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

Затем, если потребуется вычислить площадь какого-либо элемента, эта коллекция (список) найдет и выполнит правильный метод. Если элемент является треугольником, выполняется метод CalculateSurface (). Если это круг, выполняется метод CalculateSurface (). И так далее.

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

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

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

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

До скорых встреч!

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

Привет, Хабр! Меня зовут Владислав Родин. В настоящее время я являюсь руководителем курса «Архитектор высоких нагрузок» в OTUS, а также преподаю на курсах, посвященных архитектуре ПО.

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

Введение

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

Вообще устроено все следующим образом: есть само объектно-ориентированное программирование. У него есть принципы. Из принципов объектно-ориентированного программирования следуют разобранные нам шаблоны GRASP (как вариант — SOLID принципы), из которых, в свою очередь, следуют шаблоны GoF. Из них же следует ряд интересных вещей, например, enterprise паттерны.

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

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

Таким образом, система представляется в виде набора объектов предметной области, которые взаимодействуют между собой некоторым образом. Каждый объект обладает тремя cоставляющими: идентичность (identity), состояние (state) и поведение (behaviour).

Состояние объекта — это набор всех его полей и их значений.

Поведение объекта — это набор всех методов класса объекта.

Идентичность объекта — это то, что отличает один объект класса от другого объекта класса. С точки зрения Java, именно по идентичности определяется метод equals.

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

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

1. Абстрация
2. Инкапсуляция
3. Наследование
4. Полиморфизм

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

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

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

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

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

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

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

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

методы.

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

Полиморфизм

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

За самым садистским определением кроется возможность языка программирования для декомпозиции задачи и рефакторинга if’ов и switch’ей.

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

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

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

Объект : Экземпляр класса / это рабочий объект класса

Класс : Это модель или стандарт о возможностях того, что объект может делать

Метод: Может изменять класс состояние, которое будет применяться ко всем экземплярам класса

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

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

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

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

      Также существует закрытый метод: bark(). Класс собаки может вызвать это, когда захочет, и другие классы не могут сказать собаке, когда лаять. Существуют также общедоступные методы, такие как sleep(), play() и eat(), которые доступны другим классам. Каждая из этих функций изменяет внутреннее состояние класса Dog и может вызывать bark(), когда это происходит, приватное состояние и общедоступные методы связаны.

Абстракция

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

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

      Наследование — это способность одного объекта приобретать некоторые/все свойства другого объекта. Например, ребенок наследует черты своих родителей. При наследовании возможность повторного использования является основным преимуществом. Вы можете повторно использовать поля и методы существующего класса. В Java существуют различные типы наследования: одиночное, множественное, многоуровневое, иерархическое и гибридное. Например, Apple — это фрукт, поэтому предположим, что у нас есть класс Fruit и его подкласс с именем Apple. Наше яблоко приобретает свойства класса Fruit. Другими классификациями могут быть виноград, груша, манго и т. Д. Фрукты определяют класс продуктов, которые представляют собой зрелые завязи растения, мясистые, содержащие большое семя внутри или множество крошечных семян. Яблоко подкласса приобретает эти свойства от фруктов и обладает некоторыми уникальными свойствами, которые отличаются от других подклассов фруктов, такими как красное, круглое, углубление наверху.

Полиморфизм

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

ПОДРОБНЕЕ:  Основы между GraphQL и REST API, Прототипирование и исследования UX, Диаграммы подобия и кластеризация, Создание пользовательского пользовательского интерфейса: Создание цветовой схемы

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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