В чем преимущества ооп перед процедурным программированием

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

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

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

Ключевые особенности процедурного программирования

Ключевые особенности процедурного программирования приведены ниже:

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

Преимущества и недостатки процедурного программирования

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

Недостатки

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

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

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

Недостатки

Процедурное программирование против объектно-ориентированного программирования: сравнение между собой

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

Недостатки

Вывод

Как мы уже говорили в этой статье, процедурное программирование — это больше, чем вы делаете, а не то, как вы это делаете. Это стандартный подход, используемый во многих компьютерных языках, таких как C, Pascal и BASIC. Хотя идеальной парадигмы программирования не существует, важно понимать, что правильная парадигма всегда будет зависеть от типа используемого вами языка и программы, которую вы хотите создать. Рекомендуется, чтобы для достижения максимальных результатов и сильного портфеля, нужно было владеть всеми тремя основными парадигмами программирования. Лучший способ попытаться стать лучше в программировании — это, конечно пройти курсы программирования.

Источник

PHP — ООП или процедурный подход

PHP один из самых популярных скриптовых языков программирования. Почти 60% веб серверов используют PHP.Миллионы веб-сайтов и веб-приложений разрабатываются на PHP каждый месяц.

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

Изучение PHP абсолютно не тяжёлое занятие, особенно если вы хорошо знакомы с синтаксисом Java или C.

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

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

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

PHP позволяет нам писать приложения 2мя разными способами, первый — процедурный, а второй объектно ориентированный. Если вы до сих пор не поняли разницу между этими двумя подходами, давайте посмотрим на эти куски кода — один и тот же пример написанный разными подходами.

Процедурный:

А вот тот же кусок кода с использованием ООП:

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

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

Исходя из изложенного выше, можно вынести преимущества использования ООП:

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

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

* Повторное использование: Объект это логический объект у которого есть комплект свойств и методов и он может взаимодействовать с другими объектами.. Объект может быть абсолютно независимым или может зависеть от других объектов. Объект обычно создают для решения специфических поставленных проблем. Следовательно когда другие разработчики сталкиваются с похожими проблемами, они могут подключить ваш класс к своему проекту и использовать его не боясь что он нарушит процесс их разработки. Это позволяет избежать DRY, что расшифровывается как Don’t Repeat Yourself ( не повторяйся). В процедурном или модульном программировании, повторное использование возможно только в совокупности.

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

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

* Поддержка: объектно-ориентированный код легче поддерживать так как
он следует весьма жёстким соглашениям написания кода и пишется в самопоясняющейся форме.
К примеру, когда разработчик дополняет, перерабатывает код, или отлаживает его, он может легко найти внутреннюю структуру кода и поддерживать код время от времени. Более того, когда в вашем окружении работает команда разработчиков ООП может быть лучшим решением так как вы можете распределять ваш код между членами команды, после разбития его на маленькие части. Эти маленькие части могут быть разработаны как отдельные объекты, следовательно разработчики могут работать практически независимо друг от друга. В конечном итоге объеденить все части в одно приложение не составит большого труда.

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

Авторский перевод из книги Object Oriented Programming with PHP5

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

Источник

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

Статья не мальчика, но мужа.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Что дальше

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

Источник

В чем преимущество объектно-ориентированного программирования перед процедурным программированием?

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

Мне сказали, что C ++ имеет объектно-ориентированные концепции, а также публичные и частные режимы для определения переменных: вещей, которых нет в C. Мне никогда не приходилось использовать их при разработке программ на Visual Basic.NET: каковы их преимущества?

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

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

Почему это не идеально?

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

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

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

Я думаю, что основной вопрос, на который вы действительно должны ответить, это: «Зачем мне когда-либо хотеть скрывать данные? Если я это сделаю, я не смогу с этим работать!» И вот почему:

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

То, что я описал выше, является примером идеально связанного кода. И с незапамятных времен (при условии, что время началось 1 января 1970 года), человеческий род искал способы избежать этих проблем. Чтобы избежать их, нужно разделить код на системы, подсистемы и компоненты и ограничить количество функций, имеющих доступ к любому фрагменту данных. Если бы у меня было 5 целых чисел и строка, представляющая какое-то состояние, мне было бы легче работать с этим состоянием, если бы только 5 функций устанавливали / получали значения? или если 100 функций устанавливают / получают те же значения? Даже без ОО-языков (например, C) люди усердно работали над изоляцией данных от других данных и созданием четких границ разделения между различными частями кода. Когда проект достигает определенного размера, простота программирования становится невозможной, «могу ли я получить доступ к переменной X из функции Y»,

Вот почему концепции ОО были введены, и именно поэтому они такие мощные. Они позволяют вам скрывать свои данные от себя, и вы хотите делать это специально, потому что чем меньше кода, который видит эти данные, тем меньше вероятность того, что при добавлении следующей функции вы что-то сломаете. Это основная цель концепций инкапсуляции и ОО-программирования. Они позволяют вам разбивать наши системы / подсистемы на еще более детализированные блоки до такой степени, что, независимо от того, насколько велик весь проект, к данному набору переменных можно получить доступ только через 50-200 строк кода, и все! Очевидно, что ОО-программирование гораздо больше, но, по сути, именно поэтому C ++ дает вам возможность объявлять данные / функции как частные, защищенные или общедоступные.

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

Источник