Тематический урок-конференция на тему: «Объектно-ориентированное программирование»


Тематический урок-конференция
Тема: «Объектно-ориентированное программирование»
Автор: Новикова Н.В.

Содержание
Введение……………………………………………………………………….…......3
Основная часть……………………………………………..…………………….......4
Языки программирования…………………………………………………….......4
Цели ООП………………………………………………………………….………5
Разновидности ООП…………………………………………………………..…..7
История ООП………………………………………………………………….......9
Иерархия и структура ООП………………………………………………..……13
Что нужно для создания объектно-ориентированных программ………..…...15
Что создаётся с помощью ООП…………………………………………….......16
Как писать с помощью ООП………......……………………………………......17
Исследование и модернизация ООП…………………………….......................18
Сложности ООП..………………………………………………………………..20
Зачем нужен ООП……………..…………………………………………………23
Плюсы и минусы ООП………………………………...………………….……..25
Критика ООП………..……………………………………………………….…..26
Актуальность ООП………….…………………………………………………...28
Заключение………………………………………………………………………….29
Список литературы……………………………………………………………...….30
Введение
Актуальность темы обусловлена большим количеством программистов, работающих именно с объектно-ориентированным программированием, которое на данный момент является одной из самых распространенных и известных парадигм. И именно поэтому начинающим программистам и специалистам в сфере IT-технологий необходимо его изучить. Большое число программистов начало думать в терминах ООП, большое число кода написано и протестировано, но не все еще полностью изучено и именно поэтому нам еще есть куда двигаться, и что модернизировать, ведь еще не раскрыт весь потенциал данной парадигмы. Это то, что делает объектно-ориентированное программирование актуальным ещё долгое время, особенно с целью решения классических задач.
Выделено несколько основных объектов для изучения:
Объектно-ориентированное программирование.
Языки объектно-ориентированного программирования.
Синтаксис данных языков.
Программы, написанные на данном языке и их структура.
Основная цель - исследование парадигмы объектно-ориентированного программирования, а также механизма написания программы на объектно-ориентированном языке. Для достижения данной цели выделено несколько задач-ориентиров для поиска информации и написания исследовательской работы:
Изучить теоретическую составляющую данной парадигмы, её цели и разновидности.
Рассмотреть реализацию программ, написанных на объектно-ориентированных языках.
Выявить все положительные и отрицательные части данной парадигмы.
Основная часть
Языки программирования
Программирование – это искусство делать программные продукты, которые написаны на языке программирования.
Язык программирования – это формальная знаковая система, которая предназначена для написания программ, ясных для исполнителя. Язык программирования определяет комплект лексических, синтаксических и семантических правил, задающих наружный вид программы и действия, которые осуществляет исполнитель под её управлением. Со времени формирования первых программируемых машин было сделано более 2-ух с половиной тыс. языков программирования. Каждый год их количество дополняется новыми. Некоторыми языками может пользоваться только лишь небольшое число их собственных создателей, прочие становятся известны млн. людей. Профессиональные программисты как правило используют в своей работе ряд языков программирования.
Цели ООП
Языки объектно-ориентированного программирования (ООП)
Объектно-ориентированный язык программирования (ОО-язык) – язык, созданный на принципах объектно-ориентированного программирования. В основе концепции ООП находится понятие объекта.Основная задача объектно-ориентированного программирования заключается в управлении сложным процессом разработки нынешнего программного обеспечения. Эта задача определяет ряд направлений обеспечения качества приложений, в том числе применение качественных структур данных и алгоритмов. В частности, программная реализация должна владеть устойчивостью, возможностью к адаптации и возможностью многократного применения.Устойчивость
Одной из целей работы каждого хорошего программиста считается корректность программы, то есть получение верных результатов на всем множестве входных потоков данных. Устойчивость программного обеспечения заключается в способности обрабатывания внезапных входных данных, которые не были явно описаны в нем.
Цель обеспечения устойчивости заключается не только лишь в способности справляться с внезапными значениями входных данных. Программное обеспечение обязано обладать способностью принимать правильные решения, несмотря на существующие ограничения. К примеру, в случае если пользователю необходимо внести в структуру данных большее количество элементов, чем было первоначально запланировано, программа обязана повысить объем структуры.
АдаптируемостьСовременные приложения, такие как текстовые процессоры, Web-браузеры и поисковые системы Интернета, используют большие программы, которые рассчитаны на применение в течение длительного периода. В связи с этим программное обеспечение обязано иметь возможность развиваться со временем в соответствии с меняющимися условиями среды.
Возможность многократного применения
Идея адаптируемости тесно связана с многократным применением программного обеспечения, при котором код применяется в качестве компонентов разных систем либо приложений. Создание качественного программного обеспечения крайне дорогостояща, но затраты эти будут частично уменьшены, в случае если создаваемые продукты смогут употребляться в иных приложениях и последующих приложениях.
Разновидности ООП
Существует несколько ООП-методологий:
Компонентное программирование.
Компонентно-ориентированное программирование–это своеобразная «надстройка» над ООП, набор правил и ограничений, нацеленных на построение крупных развивающихся программных систем с большим временем существования. Программная система в данной методологии представляет собой набор компонентов с хорошо определёнными интерфейсами. Изменения в имеющуюся систему вносятся путём формирования новых компонентов в дополнение либо в качестве замены ранее существующих. При формировании новых компонентов, на основе ранее сформированных запрещено применение наследования реализации – новый компонент может наследовать только интерфейсы базового. Таким образом компонентное программирование обходит проблему хрупкости базового класса.
Прототипное программирование
Прототипное программирование, сохранив часть черт ООП, отказалось от базовых определений – класса и наследования.
Прототип – это объект-образец, по образу и подобию которого формируются другие объекты. Объекты-копии смогут сохранять связь с родительским объектом, автоматически наследуя изменения в прототипе; данная особенность определяется в рамках конкретного языка.
Вместо механизма описания классов и порождения экземпляров язык предоставляет механизм формирования объекта (путём задания набора полей и методов, которые объект обязан иметь) и механизм клонирования объектов.
Каждый вновь сформированный объект считается «экземпляром без класса». Каждый объект способен стать прототипом–быть использован с целью формирования нового объекта с помощью операции клонирования. Уже после клонирования новый объект может быть изменён, в частности, дополнен новыми полями и методами.
Клонированный объект или становится полной копией прототипа, хранящей все значения его полей и дублирующей его методы, либо сохраняет ссылку на прототип, не включая в себя клонированных полей и методов вплоть до тех пор, пока они не будут изменены. В последнем случае среда исполнения обеспечивает механизм делегирования – в случае если при обращении к объекту он сам не содержит нужного метода либо поля данных, вызов передаётся прототипу, от него, при необходимости, далее по цепочке.
Класс-ориентированное программирование.
Класс-ориентированное программирование – это программирование, сфокусированное на данных, причём данные и поведение неразрывно связаны между собой. Вместе данные и поведение представляют собой класс. В соответствии с этим в языках, основанных на понятии «класс», все объекты разделены на 2 основных типа – классы и экземпляры. Класс определяет структуру и функциональность (поведение), одинаковую для всех экземпляров этого класса. Экземпляр считается носителем данных – то есть обладает состоянием, меняющимся в соответствии с поведением, заданным классом. В класс-ориентированных языках новый экземпляр создаётся посредством вызова конструктора класса (возможно, с комплектом параметров). Получившийся экземпляр имеет структуру и поведение, жёстко установленные его классом.
История ООП
Всё таки первым компьютерным решением, воплотившим в себе объектный подход, был программно-аппаратный графический планшет (Sketchpad: A Man-Machine Graphical Communications System), который использовал спецоборудование DEC PDP. Его в 1963 г. создал двадцатипятилетний Иван Сазерленд.В качестве определения класса Сазерленд применял обозначение «мастер», деля описание и действительно имеющийся на экране предмет (экземпляр «мастера»).
Основоположниками объектного подхода в программировании являются жители Норвегии Оле Джохан Дал и Кристен Нюгорт, создатели языка «Симула». В 1952 г. Нюгорт начал работать моделированием больших и сложных систем реального мира, в 1957-м приобрел возможность компьютерной реализации собственных планов в машине «Ferranti MERCURY», однако быстро осознал, то что машинные языки и Фортрана сильно урезаны.
История «Симулы» стартовала в 1962 г. с проекта «Simulation Language», предназначенного для программного моделирования методики Монте-Карла. Нюгорт стал создавать язык дискретного моделирования. Он сотрудничал с Оле Джохан Далом.
В 1965 г. создателям пришла в голову идея совместить данные с процедурами, которые их обрабатывали. Уже после успешного обсуждения способностей «Симулы I» на саммите НАТО в 1966 г. принято решение было продолжать его усовершенствование. Создатели разработали термины «класс» и «объект». Тогда же возникла и технология наследования – создатели «Симулы» включили в язык возможность использования различными классами единых свойств посредством указания названия класса в виде префикса.
В NCC образовали рабочую группу «Simula Standards Group». Спустя время к ней подключился Якоб Палме. Он добавил в «Симулу» механизм сокрытия переменных. 1-ый уже сформировавшийся компилятор обновленной «Симулы 67» узрел свет в 1969 г.
Тем временем Алан Кей тщательно исследовал мысли, заложенные в Планшет, «Симулу» и ещё 2 уникальных языка – «LISP», который использовали с целью задач искусственного интеллекта, и LOGO, который был предназначен для обучения базовым понятиям программирования. В процессе ознакомления с данными языками Кей разработал новую концепцию разработки, в соответствии с которой комплект последовательно выполняющихся инструкций мог быть заменен на многомерную среду взаимодействия объектов, общающихся друг с другом посредством асинхронного обмена сообщениями. В конце 50-х годов Кей трудился на Денверской военно-воздушной базе «Рандольф» (Randolph), где писал на машинном коде программы для электронно-вычислительных машин «Burroughs 220», в то время у него возникла трудность передачи сформированных на данной машине данных на компьютеры других баз. Стандартных форматов и операционных систем в современном представлении для тех электронно-вычислительных машин не имелось, по этой причине Кею потребовалось делать микропрограммы, которые включали в себе всю необходимую информацию и уже после запуска на других машинах через обычный пользовательский интерфейс самостоятельно разворачивали необходимые данные. Эти программы Кей первоначально назвал «модулями», соединявшими данные и код. В 1966 г. он начал заниматься научной работой в сфере молекулярной биологии, тогда он осознал всю значимость данной мысли. Кей изобрел системы модулей (вероятно, уже в то время он дал им название «объекты»), соединяющие данные и алгоритмы их обработки, способные взаимодействовать друг с другом посредством определенных разработчиком интерфейсов, однако не имеющих представления о том, что происходит за их пределами.
Позже Кей ушел в Стэндфордскую лабораторию по искусственному интеллекту, а в 1972 г. устроился на работу в хорошо известный научный центр «Xerox PARC», где и осуществил данные идеи в новом объектном языке «SmallTalk», с его 1-ым названием «Biological System». В период данной работы он предложил знаменитый термин «объектно-ориентированное программирование» (ООП). Заложенные в «SmallTalk» мысли ООП и по сей день остались непревзойденными ни в каких иных языках и системах.
1974 г. Марвин Мински, автор теории искусственного интеллекта, предложил идею фрейма, который отсоединял описание класса (структуры) объекта от его конкретного представления (экземпляра) и стремительно завоевавшего популярность в языках искусственного интеллекта. Фрейм стал прямым предком нынешнего понятия объектов в «С++».
1980 г. Бьерн Страуструп, который продолжил дело своих коллег из лаборатории Bell, дополнил язык «С» концепцией классов, основанной на фреймах и объектных механизмах «Симулы».
1992 г. Вышел стандарт «CORBA 1.0», который определял основные аспекты функционирования «CORBA-систем».
1993 г. Корпорация «Microsoft» выпустила 1-ую версию компонентной модели «COM (Component Object Model)». Сначала «COM» готовилась только лишь с целью поддержки технологии встраивания и связывания документов «OLE», однако стремительно выделилась в самостоятельное направление.
1994 г. Опубликован стандарт «CORBA 2.0», который весьма стремительно приобрел массовое признание, так как показывал собой богатый и глубоко проработанный набор документов, а кроме того охватывал большинство нужных, в тот период, рынком задач. В нем были устранены недостатки прошлой версии.
1995 г. «Sun Microsystems» легко распространяет в Интернете элемент технологии «Java» – среду «HotJava», которая поддерживала мобильный код, разработку проекта «Green», которая к этому периоду считалась в «Sun» почти безнадёжной, если бы не развитие сети.
Корпорация «Borland» изготовила первую версию среды быстрой визуальной разработки «Delphi 1», которая была сформирована на концепции библиотек стандартных компонентов.
2000 г. «Microsoft» анонсирует новую объектную платформу «.NET» и новый язык программирования «C#», комбинирующий наилучшие качества «С++» и «Java». Он был предложен «Microsoft» во многом в противовес «Java».
2001 г. «OMG» выпускает спецификацию «CORBA 3.0». Эта спецификация была дополнена возможностями асинхронного обмена сообщениями, разработки систем реального времени и формирования встраиваемых систем. Особенный акцент в третьей версии «CORBA» сделан на эффективном взаимодействии с «Java».
В настоящее время кол-во прикладных языков программирования, котрые осуществят объектно-ориентированную парадигму, является наибольшим по отношению к иным парадигмам. Более распространённые в промышленности языки («С++», «Delphi», «C#», «Java» и др.) воплощают объектную модель «Симулы». Образцами языков, опирающихся на модель «SmallTalk», считаются «Python», «Ruby».

Иерархия и структура ООП
Иерархия – это упорядочение абстракций, размещение их по уровням. Объектно-ориентированное программирование применяет в качестве компонентов конструкции классы и объекты, а не алгоритмы.
Идея классов считается основой ООП и отображает устройство объектов реального мира, так как каждый предмет либо процесс владеет набором характеристик либо отличительных черт, другими словами, свойствами и поведением.
Класс – описание большого количества объектов, объединенных общностью структуры и поведением. Имеется явное распределение внешнего и внутреннего описания класса (интерфейса и реализации). Интерфейс отображает внешнее поведение объекта, описывая абстракцию поведения абсолютно всех объектов этого класса, однако скрывает структуру и неважные детали. Реализация составляет его внутреннее проявление и устанавливает характерные черты поведения.
Объект представляет собою особенный опознаваемый предмет либо сущность (реальную либо абстрактную), имеющие четко определенное функциональное предназначение в этой предметной области. Структура и поведение схожих объектов описываются в общем для них классе.
В ООП определенные величины типа данных «класс» называют экземплярами класса, либо объектами. Объекты взаимодействуют между собою, отправляя и получая сообщения. Сообщение – это запрос на осуществление действия, содержащий комплект требуемых параметров. Механизм сообщений реализуется с помощью вызова определенных функций либо методов классов.
Основными принципами либо свойствами ООП считаются инкапсуляция, наследование и полиморфизм:Инкапсуляция – это использование модификаторов доступа с целью сокрытия частей программного кода от конечного пользователя. Под ним, в свою очередь, подразумевается разработчик или наследующий объект.
Суть же понятия "инкапсуляция" заключается в манипулировании модификаторами доступа. Это означает, что разработчик сам решает, какие свойства, методы и классы будут открыты классу-клиенту, а какие - скрыты.
Наследование – умение объекта сохранять свойства и методы класса-родителя.
Основными типами иерархических структур применительно к сложным системам считаются структура классов (иерархия "is-a") и структура объектов (иерархия "part of").
Важным компонентом объектно-ориентированных систем и основным типом иерархии "is-a" считается концепция наследования. Наследование обозначает такое отношение среди классами (отношение родитель/потомок), когда 1 класс заимствует структурную либо функциональную часть одного либо нескольких других классов. Зачастую подкласс достраивает либо переписывает элементы вышестоящего класса.
В иерархии "part of" класс находится на наиболее высоком уровне абстракции, нежели любой из использовавшихся при его осуществлении. Агрегация есть в абсолютно всех языках, использующих структуры, состоящие из разнотипных данных. Однако в объектно-ориентированном программировании она обретает новую мощь: агрегация дает возможность физически объединить логически связанные структуры, а наследование с легкостью копирует эти общие группы в разнообразные абстракции. При ликвидировании объекта главного класса должны быть ликвидированы все без исключения объекты, являющиеся его элементами.
Полиморфизм – одна из трех основных парадигм ООП. Если говорить кратко, полиморфизм – это способность объекта использовать методы производного класса, который не существует на момент создания базового. Для тех, кто не особо сведущ в ООП, это, наверно, звучит сложно.
Что нужно для создания объективно-ориентированных программ
Для объектно-ориентированного программирования требуется знание его основ, а именно что такое ООП, как оно работает, из чего состоит, где используется, для чего. А также требуется знание хотя-бы одного языка и его синтаксиса. Требуются программно-аппаратные средства: Персональный компьютер (аппаратное средство), Соответствующее программное обеспечение (среда разработки, например, «Visual Studio»). Правильно сформулированное техническое задание.
Что создаётся с помощью ООП
Объектно-ориентированное программирование, или ООП, широко распространенная программная парадигма, используемая сегодня большинством языков. В ООП программисты организуют код в виде объектов, которые похожи на концепции, применяемые в реальном мире, как, например, покупательская корзина.
Вообще задача любого программиста – это как можно сильнее упростить код, чтобы нам с ним было легче работать. А мы в повседневной жизни в основном и думаем «Объектами», а не «Процедурами», именно поэтому способ ООП для многих из нас будет легче.
ООП создавался для того, чтобы имитировать ситуации, возникающие в реальном мире, поэтому было бы правильно пользоваться такими терминами, которые мы применяем в повседневном обиходе.
Основной строительный блок в ООП – это класс (class). Класс описывает объект, но не является его конкретным экземпляром. И, прежде чем Вы начнете использовать объекты, Вы должны создать для них класс.
Так же ООП используют в случае, когда программа тесно связанна с обрабатываемыми ей данными. На пример прочитать текст из файла и вывести его на экран можно и не прибегая к ООП,а вот если эти данные не однородны, должны по-особому обрабатываться и имеют кучу ограничений на чтение/редактирование и удаление, то тут хочешь не хочешь, а чтоб окончательно не запутаться прибегнешь к ООП.
Как писать с помощью ООП
Прежде всего, как мы знаем любая ОО-программа начинается с объявления, используемых, ресурсов. Потом мы прописываем имя нашего проекта, после чего мы должны объявить класс. Лучше всего после объявления класса объявить переменные, что бы они распространялись на всю программу. Потом мы начинаем писать сам код программы, в котором мы указываем все объекты, методы, доп. переменные, массивы, инструменты и т.д. Для того, чтобы это написать обязательно надо знать язык программирования, на котором ты пишешь, его синтаксис, все его составные части: массивы, виды переменных, методы и т.д, правила по написанию программы.
Исследование и модернизация ООП
Несмотря на многомиллионные инвестиции, произведенные в 1970-1980 годах коммерческими фирмами и государственными структурами различных государств в универсальные языки программирования (такие, как Алгол, PL/1, Си) и языки логического программирования (в первую очередь Prolog), наиболее распространенной в мире программной технологией остается ООП. Наиболее известным событием нового тысячелетия в данной сфере стал стремительно набравший известность язык программирования C#. Его можно уверенно рассматривать наилучшим на сегодняшний день объектно-ориентированным средством формирования графических приложений (формально - для различных платформ, по сути же - только для .NET, так как без среды разработки значимость C# равна нулю). Разумеется, наилучшим C# возможно назвать среди незначительного количества коммерческих альтернатив (Java, С++ и, возможно, Delphi). Если же сравнить его способности со средствами SmallTalk, в таком случае окажется, то что ряд сильных идей ООП, заложенных в SmallTalk современными инженерными умами, окажутся в C# упущенным.
В ближайшее десятилетие формирование ООП будет протекать под воздействием 3-х концепций: Microsoft .NET (в первую очередь всего .NET Framework и её подмножества и в соответствии с этим реализации C#), Java (все без исключения входящие в данное понятие технологии) и CORBA. При этом важнейшей характерной чертой CORBA останется независимость от ОС и языка программирования CORBA-компонентов. Методика MDA будет главной объединяющей платформой моделирования для абсолютно всех этих технологий, в первую очередь в целом в силу своей независимости от конкретного разработчика. Существенна и объявленная сквозная поддержка MDA в абсолютно всех средствах разработки "Швейцарии в мире ПО" - корпорации Borland - и гиганта IBM (в особенности принимая во внимание не так давно произошедшую покупку Rational Software и формирование проекта Eclipse). То, что затрагивает "программирования в малом" (programming in small), в таком случае в данной сфере продолжится усовершенствование шаблонов проектирования (высокоуровневого объектного программирования), их введение в среды разработки и последующее комбинация шаблонного подхода с стремительно развивающимся языком моделирования UML, заключительная версия которого 2.0 появится со дня на день.
Хочется кроме того надеяться, на то что со временем в коммерческих оболочках создания ПО на известных языках программирования все же будут выполнены идеи ООП, предложенные ещё двадцать пять лет назад создателями SmallTalk.
Классы в самом не далеком будущем вступят в стандартный набор концепций для каждого программиста, точно так же, как многие на сегодняшний день применяют динамические структуры данных и рекурсию, которые 20 лет назад были также в диковинку. В то же время классы – это попросту ещё одна новая конструкция наряду с другими. Нам необходимо узнать, для каких ситуаций они подойдут, и только лишь здесь мы и будем их применять. Грамотно подобрать инструмент для конкретной задачи – непременно для каждого мастерового и в ещё большей степени для каждого инженера.
ООП ввергает многих в состояние эйфории. Пестрящая тут и там реклама обещает нам невообразимые вещи, и даже некоторые исследователи, похоже, предрасположены рассматривать ООП как панацею, способную решить все без исключения трудности разработки программного обеспечения. Со временем эта эйфория постепенно уляжется. И уже после этапа разочарования общество, быть может, прекратят уже говорить об ООП, точно также как на сегодняшний день вряд ли от кого можно услышать о структурном программировании. Однако классы станут применять как нечто само собою разумеющееся, и мы сможем, в конечном итоге, осознать, то что они собою представляют: просто компоненты, которые помогают создавать модульное и расширяемое программное обеспечение.
Сложности ООП
Как и в любом другом языке, в объектно-ориентированном языке тоже есть свои проблемы:
Есть одна проблема с повторным копированием, а ведь это одно из основных преимуществ ООП.Допустим у вас есть готовая программа, а вам надо написать новую, в которую вы хотите вставить класс из той, старой программы. И когда вы его копируете, по идее всё должно быть хорошо, но вам выдаётся ошибка, и вам приходиться копировать родительский класс, но и этого недостаточно, ведь надо еще скопировать родителя родительского класса, и в конце концов выходит, что нужны все родители. Но это еще не вся проблема. Ведь в этом классе есть объект и мне, чтобы он работал нужно скопировать всех его родителей, и так для каждого вложенного объекта.
Джо Армстронг, создатель Erlang, когда-то сказал великолепные слова: Проблема с ОО-языками состоит в том, что они тянут за собою всё своё окружение. Вы желали всего лишь банан, но в результате получаете гориллу, держащую этот банан, и все джунгли в придачу.
Можно выйти из ситуации, не создавая очень глубоких иерархий. Однако поскольку наследование является ключом к повторному применению, то любые накладываемые на данный механизм ограничения однозначно уменьшат преимущества, получаемые от него. А для того чтобы всё-таки решить проблему необходимо агрегировать (contain) и делегировать (delegate).
А вот ещё одна проблема. Взглянем на код:
Class PoweredDevice {
}
Class Scanner inherits from PoweredDevice {
function start() {
}
}
Class Printer inherits from PoweredDevice {
function start() {
}
}
Class Copier inherits from Scanner, Printer {
}
Обратите внимание, что классы Scanner и Printer оба реализуют функцию start. Тогда какую функцию start унаследует класс Copier? Та, что реализована классом Scanner? Или классом Printer? Не могут же они обе унаследоваться.
И у этой проблемы есть решение, вот оно:
Class PoweredDevice {
}
Class Scanner inherits from PoweredDevice {
function start() {
}
}
Class Printer inherits from PoweredDevice {
function start() {
}
}
Class Copier {
Scanner scannerPrinter printerfunction start() {
printer.start()}
Класс Copier теперь содержит экземпляры Printer и Scanner. Он делегирует реализацию функции start классу Printer. А может так же легко делегировать Scanner.
Для увеличения производительности, функциям передаются не значения объектов, а ссылки на них. Это означает, что и сами функции передают никак не объекты, а ссылки. В случае если ссылка на объект передаётся конструктору объектов, то он кладёт ее в приватную переменную, защищённую инкапсулированием. Однако переданный объект небезопасен! Почему? Потому в какой-то части нашего кода находится указатель на объект, то есть код, вызывающий конструктор. Но он ДОЛЖЕН иметь ссылку на объект, в противном случае он не сможет передать ее конструктору.
А вот решение. Конструктору потребуется клонировать переданные объекты. Причём клон обязан быть полным, то есть клонироваться будут все без исключения объекты, находящиеся в переданном объекте, и все без исключения объекты, находящиеся в этих объектах, и т.д. И всё ради увеличения эффективности. Однако дело в том, что не все объекты могут быть клонированы. Некоторые занимают ресурсы операционной системы, которые с ними ассоциированы, так что в наилучшем случае клонировать их бесполезно, а в наихудшем – нет возможности.
Зачем нужно ООП
ООП нужно для:
Упрощение понимания чловеком.
Ведь наш, человеческий, язык так и устроен. Человек привык обозначать класс предметов схожего поведения одним словом, которое определяет его поведение.
Что же удивительного в том, что эта практика перекочевала в программирование?
Ведь гораздо проще рассуждать о стеке, чем об «этом наборе данных и кода, который отдает первым последний занесенный объект».
Локализация кода
Когда нам нужно работать с несколькими данными нам придётся работать отдельно с каждой из них, но в ООП эта проблема решается с помощью локализации. То есть мы просто все эти данные объединяем под одним классом и применяем действие не по отдельности к каждому, а сразу ко всем.
Одной из самых значительных проблем в программировании считается сложность. Чем больше и сложнее программа, тем важнее становится разбить её на небольшие, четко очерченные части. Для того чтобы преодолеть сложность, мы должны абстрагироваться от мелких деталей. В этом смысле классы представляют собой крайне удобный инструмент:
Классы дают возможность осуществлять конструирование из полезных компонент, владеющих простыми инструментами, что предоставляет возможность абстрагироваться от деталей реализации.
Данные и операции совместно образуют определенную сущность, и они не «размазываются» по всей программе, как это зачастую бывает в случае процедурного программирования.
Локализация кода и данных улучшает наглядность и удобство сопровождения программного обеспечения.
Инкапсуляция данных защищает наиболее критичные данные от несанкционированного доступа.
ООП предоставляет возможность создавать расширяемые системы (extensible systems). Это одно из самых существенных достоинств ООП и именно оно отличает этот подход от традиционных методов программирования. Расширяемость (extensibility) обозначает, то что существующую систему можно заставить работать с новыми компонентами, причем без внесения в нее каких-либо изменений.
Расширение типа (type extension) и вытекающий с него полиморфизм переменных оказываются полезными в большей степени в следующих ситуациях:
Обработка разнородных структур данных. Программы могут работать, не утруждая себя изучением вида объектов. Новые виды могут быть добавлены в любой время.
Изменение поведения во время исполнения. На стадии исполнения 1 объект может быть заменен другим. Это может привести к изменению алгоритма, в котором применяется этот объект.
Реализация родовых компонент. Алгоритмы можно обобщать вплоть до такой степени, что они уже смогут работать более, чем с 1 видом объектов.
Доведение полуфабрикатов. Компоненты нет необходимости подстраивать под конкретное приложение. Их можно сохранять в библиотеке в виде полуфабрикатов (semifinished products) и расширять по мере необходимости вплоть до различных законченных продуктов.
Расширение каркаса. Независимые от приложения части предметной области могут быть выполнены в виде каркаса и в последующем расширены за счет прибавления частей, специфичных для определенного приложения.
Плюсы и минусы ООП
Многоразового применения программного обеспечения на практике достичь не удается из-за того, что имеющиеся компоненты уже никак не отвечают новым требованиям. ООП помогает этого достичь в отсутствии нарушения работы уже существующих клиентов, что дает возможность нам извлечь наибольшее количество из многоразового применения компонент.
Мы сокращаем время на разработку, которое с выгодой может быть отдано другим проектам.
Компоненты многоразового применения как правило включают гораздо меньше ошибок, нежели вновь разработанные, так как они уже не раз подвергались проверке.
Когда некая компонента применяется сразу несколькими клиентами, то усовершенствования, вносимые в её код, одновременно оказывают свое положительное воздействие и на множество работающих с ней программ.
В случае если программа опирается на стандартные компоненты, то её структура и пользовательский интерфейс становятся наиболее унифицированными, что упрощает её понимание и упрощает её применение.Критика ООП
Объектно-ориентированное программирование требует знания 4 вещей:
Следует понимать базовые концепции, такие как классы, наследование и динамическое связывание. Для программистов, уже знакомых с определением модуля и с абстрактными типами данных, это потребует минимальных стараний. Для тех же, кто ни разу не использовал инкапсуляцию данных, это может означать изменения мировоззрения и может отнять на изучение существенное количество времени.
Многоразовое применение потребует от программиста ознакомиться с большими библиотеками классов. А это может оказаться труднее, нежели даже исследование нового языка программирования. Библиотека классов по сути представляет собой виртуальный язык, который способен включать в себя сотни типов и тыс. операций. В языке Smalltalk, к примеру, до того, как перейти к практическому программированию, необходимо изучить значительную часть его библиотеки классов. А это также потребует времени.
Проектирование классов – задача куда более сложная, нежели их применение. Проектирование класса, как и проектирование языка, потребует большого опыта. Это итеративный процесс, где требуется учиться на собственных же ошибках.
Очень сложно изучать классы, не имея возможности их «пощупать». Только лишь с приобретением маломальского опыта можно уверенно себя почувствовать при работе с применением ООП.Как мы видели, старания на освоение базовых концепций не слишком велики, однако вот в случае библиотек классов и их применения они могут быть весьма существенными.
Время, которое было сэкономлено на том, что получилось обойтись без написания своего класса, должно быть частично потрачено на то, чтобы разобраться в существующем классе.
В сложных иерархиях классов поля и методы как правило наследуются с разных уровней. И не всегда легко определить, какие поля и методы фактически относятся к данному классу.
Абстракцией данных не следует злоупотреблять. Чем больше данных спрятано в недрах класса, тем труднее его расширять.
Актуальность ООП
Что делает ООП актуальным? Во-первых, это работает. Так или иначе, программисты научились понимать друг друга, создавать сложные системы и создавать абстракции при помощи паттернов. Большое число программистов начало думать в терминах ООП, большое число кода написано и протестировано. Это то, что делает ООП актуальным ещё долгое время, особенно с целью решения классических задач. Однако для задач нетривиальных, постоянно необходимо пробовать и применять новые подходы. «Серебряной пули» не существует. Более того, понимание подходов функционального программирования, макроязыков, алгоритмов, устройства компиляторов-интерпретаторов дают программисту неоспоримые преимущества для написание качественного и гибкого кода.
Заключение
В конце концов, после изучения этой парадигмы, всей ее структуры, объектно-ориентированных языков, всех ее положительных и отрицательных сторон, после изучения того, как и что создается с помощью ООП, становится понятно, что объектно-ориентированное программирование актуально сейчас и будет актуально еще долгое время, ведь так или иначе, программисты научились понимать друг друга, создавать сложные системы и создавать абстракции при помощи паттернов. Большое число программистов начало думать в терминах ООП, большое число кода написано и протестировано. И главное, что всё это работает. Да, у этой парадигмы есть свои минусы и недостатки, но они либо не значительны и из-за плюсов объектно-ориентированного языка потихоньку уходят на второй план, либо их уже исправили, либо будут исправлять в будущем. Эта парадигма справляется со своими задачами, она благодаря своим плюсам, максимально упрощает работу.
Можно сделать вывод, что ООП, это актуальная, уже достаточно исследованная (но не до конца) парадигма, которой еще достаточно долго будут пользоваться. По крайней мере, ее составляющими «классами» и «объектами», точно долго будут пользоваться. ООП было создано для того, чтобы упростить жизнь программистам, которые работают с ним, и оно точно справляется с этой задачей. Эта парадигма развивается и будет развиваться, будут появляться новые объектно-ориентированные языки, новые среды разработки, а старые будут совершенствоваться. И я надеюсь, что вскоре она достигнет такого уровня, что максимально облегчит работу всем программистам, работающим с объектно-ориентированным программированием.

Список литературы:
Сергей Бобровский, История развития программного обеспечения, URL://http://www.computer-museum.ru;
Объектно-ориентированное программирование для чайников, URL://http://progstudy.ru;
Объектно-ориентированное программирование, URL://https://ru.wikipedia.org;
Прощай объектно-ориентированное программирование, URL://https://habrahabr.ru;
Николай Вязовик, Евгений Жилин. Философия ООП В.А. Мирошниченко, М.А. Бодарева, Основы объектно-ориентированного программирования, URL://http://www.studfiles.ru;
Ханспетер Мессенбок, Плюсы и минусы объектно-ориентированного программирования, URL://http://www.uni-vologda.ac.ru;
Г.И. Радченко, Е.А. Захаров, Объектно-ориентированное программирование.

Приложенные файлы


Добавить комментарий