Какое программирование основано на представлении программы в виде совокупности объектов

Обновлено: 05.07.2024

• Open with Desktop
• View raw
• Copy raw contents Copy raw contents Loading

Copy raw contents

Copy raw contents

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

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

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

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

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

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

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

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

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

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

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

Полиморфизм – это свойство системы использовать объекты с одинаковым интерфейсом без информации о типе и внутренней структуре объекта.

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

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

• ad hoc, функция ведет себя по разному для разных типов аргументов (например, функция draw() — рисует по разному фигуры разных типов);
• параметрический, функция ведет себя одинаково для аргументов разных типов (например, функция add() — одинаково кладет в контейнер элементы разных типов).

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

Расскажите про основные понятия ООП: «класс», «объект», «интерфейс».

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

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

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

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

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

В чем заключаются преимущества и недостатки объектно-ориентированного подхода в программировании?

• Объектная модель вполне естественна, поскольку в первую очередь ориентирована на человеческое восприятие мира, а не на компьютерную реализацию.
• Классы позволяют проводить конструирование из полезных компонентов, обладающих простыми инструментами, что позволяет абстрагироваться от деталей реализации.
• Данные и операции над ними образуют определенную сущность, и они не разносятся по всей программе, как нередко бывает в случае процедурного программирования, а описываются вместе. Локализация кода и данных улучшает наглядность и удобство сопровождения программного обеспечения.
• Инкапсуляция позволяет привнести свойство модульности, что облегчает распараллеливание выполнения задачи между несколькими исполнителями и обновление версий отдельных компонентов.
• Возможность создавать расширяемые системы.
• Использование полиморфизма оказывается полезным при:
  • Обработке разнородных структур данных. Программы могут работать, не различая вида объектов, что существенно упрощает код. Новые виды могут быть добавлены в любой момент.
  • Изменении поведения во время исполнения. На этапе исполнения один объект может быть заменен другим, что позволяет легко, без изменения кода, адаптировать алгоритм в зависимости от того, какой используется объект.
  • Реализации работы с наследниками. Алгоритмы можно обобщить настолько, что они уже смогут работать более чем с одним видом объектов.
  • Возможности описать независимые от приложения части предметной области в виде набора универсальных классов, или фреймворка, который в дальнейшем будет расширен за счет добавления частей, специфичных для конкретного приложения.
  • Сокращается время на разработку, которое может быть отдано другим задачам.
  • Компоненты многоразового использования обычно содержат гораздо меньше ошибок, чем вновь разработанные, ведь они уже не раз подвергались проверке.
  • Когда некий компонент используется сразу несколькими клиентами, улучшения, вносимые в его код, одновременно оказывают положительное влияние и на множество работающих с ним программ.
  • Если программа опирается на стандартные компоненты, ее структура и пользовательский интерфейс становятся более унифицированными, что облегчает ее понимание и упрощает использование.

  Что подразумевают в плане принципов ООП выражения «является» и «имеет»?

  «является» подразумевает наследование. «имеет» подразумевает ассоциацию (агрегацию или композицию).

  В чем разница между композицией и агрегацией?

  Ассоциация обозначает связь между объектами. Композиция и агрегация — частные случаи ассоциации «часть-целое».

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

  Что такое статическое и динамическое связывание?

  Присоединение вызова метода к телу метода называется связыванием. Если связывание проводится компилятором (компоновщиком) перед запуском программы, то оно называется статическим или ранним связыванием (early binding).

  В свою очередь, позднее связывание (late binding) это связывание, проводимое непосредственно во время выполнения программы, в зависимости от типа объекта. Позднее связывание также называют динамическим (dynamic) или связыванием на стадии выполнения (runtime binding). В языках, реализующих позднее связывание, должен существовать механизм определения фактического типа объекта во время работы программы, для вызова подходящего метода. Иначе говоря, компилятор не знает тип объекта, но механизм вызова методов определяет его и вызывает соответствующее тело метода. Механизм позднего связывания зависит от конкретного языка, но нетрудно предположить, что для его реализации в объекты должна включаться какая-то дополнительная информация.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  Полиморфизм

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

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

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

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

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

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

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

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

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

  2. Приватный (private). На этом уровне обычно расположена вся внутренняя реализация вашего класса. Так же здесь может быть представлен, как ни странно, конструктор вашего класса, если вы вдруг захотели сделать его виртуальным. Доступ к этим полям и методам возможен только изнутри самого объекта.

  3. Защищённый. (protected). Представляет из себя что-то среднее между приватным и публичным. Поведение на данном уровне схоже с поведением на приватном уровне. Доступ к этим элементам класса возможен из самого объекта, а также из объектов класса-наследника.

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

  Второй, но не менее важный принцип – Наследование . Классы могут быть созданы не только с нуля, но и как продолжение «рода» другого класса. В теории нет разницы, от скольких классов будет идти наследование: от одного единственного или же от целого множества различных классов. На выходе мы будем иметь один класс. Также, в теории, существует 3 разных способа наследования: публичный, приватный, и защищённый.

  1. Публичный (public). При публичном наследовании новый класс будет иметь все те же поля что и класс родитель, с всё теми же уровнями доступа.

  2. Защищённый (protected). При приватном наследовании, публичные поля станут защищёнными, остальные без изменений.

  3. Приватный (private). При приватном наследовании все поля класса, от которого наследуется приватным методом, перейдут в приватное состояние

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

  Абстракция

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

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

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

  Полиморфизм

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

  
  

  Рассказываю об одной из важнейших парадигм в программировании.

  Парадигмы программирования и их виды

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

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

  Существуют различные типы парадигм, например процедурный, ориентированный на работу с функциями, или логический, подразумевающий решение базовых логических задач в духе «если А = true, то и B = true». Но есть и более интересный подход к решению задач разработки, и это ООП-парадигма.

  Что такое ООП?

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

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

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

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

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

  Объекты

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

  
  

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

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

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

  Методы

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

  Атрибуты

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

  Классы

  Это наиболее абстрактная и обобщенная форма в ООП. Что-то в духе шаблона, на базе которого строятся другие элементы структуры кода.

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

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

  
  

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

  Ключевые принципы ООП

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

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

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

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

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

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

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

  
  

  Это проще понять на примере со средствами передвижения:

  Берем абстрактный класс «Средство передвижения» с возможностью набирать скорость и перевозить людей.

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

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

  Не нужно каждый раз создавать новый класс или объект с полным набором опций. Достаточно воспользоваться конструкцией в духе export class Bus extends Vehicle() и дополнить код конкретикой.

  Абстракция

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

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

  Полиморфизм

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

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

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

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

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

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

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

  Расширяемость: ООП-код легче развивать, дополнять и менять. Этому способствует независимая модульная структура.

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

  Безопасность: инкапсулированный код недоступен извне, поэтому «поломать» ООП-программу сложнее.

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

  Недостатки ООП

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

  Языки, исповедующие объектно-ориентированную парадигму

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

  Ruby – высокоуровневый язык с динамической типизацией, созданный в середине 90-х японским разработчиком Юкихиро Мацумото.

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

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

  Вместо заключения

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

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

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

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

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

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

  
  

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

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

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

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

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

  Абстракция

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

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

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

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

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

  Полиморфизм

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

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

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

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

  Читайте также:

    
  • Замена в ворде 2003
    
  • Что можно делать в ворде и экселе
    
  • Как проверить разрешения сайтов в яндекс браузере
    
  • Яндекс браузер как выбрать версию
    
  • Как вложить excel файл в excel