Можете ли да обясните разликата между процедурното програмиране и OOP?


Отговор 1:

Оригинален въпрос:

Можете ли да обясните разликата между процедурното програмиране и OOP?

Отговор:

Първо първо, нека да определим какво означава процедурно и обектно ориентирано програмиране.

Определение - Какво означава език на процедурите? Процедурният език е вид компютърен език за програмиране, който посочва поредица от добре структурирани стъпки и процедури в рамките на своя програмен контекст за съставяне на програма. Той съдържа систематичен ред на изрази, функции и команди за завършване на изчислителна задача или програма. Процедурният език е известен също като императивен език.Техопедия обяснява Процедурен езикПроцедурен език, както подсказва името, разчита на предварително определени и добре организирани процедури, функции или подпрограми в архитектурата на програмата, като посочите всички стъпки, които компютърът трябва да предприеме, за да достигне желано състояние или изход. Процедурният език отделя програма в рамките на променливи, функции, оператори и условни оператори. Процедурите или функциите се прилагат върху данните и променливите за изпълнение на задача. Тези процедури могат да бъдат извиквани / извиквани навсякъде между йерархията на програмата и други процедури. Програма, написана на процедурен език, съдържа една или повече процедури. Процедурният език е един от най-често използваните видове програмни езици, които се използват, с известни езици като C / C ++, Java, ColdFusion и PASCAL.

Сега, нека да определим обектно ориентирано програмиране.

Определение - Какво означава обектно-ориентирано програмиране (OOP) Обектно-ориентираното програмиране (OOP) е модел на софтуерно програмиране, изграден около обекти. Този модел разделя данните в обекти (полета с данни) и описва съдържанието и поведението на обекта чрез деклариране на класове (методи). Функциите наOOP включват следното: Капсулиране: Това прави структурата на програмата по-лесна за управление, тъй като изпълнението и състоянието на всеки обект са скрити зад добре дефинирани граници.Полиморфизъм: Това означава, че абстрактните единици се реализират по много начини. Наследство: Това се отнася до йерархичното подреждане на фрагменти за изпълнение. Обектно-ориентираното програмиране позволява опростено програмиране. Предимствата му включват повторна употреба, рефакторинг, разширяемост, поддръжка и ефективност.Техопедия обяснява обектно-ориентираното програмиране (OOP) OOP е модел на програмиране на избор през последното десетилетие или повече. Модулният дизайн на OOP позволява на програмистите да изграждат софтуер в управляеми парчета, а не в големи количества последователен код. Едно от големите предимства на OOP е мащабируемостта, като обектите и определенията нямат ограничено ограничение. Освен това отделянето на данни от метода предотвратява често срещан проблем, открит в по-старите линейни софтуерни езици. Ако грешка се появи в линеен код, тя може да бъде преведена през система и да създаде масиви трудно проследими грешки. И обратно, OOP програма, с разделянето на метода и данните, не е податлива на такива разпространени грешки. Популярните OOP езици включват Java, семейството на езици C, VB.NET Shop и Python.Това наречени "чисти" OOP езици включват Scala, Ruby, Eiffel, JADE, Smalltalk и Emerald.

Източникът на дефинициите идва от Какво е обектно-ориентирано програмиране (OOP)? - Определение от Техопедия и Какво е процедурен език? - Определение от Техопедия

Сега. Нека да разгледаме разумно прилагането на разликата.

Ще започнем с процедурни и най-лесният начин да направите това ще бъде използването на езика C специално с Arduino, тъй като това знам.

Реших да използвам ръководството за мигаща светлина като основа, тъй като това е една от основните реализации.

// функцията за настройка се стартира веднъж, когато натиснете нулиране или захранване на настройката за анулация на платката () {// инициализирате цифров щифт LED_BUILTIN като изход. pinMode (LED_BUILTIN, OUTPUT); } // функцията loop работи отново и отново завинаги void loop () {digitalWrite (LED_BUILTIN, HIGH); // включете светодиода (HIGH е нивото на напрежението) забавяне (1000); // изчакайте втори digitalWrite (LED_BUILTIN, LOW); // изключете светодиода, като направите напрежението НИСКО закъснение (1000); // изчакайте секунда}

Сега, нека да обясня кода малко по-добре. Имате две функции Настройка и цикъл. Цикълът се извиква многократно и настройката се извиква само веднъж. Изпращате командата digitalWrite към светодиода, за да поставите съответно високата и ниската мощност. Забавяне е колко дълго светлината ще се запали или изключи, в този случай 1000 мс или приблизително 1 секунда. Доста направо, но това показва, че вие ​​сте на основите на процедурното програмиране. Вие пишете процедура или инструкция и това се повтаря, докато приключи. Няма допълнителна сложност на необходимия код.

Примерно време за C # и OOP

използване на System; използване на System.Collections.Generic; използване на System.Linq; използване на System.Text; пространство от имена oops {клиент в публичен клас {// Член-променливи public int CustID; име на публичен низ; Адрес на публичен низ; // конструктор за инициализиране на полета клиент () {CustID = 1101; Наименование = "Том"; Адрес = "САЩ"; } // метод за показване на клиентски записи (функционалност) public void displayData () {Console.WriteLine ("Клиент =" + CustID); Console.WriteLine ( "име =" + наименование); Console.WriteLine ( "Адрес =" + Адрес); } // Код за входна точка}} Класова програма {static void Main (string [] args) {// object instantiation customer obj = new customer (); // Метод за извикване obj.displayData (); // полета, извикващи Console.WriteLine (obj.CustID); Console.WriteLine (obj.Name); Console.WriteLine (obj.Address); }}}

Ето класически пример за OOP. Имате клиентски клас, който определя всички обекти, които имате на разположение за вас. Все още имате функции / методи за писане. Но основната разлика е, че искате да разделите всеки метод / функция нагоре според това, което трябва да прави. Оттам вашият основен метод е входната точка на програмата и по този начин трябва да имате своя критичен код тук.


Отговор 2:

OOPS концепция в Java

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


Отговор 3:

Процедурното програмиране е програмиране с процедури като основен механизъм за абстракция. Хм.

Какво е процедура? Това е име с букет код, който може да бъде извикан по име и който получава стойности и референции от контекста, в който е извикан, параметрите и може да върне стойности и препратки към този контекст, след като извърши някаква работа.

Често една конкретна стойност ще бъде посочена вътре в процедурата като възвръщаема стойност. В езиците, които поддържат процедури, е обичайно да се виждат, че те се използват, като че ли са функции, където параметрите се третират като аргументи, а връщащата се стойност се изчислява в рамките на процедурата като стойността на функцията за тези аргументи. Но също така е идиоматично процедурата да връща една или повече стойности в своя извикващ контекст чрез параметри, или „външни“ параметри, ако езикът поддържа това, или чрез промяна на стойността, предавана чрез референция, и да се използва самата връщаща стойност флаг, статус или индикатор за грешка В култури за програмиране, силно повлияни от Unix, често ще видите 0 върнати, което показва успех (или поне, липсата на известни грешки) и отрицателно число, което да посочи известен режим на отказ.

Това не е строго необходимо за модела, но не мога да се сетя за език, който използва процедурите като свой основен механизъм за абстракция, който също няма контрол на потока, използвайки почти един и същ набор от добре познати полумагически неща като:

if (условие) {doThisThing ()} else {doThatThing ()}

и

докато (условие) {KeepOnDoingThisThing ()}

Считам, че в съзнанието на повечето програмисти, "процедурното" програмиране е доста свързано със "структурираното програмиране". Още в деня, когато структурираното програмиране беше ново, беше установено, че има удобен набор от потоци от контролни конструкции, от които могат да бъдат изградени всички необходими модели на потока на контрол в рамките на една процедура:

избор на алтернативи

  • ако в противен случай (два варианта, базирани на булева) случай или превключвател (много възможности, базирани на всеки набор)

повторение

с известни граници:

  • за контури (обикновено определен брой повторения) предскажете цикли (повторете толкова пъти колкото размера на някаква колекция, може би над самите членове)

с специални граници:

  • докато (0 или повече повторения), докато (1 или повече повторения)

и тъжно непопулярните:

  • изход-когато цикъл

който изпълнява кода преди изхода поне веднъж и кода след изход нула или повече пъти.

Тези структури могат да се приложат една от друга, но това е изненадващо трудно в някои случаи. Изявленията за превключване / случай са много сложни да се емулират точно с вложени ifs. И важното за нашите цели е, че те почти винаги са вградени в езиковата реализация и те могат да правят неща, които вие, работещият програмист, ще се мъчите да напишете код. На всеки чисто или преди всичко процедурен език, който мога да измисля, би било много трудно и в много случаи невъзможно да напишете собствените си контролни структури, които работеха по същия начин като вградените. Така че, вие използвате тези, които са вградени. Процедурното, структурирано, програмирането е много ограничен свят.

Процедурните езици за програмиране също имат тенденция да имат някаква концепция за модул, наречен контейнер за куп процедури. Някои от тези процедури ще бъдат видими и използваеми извън модула, някои ще бъдат видими и използваеми само в модула, тоест чрез други процедури също в рамките на същия модул. В повечето езици с модули модулът може също да има променливи в него, които са видими и споделени между процедурите, дефинирани в модула. Дори C може да направи това. Такава модулна система дава възможност за степен на капсулиране и скриване на информация: онези процедури и променливи вътре в модула, осигурявайки изпълнението на процедурите, видими извън модула, могат да помогнат за контрол на свързването в цялата структура на системата. Което е хубаво.

Ако отидете една стъпка по-нататък и разрешите многократно използване на един и същ модул, като всяко използване има собствено копие на променливите, дефинирани в модула, тогава модулът започва да изглежда като примитивен вид обект. И ако след това направите екземплярите на модулите с променливите първостепенно нещо и споделяте процедурите между тях по някакъв начин, така че имате само едно копие от тях, тогава сте доста близо до това, което прави C ++. Това фино зърнесто модулно, процедурно, структурирано програмиране не е обектно-ориентирано програмиране.

Обектно ориентирано програмиране е програмиране с обекти като основен механизъм за абстракция. Хм.

Какво е обект? Това е дълговечно изчислително образувание, от което може да се поиска да направи нещо. Архетип и пример за обектно-ориентирано програмиране е Smalltalk. В Smalltalk всяка стойност е обект (или поне, много малкото стойности, които не са обекти, са направени така, че да изглеждат като че ли са). Изчисляването протича от обекти, изпращащи съобщения един до друг. Изпълненията на Smalltalk се различават до известна степен, но това е общата идея:

Обекти, заложени в паметта. Когато даден обект иска друг обект да направи нещо, той изгражда съобщение с искане за това и го изпраща до предвидения обект. Съобщенията са обекти. Обектите са отговорни за поддържане на състояние, тоест притежават променливи. Те не изпълняват код. Когато обектът получи съобщение, той го предава на своя клас. Класовете са обекти. Класовете са отговорни за създаването и управлението на обекти, те не изпълняват код. Класът предава съобщението на своя метаклас. Метакласовете са обекти. Метакласите са отговорни за управлението на методите. Метакласът разглежда своите методи и намира този, който съответства на съобщението. Методите са обекти. По пътя обектът на съобщението беше украсен с различни допълнителни части информация, включително препратка към обекта, получил съобщението. Методът е отговорен за стартирането на код и използва всички аргументи, предадени в оригиналното съобщение, за да го направи. Методът изпълнява своя код в контекста на обекта, получил съобщението. Кодът на метода е просто скрипт от съобщения за изграждане и изпращане на други обекти. Ако метакласът не може да намери метод, който да съвпадне със съобщението, тогава търсенето започва метакласите на родителските класове на класа на обекта. Това се нарича „наследяване“.

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

Програмирането в Smalltalk означава комбинация от скриптови съобщения, изпращани за използване на методи, и създаване на нови класове (с метакласове) за методите, в които да се живее. И това е валидно за еквивалента на потока на контрол, тъй като е на всичко друго.

На процедурен език може да предприемете някакво действие върху всеки член на колекция с код малко като този псевдо-код:

foreach (theThing in aCollection) doThisActionOn (theThing)

В типичен Smalltalk еквивалентният скрипт на изпращане на съобщения може да изглежда така:

aCollection направи: [aThing | aThing takeThisAction].

Тук takeThisAction е съобщение, изпращано до всеки aThing обект в колекция aCollection. (Между другото, кодът вътре в квадратни скоби е блок, който Smalltalk нарича ламбда. Това е обект.) Ако сравним двете, можем да видим някои критични характеристики на обектно-ориентираното програмиране за разлика от процедурните:

  • В процедурния кодекс ние избираме как да пресечем членовете на колекцията, избираме механизма на foreach. В обектно-ориентирания код ние молим колекцията да извърши преминаване, не знаем как го прави. В процедурния код повикващият код трябва да има достъп до процедурата, наречена doThisActionOn, в обектно-ориентирания код takeThisAction е просто символ. Не знаем как предметите вътре в колекцията ще я интерпретират.

Това е същността на обектно-ориентираното програмиране и е описано като „програмиране чрез преминаване на долара“. В процедурното програмиране, от друга страна, трябва да заявим изрично какво прави всеки изчисление.