Podeu explicar la diferència entre la programació processal i la OOP?


Resposta 1:

Pregunta original:

Podeu explicar la diferència entre la programació procedimental i l’OOP?

Resposta:

Primera cosa, definim què significa la programació procedimental i orientada a objectes.

Definició: què significa el llenguatge procedimental? Un llenguatge procedimental és un tipus de llenguatge de programació per ordinador que especifica una sèrie de passos i procediments ben estructurats dins del seu context de programació per compondre un programa. Conté un ordre sistemàtic d’enunciats, funcions i ordres per completar una tasca o programa computacional. El llenguatge de processos també es coneix com a llenguatge imperatiu.Techopedia explica Llenguatge procedimental Un llenguatge procedimental, com el seu nom indica, es basa en procediments, funcions predefinides i ben organitzades. o sub-rutines en l'arquitectura d'un programa especificant tots els passos que l'ordinador ha de fer per assolir un estat o una sortida desitjats. El llenguatge procedimental segrega un programa dins de variables, funcions, sentències i operadors condicionals. S’implementen procediments o funcions a les dades i variables per realitzar una tasca. Aquests procediments es poden cridar / invocar en qualsevol lloc entre la jerarquia del programa i també per altres procediments. Un programa escrit en llenguatge de procediment conté un o més procediments. El llenguatge de processament és un dels tipus més habituals de llenguatges de programació en ús, amb llenguatges notables com C / C ++, Java, ColdFusion i PASCAL.

Ara, definim la programació orientada a objectes.

Definició: què significa la programació orientada a objectes (OOP)? La programació orientada a objectes (OOP) és un model de programació de programari construït al voltant d'objectes. Aquest model compartimenta les dades en objectes (camps de dades) i descriu el contingut i el comportament dels objectes mitjançant la declaració de classes (mètodes). Les funcions d'OOP inclouen el següent: Encapsulació: això fa que l'estructura del programa sigui més fàcil de gestionar perquè la implementació i l'estat de cada objecte queden ocults darrere. límits ben definits.Polimorfisme: Això vol dir que les entitats abstractes s’implementen de diverses maneres. Herència: es refereix a l’ordenació jeràrquica de fragments d’implementació. La programació orientada a objectes permet una programació simplificada. Els seus beneficis inclouen reutilització, refactorització, extensibilitat, manteniment i eficiència. Techopedia explica la programació orientada a objectes (OOP) OOP ha estat el model de programació escollit durant la darrera dècada o més. El disseny modular de l’OOP permet als programadors construir programari en trossos manejables en lloc de grans quantitats de codi seqüencial. Un dels grans beneficis de l’OOP és el de l’escalabilitat, amb objectes i definicions sense limitació finita. A més, la separació de dades del mètode evita un problema comú que es troba en llenguatges de programari lineals més antics. Si apareix un error en un codi lineal, es pot traduir a través d’un sistema i crear masses d’errors difícils de rastrejar. Per contra, un programa OOP, amb la seva separació de mètode i dades, no és susceptible d'errors tan proliferats. Els llenguatges OOP populars inclouen Java, la família C dels idiomes, VB.NET Shop i Python.So anomenats llenguatges OOP "purs". inclouen Scala, Ruby, Eiffel, JADE, Smalltalk i Emerald.

L’origen de les definicions prové de Què és la programació orientada a objectes (OOP)? - Definició de Techopedia i què és un llenguatge de procediment? - Definició de Techopedia

Ara. Analitzem bé la implementació de diferències.

Començarem per procedimental, i la manera més senzilla de fer-ho serà utilitzar el llenguatge C específicament amb Arduino, ja que és el que conec.

Vaig decidir utilitzar el tutorial de llum parpellejant com a base ja que és una de les implementacions bàsiques.

// la funció de configuració s’executa un cop en prémer reset o engegar la configuració del void de la placa () {// inicialitzar el pin digital LED_BUILTIN com a sortida. pinMode (LED_BUILTIN, OUTPUT); } // la funció de bucle es recorre una vegada i una altra per a un bucle void () {digitalWrite (LED_BUILTIN, HIGH); // encendre el LED (HIGH és el nivell de voltatge) retard (1000); // espereu un segon digitalWrite (LED_BUILTIN, LOW); // apagueu el LED fent que la tensió es retardi LOW (1000); // esperar un segon}

Ara, deixeu-me explicar el codi una mica millor. Teniu dues funcions Configuració i Loop. El bucle s’anomena repetidament i la configuració només s’anomena una vegada. Envia el comandament digitalWrite al LED per posar el nivell de potència a alt i baix, respectivament. El retard és quant de temps continuarà encesa o apagada, en aquest cas, 1000ms o aproximadament 1 segon. Molt endavant, però això demostra que és fonamental la programació procedimental. Escriviu un procediment o instrucció i es repeteix fins que finalitzi. No hi ha cap complexitat addicional al codi requerit.

Exemple C # i temps OOP.

utilitzant Sistema; utilitzant System.Collections.Generic; utilitzant System.Linq; mitjançant System.Text; namespace oops {public class client {// Variables membres public int CustID; cadena pública Nom; cadena pública Adreça; // constuctor per inicialitzar camps client () {Custid = 1101; Nom = "Tom"; Adreça = "EUA"; } // mètode per mostrar registres de clients (funcionalitat) public void displayData () {Console.WriteLine ("Client =" + Custid); Console.WriteLine ("Nom =" + Nom); Console.WriteLine ("Adreça =" + Adreça); } // Codi del punt d’entrada}} Programa de classe {static void Main (string [] args) {// object instantiation client obj = new client (); // Mètode per trucar a obj.displayData (); // camps que criden Console.WriteLine (obj.CustID); Console.WriteLine (nom d'objecte); Console.WriteLine (obj.Address); }}}

Aquí teniu un exemple clàssic d’OOP. Teniu una classe de client que defineix tots els objectes que teniu disponibles. Encara teniu funcions / mètodes per escriure. Però la diferència clau és que voleu dividir tots els mètodes / funcions segons el que se suposa. A partir d’aquí, el vostre mètode principal és el punt d’entrada del programa i per tant hauríeu de tenir aquí el vostre codi crític.


Resposta 2:

Concepte OOPS a Java

El llenguatge procedimental es basa en funcions, però el llenguatge orientat a objectes es basa en objectes del món real. El llenguatge processal dóna importància a la seqüència d’execució de funcions, però el llenguatge orientat a objectes dóna importància als estats i comportaments dels objectes. El llenguatge processal exposa les dades a tot el programa. però el llenguatge orientat a objectes encapsula les dades. El llenguatge de programació segueix el paradigma de programació de cap avall, però el llenguatge orientat a objectes segueix el paradigma de programació de fons cap a dalt. de manera que és més fàcil de modificar, ampliar i mantenir. El llenguatge processal proporciona menys àmbit de reutilització de codi, però el llenguatge orientat a objectes proporciona més àmbit de reutilització de codi.


Resposta 3:

La programació procedimental és la programació amb procediments com a mecanisme d'abstracció principal. Huh.

Què és un procediment? És un gran codi de codi que pot ser invocat pel seu nom i que rep valors i referències del context on s'invoca, dels paràmetres i pot retornar valors i referències a aquest context després de fer una mica de treball.

Sovint, un valor particular s’indicarà dins del procediment com a valor de devolució. En idiomes que admeten procediments, és habitual veure-los utilitzats com si fossin funcions, on els paràmetres es tracten com a arguments i el valor de retorn es calcula dins del procediment com a valor de la funció per a aquests arguments. Però també és idiomàtic que el procediment retorni un o més valors al seu context de trucada mitjançant paràmetres, ja sigui paràmetres "fora" si el llenguatge admet això, o canviant un valor passat per referència, i utilitzi el valor de retorn propi per a indicador, estat o indicador d’error. A les cultures de programació molt influïdes per Unix, sovint veureu 0 retornat per indicar l’èxit (o almenys, l’absència de falles conegudes) i un nombre negatiu per indicar algun mode de fallida conegut.

No és estrictament necessari el model, però no puc pensar en un llenguatge que utilitzi procediments com a principi de mecanisme d'abstracció que no tingui un control de flux que utilitzi gairebé el mateix conjunt de semi-màgics coneguts coses com:

if (condició) {doThisThing ()} else {doThatThing ()}

i

while (condició) {keepOnDoingThisThing ()}

Crec que, en la majoria de les ments del programador, la programació "procedimental" està força relacionada amb la "programació estructurada". En el moment en què la programació estructurada era nova, es va trobar que hi ha un conjunt convenient de construccions de control de flux a partir dels quals es podrien construir tots els patrons necessaris de flux de control dins d'un procediment:

escollir alternatives

  • en cas contrari (dues opcions, basades en un booleà) cas o commutador (moltes opcions, basades en qualsevol conjunt)

repetició

amb límits coneguts:

  • per a bucles (normalment un nombre determinat de iteracions) bucles de predicació (iteració tantes vegades com la mida d'alguna col·lecció, potser sobre els mateixos membres)

amb límits ad-hoc:

  • while do (0 o més iteracions) ho fa mentre (1 o més iteracions)

i el tristament impopular:

  • bucle sortida-quan

que executa el codi abans de la sortida com a mínim una vegada i el codi després de la sortida zero o més vegades.

Aquestes estructures es poden implementar segons les altres, però en alguns casos és sorprenentment difícil. Les instruccions de commutació / cas són molt difícils d’emular exactament amb ifs imbricats. I l’important per als nostres propòsits és que gairebé sempre s’inclouen en la implementació del llenguatge, i poden fer coses que tu, el programador que treballarà, lluitarà per escriure codi per fer-ho. En tots els llenguatges purament o principalment procedimentals que puc pensar, seria molt dur i, en molts casos, resultés impossible escriure les vostres estructures de control que funcionessin de la mateixa manera que les integrades. Per tant, utilitzeu els integrats. La programació, estructurada, de programació és un món molt restringit.

Els llenguatges de programació procedimentals també solen tenir algun tipus de concepte de mòdul, un contenidor anomenat per a un munt de procediments. Alguns d'aquests procediments seran visibles i poden ser utilitzats fora del mòdul, alguns només seran visibles i utilitzables dins del mòdul, és a dir, d'altres procediments també dins del mateix mòdul. En la majoria dels idiomes amb mòduls, un mòdul també pot tenir variables que siguin visibles i compartides entre els procediments definits dins del mòdul. Fins i tot C pot fer-ho. Aquest sistema de mòdul permet obtenir un grau d’encapsulació i amagada d’informació: aquells procediments i variables dins del mòdul, proporcionant la implementació dels procediments visibles fora del mòdul poden ajudar a controlar l’acoblament a través de l’estructura d’un sistema. La qual cosa és agradable.

Si aneu un pas més enllà i permeteu diversos usos del mateix mòdul, cada ús té una còpia pròpia de les variables definides al mòdul, aleshores el mòdul comença a semblar un objecte primitiu. I, a continuació, feu que les instàncies dels mòduls siguin les variables primàries i compartiu els tràmits d’alguna manera, de manera que només en teniu una còpia, aleshores esteu bastant a prop del que fa C ++. Aquesta programació estructurada, modular, procedimental i estructurada, no és una programació orientada a objectes.

La programació orientada a objectes és la programació amb objectes com a mecanisme d'abstracció principal. Huh.

Què és un objecte? És una entitat computacional de llarga vida a la qual se li pot demanar que faci alguna cosa. Un arquetip i exemple de programació orientada a objectes és Smalltalk. A Smalltalk, cada valor és un objecte (o almenys, els pocs valors que no són objectes es fan semblar que ho siguin). El càlcul es realitza mitjançant objectes que s'envien missatges. Les implementacions de Smalltalk varien una mica, però aquesta és la idea general:

Objectes ambientats a la memòria. Quan un objecte vol que un altre objecte faci alguna cosa, construeix un missatge que ho demana i l'envia a l'objecte previst. Els missatges són objectes. Els objectes són els responsables de mantenir l'estat, és a dir, contenen variables. No utilitzen codi. Quan un objecte rep un missatge el transmet a la seva classe. Les classes són objectes. Les classes són responsables de crear i gestionar objectes, no fan servir codi. La classe passa el missatge a la seva metaclass. Les matacasses són objectes. Les matacasses són responsables de gestionar els mètodes. El metaclass contempla els seus mètodes i en troba el corresponent al missatge. Els mètodes són objectes. Al llarg del camí, l'objecte del missatge es va decorar amb diverses dades addicionals, inclosa una referència a l'objecte que va rebre el missatge. El mètode s’encarrega d’executar codi i s’utilitza qualsevol argument que es passi al missatge original per fer-ho. El mètode executa el seu codi en el context de l'objecte que ha rebut el missatge. El codi del mètode és només un script de missatges per crear i enviar a altres objectes. Si el metaclass no pot trobar un mètode que coincideixi amb el missatge, s'inicia una cerca a les metaclasses de les classes pares de la classe de l'objecte. Això s’anomena “herència”.

Pot ser que una implementació o una altra tingui determinats mètodes integrats en la implementació per raons d'eficiència, però en principi tot un sistema Smalltalk pot funcionar així.

La programació, a Smalltalk, significa una combinació d’enviaments de missatges d’escriptura per anar en mètodes i crear noves classes (amb metaclasses) per a mètodes per viure. I això és tan cert com l’equivalent al flux de control ja que és de qualsevol cosa. més.

En un llenguatge de procediment, podeu actuar sobre cada membre d'una col·lecció amb un codi tal com aquest pseudo-codi:

foreach (theThing in aCollection) doThisActionOn (theThing)

En un Smalltalk típic, l'escriptura de missatges enviats pot semblar així:

aColecció fer: [aThing | aThing takeThisAction].

Aquí, takeThisAction és un missatge que s'envia a cada objecte aThing de la col·lecció aCollection. (Per cert, el codi dins dels claudàtors és un bloc, que és el que Smalltalk anomena lambda. És un objecte.) Si comparem els dos, podem veure algunes característiques crítiques de la programació orientada a objectes en contraposició a la procedimental:

  • En el codi procedimental, escollim la manera de travessar els membres de la col·lecció, escollim el mecanisme de predicació. En el codi orientat a l'objecte, demanem a la col·lecció que faci un recorregut, no sabem com ho fa. Al codi procedimental, el codi de trucada ha de tenir accés al procediment anomenat doThisActionOn, al codi orientat a l'objecte takeThisAction és només un símbol. No sabem com l’interpretaran els objectes de la col·lecció.

Aquesta és l'essència de la programació orientada a objectes, i s'ha descrit com a "programació passant el valor". D’altra banda, en la programació procedimental, hem d’explicir explícitament què fa tot càlcul.