Pouvez-vous expliquer la différence entre la programmation procédurale et la POO?


Réponse 1:

Question d'origine:

Pouvez-vous expliquer la différence entre la programmation procédurale et la POO?

Répondre:

Tout d'abord, définissons ce que signifie la programmation procédurale et orientée objet.

Définition - Définition du langage procédural Un langage procédural est un type de langage de programmation informatique qui spécifie une série d'étapes et de procédures bien structurées dans son contexte de programmation pour composer un programme. Il contient un ordre systématique d'instructions, de fonctions et de commandes pour exécuter une tâche ou un programme de calcul. ou des sous-routines dans l'architecture d'un programme en spécifiant toutes les étapes que l'ordinateur doit suivre pour atteindre l'état ou la sortie souhaité. Le langage procédural sépare un programme en variables, fonctions, instructions et opérateurs conditionnels. Des procédures ou fonctions sont implémentées sur les données et les variables pour effectuer une tâche. Ces procédures peuvent être appelées / invoquées n'importe où entre la hiérarchie du programme et par d'autres procédures également. Un programme écrit en langage procédural contient une ou plusieurs procédures. Le langage procédural est l'un des types les plus courants de langages de programmation utilisés, avec des langages notables tels que C / C ++, Java, ColdFusion et PASCAL.

Maintenant, définissons la programmation orientée objet.

Définition - Que signifie la programmation orientée objet (POO) La programmation orientée objet (POO) est un modèle de programmation logicielle construit autour des objets. Ce modèle compartimente les données en objets (champs de données) et décrit le contenu et le comportement des objets par le biais de la déclaration de classes (méthodes). frontières bien définies.Polymorphisme: Cela signifie que les entités abstraites sont implémentées de plusieurs façons.Héritage: Cela fait référence à l'agencement hiérarchique des fragments d'implémentation.La programmation orientée objet permet une programmation simplifiée. Ses avantages incluent la réutilisabilité, la refactorisation, l'extensibilité, la maintenance et l'efficacité. Techechedia explique la programmation orientée objet (POO) La POO a été le modèle de programmation de choix pour la dernière décennie ou plus. La conception modulaire d'OOP permet aux programmeurs de créer des logiciels en morceaux gérables plutôt qu'en grandes quantités de code séquentiel.Un des grands avantages de l'OOP est celui de l'évolutivité, avec des objets et des définitions sans limitation finie. De plus, la séparation des données de la méthode évite un problème courant rencontré dans les anciens langages logiciels linéaires. Si un bogue apparaît dans un code linéaire, il peut être traduit par un système et créer des masses d'erreurs difficiles à retracer. Inversement, un programme OOP, avec sa séparation de la méthode et des données, n'est pas susceptible de telles erreurs proliférées. Les langages OOP populaires incluent Java, la famille C des langages, VB.NET Shop et Python. Langages OOP dits "purs" comprennent Scala, Ruby, Eiffel, JADE, Smalltalk et Emerald.

La source des définitions provient de Qu'est-ce que la programmation orientée objet (POO)? - Définition de Techopedia et qu'est-ce qu'un langage procédural? - Définition de Techopedia

Maintenant. Regardons la différence de mise en œuvre sage.

Nous allons commencer par la procédure, et la façon la plus simple de le faire sera d'utiliser le langage C spécifiquement avec Arduino puisque c'est ce que je sais.

J'ai décidé d'utiliser le didacticiel Lumière clignotante comme base, car il s'agit de l'une des implémentations de base.

// la fonction de configuration s'exécute une fois lorsque vous appuyez sur reset ou sur la carte void setup () {// initialisez la broche numérique LED_BUILTIN en sortie. pinMode (LED_BUILTIN, OUTPUT); } // la fonction de boucle se répète indéfiniment void loop () {digitalWrite (LED_BUILTIN, HIGH); // allume la LED (HIGH est le niveau de tension) delay (1000); // attend une seconde digitalWrite (LED_BUILTIN, LOW); // éteint la LED en retardant la tension (1000); // attend une seconde}

Maintenant, permettez-moi d'expliquer un peu mieux le code. Vous avez deux fonctions Configuration et Boucle. La boucle est appelée à plusieurs reprises et la configuration n'est appelée qu'une seule fois. Vous envoyez la commande digitalWrite à la LED pour mettre la puissance nominale respectivement à haut et bas. Le délai est la durée pendant laquelle la lumière restera allumée ou éteinte, dans ce cas, 1000 ms ou environ 1 seconde. Assez simple, mais cela montre que vous avez l'essentiel de la programmation procédurale. Vous écrivez une procédure ou une instruction qui se répète jusqu'à la fin. Il n'y a pas de complexité supplémentaire au code requis.

Heure d'exemple C # et OOP.

en utilisant le système; using System.Collections.Generic; using System.Linq; using System.Text; namespace oops {public class customer {// Variables membres public int CustID; chaîne publique Nom; chaîne publique Adresse; // constuctor pour initialiser les champs customer () {CustID = 1101; Nom = "Tom"; Adresse = "USA"; } // méthode d'affichage des enregistrements client (fonctionnalité) public void displayData () {Console.WriteLine ("Customer =" + CustID); Console.WriteLine ("Nom =" + Nom); Console.WriteLine ("Adresse =" + Adresse); } // Code pour le point d'entrée}} Programme de classe {static void Main (string [] args) {// instanciation d'objet customer obj = new customer (); // Méthode appelant obj.displayData (); // champs appelant Console.WriteLine (obj.CustID); Console.WriteLine (obj.Name); Console.WriteLine (obj.Address); }}}

Voici un exemple classique de POO. Vous avez une classe de clients qui définit tous les objets dont vous disposez. Vous avez encore des fonctions / méthodes à écrire. Mais la principale différence est que vous souhaitez diviser chaque méthode / fonction en fonction de ce qu'elle est censée faire. À partir de là, votre méthode principale est le point d'entrée du programme et devrait donc avoir votre code critique ici.


Réponse 2:

Concept OOPS en Java

Le langage procédural est basé sur les fonctions mais le langage orienté objet est basé sur des objets du monde réel.Le langage procédural donne de l'importance sur la séquence d'exécution des fonctions mais le langage orienté objet donne de l'importance sur les états et les comportements des objets.Le langage procédural expose les données à l'ensemble du programme mais le langage orienté objet encapsule les données.Le langage procédural suit le paradigme de programmation descendante mais le langage orienté objet suit le paradigme de programmation ascendant.Le langage procédural est de nature complexe, il est donc difficile de le modifier, de l'étendre et de le maintenir, mais le langage orienté objet est de nature moins complexe il est donc plus facile de modifier, d'étendre et de maintenir. Le langage procédural offre moins de possibilités de réutilisation de code mais le langage orienté objet offre plus de possibilités de réutilisation de code.


Réponse 3:

La programmation procédurale est la programmation avec des procédures comme mécanisme d'abstraction principal. Huh.

Qu'est-ce qu'une procédure? Il s'agit d'un bloc de code nommé qui peut être invoqué par son nom et qui reçoit des valeurs et des références du contexte dans lequel il est invoqué, des paramètres et peut renvoyer des valeurs et des références à ce contexte après avoir effectué certains travaux.

Souvent, une valeur particulière sera indiquée dans la procédure comme valeur de retour. Dans les langues qui prennent en charge les procédures, il est courant de les voir utilisées comme s'il s'agissait de fonctions, où les paramètres sont traités comme des arguments et la valeur de retour est calculée dans la procédure comme la valeur de la fonction pour ces arguments. Mais il est également idiomatique que la procédure retourne une ou plusieurs valeurs à son contexte d'appel via des paramètres, soit des paramètres «out» si le langage le supporte, soit en changeant une valeur passée par référence, et utiliser la valeur de retour elle-même pour un indicateur, indicateur d'état ou d'erreur. Dans les cultures de programmation fortement influencées par Unix, vous verrez souvent 0 retourné pour indiquer le succès (ou au moins, l'absence d'échecs connus) et un nombre négatif pour indiquer un mode d'échec connu.

Ce n'est pas strictement nécessaire au modèle mais je ne peux pas penser à un langage qui utilise des procédures comme son mécanisme d'abstraction principal qui n'a pas non plus de flux de contrôle utilisant à peu près le même ensemble de semi-magiques bien connus des choses comme:

if (condition) {doThisThing ()} else {doThatThing ()}

et

while (condition) {keepOnDoingThisThing ()}

Je pense que dans la plupart des programmeurs, la programmation «procédurale» est à peu près confondue avec la «programmation structurée». À l'époque où la programmation structurée était nouvelle, il a été constaté qu'il existe un ensemble pratique de constructions de flux de contrôle à partir desquelles tous les modèles de flux de contrôle nécessaires dans une procédure peuvent être construits:

choisir des alternatives

  • si alors sinon (deux choix, basés sur un booléen) cas ou commutateur (beaucoup de choix, basés sur n'importe quel ensemble)

répétition

avec des limites connues:

  • pour les boucles (généralement un nombre donné d'itérations) pour chaque boucle (itérer autant de fois que la taille d'une collection, peut-être sur les membres eux-mêmes)

avec des limites ad hoc:

  • while do (0 ou plusieurs itérations) do while (1 ou plusieurs itérations)

et le tristement impopulaire:

  • boucle exit-when

qui exécute le code avant la sortie au moins une fois, et le code après la sortie zéro ou plusieurs fois.

Ces structures peuvent être mises en œuvre les unes par rapport aux autres, mais c'est étonnamment difficile dans certains cas. Les instructions switch / case sont très difficiles à émuler exactement avec des if imbriqués. Et l'important pour nous est que ceux-ci sont presque toujours intégrés à l'implémentation du langage, et ils peuvent faire des choses que vous, le programmeur, aurez du mal à écrire du code. Dans tous les langages purement ou principalement procéduraux auxquels je peux penser, il serait très difficile et, dans de nombreux cas, carrément impossible d'écrire vos propres structures de contrôle qui fonctionnaient de la même manière que celles intégrées. Donc, vous utilisez ceux qui sont intégrés. La programmation procédurale et structurée est un monde très contraint.

Les langages de programmation procédurale ont également tendance à avoir une sorte de concept de module, un conteneur nommé pour un tas de procédures. Certaines de ces procédures seront visibles et utilisables à l'extérieur du module, d'autres ne seront visibles et utilisables qu'à l'intérieur du module, c'est-à-dire par d'autres procédures également dans le même module. Dans la plupart des langages avec modules, un module peut également contenir des variables qui sont visibles et partagées entre les procédures définies dans le module. Même C peut le faire. Un tel système de modules permet un certain degré d'encapsulation et de masquage des informations: ces procédures et variables à l'intérieur du module, fournissant la mise en œuvre des procédures visibles à l'extérieur du module, peuvent aider à contrôler le couplage à travers la structure d'un système. Ce qui est bien.

Si vous allez plus loin et autorisez plusieurs utilisations du même module, chaque utilisation ayant sa propre copie des variables définies dans le module, le module commence alors à ressembler à une sorte d'objet primitif. Et si vous faites ensuite les instances des modules avec les variables la chose principale et partagez les procédures entre elles d'une manière ou d'une autre, donc vous n'en avez qu'une copie, alors vous êtes assez proche de ce que fait C ++. Cette programmation modulaire, procédurale et structurée à grain fin n'est pas une programmation orientée objet.

La programmation orientée objet est la programmation avec des objets comme mécanisme d'abstraction principal. Huh.

Qu'est-ce qu'un objet? C'est une entité de calcul à longue durée de vie à laquelle on peut demander de faire quelque chose. Un archétype et un exemple de programmation orientée objet est Smalltalk. Dans Smalltalk, chaque valeur est un objet (ou du moins, les très rares valeurs qui ne sont pas des objets sont conçues pour ressembler à elles). Le calcul procède par l'envoi d'objets entre eux par des objets. Les implémentations de Smalltalk varient quelque peu, mais c'est l'idée générale:

Objets placés en mémoire. Lorsqu'un objet veut qu'un autre objet fasse quelque chose, il crée un message le demandant et l'envoie à l'objet voulu. Les messages sont des objets. Les objets sont responsables du maintien de l'état, c'est-à-dire qu'ils contiennent des variables. Ils n'exécutent pas de code. Lorsqu'un objet reçoit un message, il le transmet à sa classe. Les classes sont des objets. Les classes sont responsables de la création et de la gestion des objets, elles n'exécutent pas de code. La classe transmet le message à sa métaclasse. Les métaclasses sont des objets. Les métaclasses sont responsables de la gestion des méthodes. La métaclasse examine ses méthodes et trouve celle correspondant au message. Les méthodes sont des objets. En cours de route, l'objet du message a été décoré de diverses informations supplémentaires, y compris une référence à l'objet qui a reçu le message. La méthode est responsable de l'exécution du code et utilise tous les arguments passés dans le message d'origine pour ce faire. La méthode exécute son code dans le contexte de l'objet qui a reçu le message. Le code de la méthode n'est qu'un script de messages à créer et à envoyer à d'autres objets. Si la métaclasse ne trouve pas de méthode pour correspondre au message, une recherche démarre les métaclasses des classes parentes de la classe de l'objet. C'est ce qu'on appelle «l'héritage».

Il se peut qu'une implémentation ou une autre intègre certaines méthodes à l'implémentation pour des raisons d'efficacité, mais en principe, un système Smalltalk complet peut fonctionner de cette façon.

La programmation, dans Smalltalk, signifie une combinaison d'envois de messages de script pour aller dans les méthodes et créer de nouvelles classes (avec des métaclasses) pour les méthodes à vivre. Et cela est aussi vrai pour l'équivalent du flux de contrôle que pour n'importe quoi autre.

Dans un langage procédural, vous pouvez prendre des mesures sur chaque membre d'une collection avec du code un peu comme ce pseudo-code:

foreach (theThing in aCollection) doThisActionOn (theThing)

Dans un Smalltalk typique, le script équivalent d'envoi de messages peut ressembler à ceci:

aCollection: [aThing | aTHhing takeThisAction].

Ici, takeThisAction est un message envoyé à chaque objet aThing dans la collection aCollection. (Soit dit en passant, le code entre crochets est un bloc, ce que Smalltalk appelle un lambda. C'est un objet.) Si nous comparons les deux, nous pouvons voir certaines caractéristiques critiques de la programmation orientée objet contrairement à la procédure:

  • Dans le code procédural, nous choisissons comment traverser les membres de la collection, nous choisissons le mécanisme foreach. Dans le code orienté objet, nous demandons à la collection de faire une traversée, nous ne savons pas comment elle le fait.Dans le code procédural, le code appelant doit avoir accès à la procédure nommée doThisActionOn, dans le code orienté objet takeThisAction est juste un symbole. Nous ne savons pas comment les objets de la collection l'interpréteront.

C'est l'essence même de la programmation orientée objet, et elle a été décrite comme «la programmation en passant la balle». Dans la programmation procédurale, en revanche, nous devons indiquer explicitement ce que fait chaque calcul.