Polymorphisme vs héritage: Différence entre polymorphisme et héritage [2022]

Le polymorphisme et l'héritage sont deux concepts très fondamentaux de la programmation orientée objet. L'ajout d'objets dans les langages de programmation modernes a fait une différence considérable dans la façon dont nous utilisons le langage et les choses que nous sommes capables de faire avec eux. En un mot, la programmation orientée objet est un ensemble de méthodes qui permet au programmeur d'utiliser des classes et, par conséquent, de dériver des objets basés sur ces classes.

Il vise à ressembler à des entités du monde réel et à permettre aux programmeurs de rendre plus facile leur code incluant le paradigme dans lequel ils écrivent leur code. Il existe essentiellement quatre concepts de programmation orientés objet, à savoir l'héritage, l'abstraction, le polymorphisme et l'encapsulation. Maintenant, chacune des idées, comme mentionné précédemment, peut être considérée comme les piliers sur lesquels repose toute langue moderne.

Pour en revenir à notre sujet du polymorphisme contre l'héritage et le droit de la chauve-souris, nous voyons une différence flagrante entre les deux concepts. L'héritage est le concept qui permet au code d'être réutilisé à nouveau dans le même programme ou dans un programme différent. Nous pouvons même modifier le comportement du code en conservant les choses que nous aimons et en supprimant celles qui ne sont pas utiles pour les tâches que nous essayons d'accomplir. L'héritage permet de gagner beaucoup de temps en développant presque tout ce que nous voyons sur nos écrans numériques de nos jours.

D'autre part, le polymorphisme est chargé de dicter le code qui a déjà été écrit et de décider quel type de code doit être exécuté en fonction de paramètres spécifiques en temps réel. Il serait avantageux pour quiconque de passer d'abord en revue chacun de ces concepts en détail, avant de passer à la discussion de la différence entre polymorphisme et héritage. Les différences deviendront plus prononcées une fois que nous saurons ce que l'on entend exactement par héritage et polymorphisme.

Obtenez des diplômes en génie logiciel des meilleures universités du monde. Gagnez des programmes Executive PG, des programmes de certificat avancés ou des programmes de maîtrise pour accélérer votre carrière.

Héritage

Ce serait un crime dans le paradigme de la programmation de ne pas considérer l'héritage comme un concept extrêmement crucial de la POO. L'importance de l'héritage ne doit jamais être prise à la légère, car le but de l'héritage est la « réutilisabilité ». Ce que fait l'héritage, comme son nom l'indique, c'est qu'il permet au code écrit dans une classe d'être étendu à une autre classe. Ainsi, en héritage, il existe une classe de base ; la classe dans laquelle le code est écrit doit être réutilisée.

La prochaine classe que nous créerions devrait être héritée de cette classe de base pour utiliser toutes les fonctions et variables associées à la classe de base. Chaque fois qu'une classe prend les propriétés d'une autre classe (ou hérite d'une classe différente), tous les membres présents dans la classe de base deviennent membres de cette nouvelle classe dérivée.

L'exemple de code ci-dessous vous montrera à quoi ressemble une forme générale d'héritage. Une chose clé à noter ici est que la syntaxe exacte que vous auriez à écrire pour activer l'héritage de votre code dépendrait uniquement du langage de programmation que vous choisissez.

1. class nom-classe-dérivé : spécificateur d'accès nom-classe-base{
2. // corps de la classe dérivée
3. }

Dans l'exemple ci-dessus, certaines choses nécessitent une petite explication. Le mot « spécificateur d'accès » désigne la manière dont la classe dérivée accéderait aux propriétés et aux méthodes de la classe de base. Il existe trois spécificateurs d'accès en général, chacun ayant sa propre signification (à savoir privé, public et protégé) et ses propriétés.

Encore une fois, selon la langue de votre choix, vous devrez ou non utiliser ces spécificateurs d'accès. Ainsi, dans le monde du C++, si vous héritez sans rien spécifier par défaut, cela devient privé. Cependant, si vous héritez d'une structure (passe par le mot-clé struct), le spécificateur d'accès par défaut serait public au lieu de privé.

Lire : Opportunités de carrière dans le langage de programmation R

C++ vous donne également beaucoup d'options parmi lesquelles choisir lorsque vous faites de l'héritage. Vous en trouverez quelques-uns ci-dessous :

une. Héritage hiérarchique : Ce type d'héritage suit la règle selon laquelle il ne devrait y avoir qu'une seule superclasse, et à partir de cette superclasse, il doit y avoir de nombreuses sous-classes dérivées. Vous en trouverez un exemple ci-dessous :

1. //Classe de base
2. Classe A
3. {
4. public void funA()
5. {
6. //
7. }
8. }
10. //Classe dérivée
11. classe B : A
12. {
13. public void funB()
14. {
15. //
16. }
17. }
19. //Classe dérivée
20. classe C : A
21. {
22. public void funC()
23. {
24. //
25. }
26. }
28. //Classe dérivée
29. classe D : C
30. {
31. vide public funD()
32. {
33. //
34. }
35. }
37. //Classe dérivée
38. classe E : C
39. {
40. public void funE()
41. {
42. //
43. }
44. }
46. //Classe dérivée
47. classe F : B
48. {
49. public void funF()
50. {
51. //
52. }
53. }
55. //Classe dérivée
56. classe G : B
57. {
58. public void funG()
59. {
60. //
61. }
62. }

b. Héritage multiple : Si vous effectuez un héritage multiple, cela signifierait que vous n'avez qu'une seule sous-classe dérivée qui hérite de plusieurs superclasses. Vous trouverez ci-dessous un exemple simple d'héritage multiple :

1. //Classe de base
2. Classe A
3. {
4. public void funA()
5. {
6. //
7. }
8. }
10. //Classe de base
11. classe B
12. {
13. public void funB()
14. {
15. //
16. }
17. }
19. //Classe dérivée
20. classe C : A, B
21. {
22. public void funC()
23. {
24. //
25. }
26. }

c. Héritage unique : Il s'agit peut-être de la forme d'héritage la plus simple. Il n'y a qu'une classe de base et une classe dérivée. Vous trouverez un exemple ci-dessous :

1. //Classe de base
2. Classe A
3. {
4. public void funA()
5. {
6. //À FAIRE:
7. }
8. }
10. //Classe dérivée
11. classe B : A
12. {
13. public void funB()
14. {
15. //À FAIRE:
16. }
17. }

Polymorphisme

La définition de base du mot polymorphisme signifie avoir de nombreuses formes. Cette définition est valable pour expliquer le polymorphisme dans le contexte de la programmation. Dans ce paradigme, le polymorphisme prend le sens d'une fonction mais de plusieurs formes. Le polymorphisme se produit réellement au moment de la compilation. Le polymorphisme au moment de la compilation n'est possible qu'en raison du concept de surcharge, et au moment de l'exécution, la fonctionnalité de remplacement fait du polymorphisme une réalité. Un par un, abordons la définition à la fois de la surcharge et du dépassement.

La surcharge nécessite que le code que vous écrivez ou que la fonction de la classe soit écrite plusieurs fois avec des paramètres différents mais avec le même type de retour. Cela signifie que les arguments que vous transmettez à la fonction peuvent être différents, et simplement en regardant les valeurs finales qui sont transmises à la fonction au moment de l'exécution, la forme de la fonction à appeler est décidée. Généralement, nous voyons le constructeur de classe être la fonction la plus surchargée. Toute cette théorie deviendra beaucoup plus claire et il vous sera plus facile de l'ancrer dans votre esprit à l'aide d'un exemple.

1. surcharge de classe{
2. entier a, b ;
3. Publique:
4. int surcharge (int x){ // premier constructeur de surcharge()
5. un=x ;
6. retourner un ;
7. }
8. int surcharge (int x, int y){ //deuxième constructeur de surcharge()
9. un=x ;
10. b=y ;
11. retourner a*b ;
12. }
13. } ;
14. int principal (){
15. surcharge O1 ;
16. O1. surcharge (20); //premier appel du constructeur surcharge()
17. O1. surcharge (20,40); // second appel du constructeur surcharge()

Ici, dans cet exemple, nous voyons la surcharge en action. Regardez comment différents constructeurs sont appelés selon que la valeur finale de la parenthèse de l'objet est un entier ou deux.

Abordons ensuite la définition de Overriding. Vous ne pouvez effectuer de remplacement que sur les fonctions spécifiques héritées. Oui, l'héritage est un point clé pour rendre possible le remplacement des fonctions. Si vous souhaitez écrire une fonction et également la remplacer, en C++, vous devrez utiliser le mot-clé virtual avant la définition de la fonction, et dans la classe dérivée utilisant le même nom pour votre fonction, supprimez simplement le mot-clé virtual. Pour solidifier votre compréhension, voici un exemple :

1. base de classe{
2. Publique:
3. virtual void funct (){ //fonction virtuelle de la classe de base
4. cout<<« Ceci est la fonction d'une classe de base » ;
5. }
6. } ;
7. classe dérivée1 : base publique{
8. Publique:
9. void funct (){ //fonction virtuelle de la classe de base redéfinie dans la classe dérivée1
10. cout<<« Ceci est la fonction d'une classe dérivée1 » ;
11. }
12. } ;
13. entier principal ()
14. {
15. base *p, b ;
16. dérivé1 d1 ;
17. *p=&b;
18. p-> fonction (); //appel à la fonction de classe de base().
19. *p=&d1;
20. renvoie 0 ;
21. }

Regardez comment le mot-clé virtual est utilisé dans la classe de base, et dans la classe dérivée, la même définition de fonction est là juste le mot-clé virtual est absent.

Quelques différences persistantes entre polymorphisme et héritage :

1. L'héritage consiste essentiellement à créer une classe, puis à faire en sorte que d'autres classes de votre programme obtiennent leurs fonctionnalités à partir de la classe de base déjà existante. Cependant, le polymorphisme est une interface et, du fait qu'il s'agit d'une interface, il peut prendre différentes formes.
2. L'héritage est une propriété appartenant uniquement aux classes alors que le polymorphisme s'étend à n'importe quelle méthode et/ou fonction.
3. L'héritage permet à la classe dérivée d'utiliser toutes les fonctions et variables déclarées dans la classe de base sans les redéfinir explicitement. C'est pourquoi nous disons que l'héritage augmente la réutilisabilité du code et réduit la longueur du code, que nous aurions à écrire si l'héritage était absent. Alors que le polymorphisme permet au même nom de fonction d'avoir deux codes très différents. Ainsi, en un sens, au lieu de réduire la longueur du code que nous aurions à écrire, le polymorphisme l'allonge davantage.
4. L'héritage peut prendre de nombreuses formes; vous pouvez être vraiment créatif avec l'héritage. Cependant, le polymorphisme ne peut être accompli que par deux moyens, c'est-à-dire la surcharge et le remplacement. Vous pouvez toujours devenir très fou en utilisant le polymorphisme, mais vous êtes limité aux deux façons de l'implémenter dans votre code d'écriture.

Doit lire: Doit lire 47 questions et réponses d'entrevue OOPS pour les débutants et les expérimentés

Polymorphisme vs héritage : différenciation tabulaire

Dans le tableau ci-dessous, vous trouverez une nette différence entre polymorphisme et héritage :

Découvrez: Qu'est-ce que la conversion de type en Java | Comprendre le casting de type en tant que débutant

Conclusion

Il est prudent de dire que le polymorphisme et l'héritage sont des concepts essentiels pour faire de n'importe quel programme une réalité. Ils sont tous deux à la base de l'idée de la programmation orientée objet. Il existe de nombreuses différences entre le polymorphisme et l'héritage car ils servent deux objectifs très différents.

Le polymorphisme permet au programmeur d'écrire plusieurs définitions d'une fonction. En même temps, l'héritage permet à l'utilisateur de réutiliser le code déjà écrit. Pour bien comprendre et apprécier les deux concepts, il est recommandé de lire davantage sur les deux sujets.

Une chose que vous devez toujours garder à l'esprit chaque fois que vous écrivez du code est que si vous cherchez à refactoriser le code que vous avez déjà écrit (essentiellement la définition d'une classe et l'utiliser à nouveau dans votre code pour servir un code similaire ou différent but), vous devriez faire usage de l'héritage. Si vous cherchez à réduire la confusion générale dans votre code et que vous souhaitez utiliser le même nom de fonction pour effectuer des tâches similaires, vous devez utiliser le polymorphisme.

Si vous souhaitez en savoir plus sur le développement de logiciels à pile complète, consultez le diplôme PG upGrad & IIIT-B en développement de logiciels à pile complète qui est conçu pour les professionnels en activité et offre plus de 500 heures de formation rigoureuse, plus de 9 projets et affectations, statut d'anciens élèves de l'IIIT-B, projets de synthèse pratiques et aide à l'emploi avec les meilleures entreprises.

Planifiez votre carrière en développement de logiciels dès maintenant.

Postulez pour la certification PG liée à l'emploi d'upGrad en génie logiciel