Polimorfism vs. Moștenire: diferența dintre polimorfism și moștenire [2022]

Polimorfismul și moștenirea sunt ambele concepte fundamentale ale programării orientate pe obiecte. Adăugarea de obiecte în limbajele de programare moderne a făcut o diferență considerabilă în modul în care folosim limbajul și lucrurile pe care suntem capabili să le facem cu ele. Pe scurt, programarea orientată pe obiecte este un set de metode care permite programatorului să folosească clase și, prin urmare, să derive obiecte pe baza acestor clase.

Acesta își propune să semene cu entitățile din lumea reală și să le faciliteze programatorilor să-și facă codul inclusiv paradigma în care își scriu codul. Există în esență patru concepte de programare orientată pe obiecte, și anume Moștenire, Abstracție, Polimorfism și încapsulare. Acum, fiecare dintre idei, așa cum am menționat mai devreme, poate fi considerată pilonii pe care stă orice limbă modernă.

Revenind la subiectul nostru despre polimorfism vs. moștenire și dreptul liliacului, vedem o diferență evidentă între cele două concepte. Moștenirea este conceptul care permite reutilizarea codului în același program sau diferit. Putem chiar schimba modul în care se comportă codul păstrând lucrurile care ne plac și renunțând pe cele care nu sunt utile pentru sarcinile pe care încercăm să le îndeplinim. Moștenirea economisește mult timp în dezvoltarea aproape a tot ceea ce vedem pe ecranele noastre digitale în zilele noastre.

Pe de altă parte, polimorfismul este responsabil pentru dictarea codului care a fost deja scris și pentru a decide ce fel de cod trebuie executat pe baza unor parametri specifici în timp real. Ar fi benefic pentru oricine să parcurgă mai întâi fiecare dintre aceste concepte în detaliu, înainte de a trece la discuția despre diferența dintre polimorfism și moștenire. Diferențele vor deveni mai pronunțate odată ce vom ști ce se înțelege exact prin moștenire și polimorfism.

Obțineți diplome de Inginerie software de la cele mai bune universități din lume. Câștigă programe Executive PG, programe avansate de certificat sau programe de master pentru a-ți accelera cariera.

Moştenire

Ar fi o crimă în paradigma de programare să nu consideri Moștenirea ca fiind un concept extrem de crucial OOP. Importanța moștenirii nu ar trebui niciodată tratată cu ușurință, deoarece scopul moștenirii este „reutilizarea”. Ceea ce face moștenirea, așa cum ar sugera și numele, este că permite ca codul scris într-o clasă să fie extins într-o altă clasă. Deci, în moștenire, există o clasă de bază; clasa în care este scris codul urmează să fie reutilizată.

Următoarea clasă pe care am crea-o ar trebui să fie moștenită de la această clasă de bază pentru a utiliza toate funcțiile și variabilele asociate cu clasa de bază. Ori de câte ori o clasă preia proprietățile unei alte clase (sau moștenește de la o clasă diferită), toți membrii care sunt prezenți în clasa de bază devin membri ai acestei noi clase derivate.

Exemplul de cod de mai jos vă va arăta cum arată o formă generală de moștenire. Un lucru esențial de reținut aici este că sintaxa exactă pe care ar trebui să o scrieți pentru a activa moștenirea codului dvs. ar depinde numai de limbajul de programare pe care îl alegeți.

1. class derived-class-name : specificatorul de acces de bază-clas-name{
2. // corpul clasei derivate
3. }

În exemplul prezentat mai sus, anumite lucruri au nevoie de o mică explicație. Cuvântul „specificator de acces” înseamnă modul în care clasa derivată ar accesa proprietățile și metodele clasei de bază. Există trei specificatori de acces în general, fiecare având propriul sens (și anume privat, public și protejat) și proprietăți.

Încă o dată, în funcție de limba pe care o alegeți, este posibil să fie necesar sau nu să utilizați acești specificatori de acces. Deci, în lumea C++, dacă moșteniți fără a specifica nimic implicit, devine privat. Cu toate acestea, dacă moșteniți dintr-o structură (se merge după cuvântul cheie struct), specificatorul de acces implicit ar fi public în loc de privat.

Citiți: Oportunități de carieră în limbajul de programare R

C++ vă oferă, de asemenea, o mulțime de opțiuni din care să alegeți atunci când faceți moștenire. Veți găsi câteva dintre ele enumerate mai jos:

A. Moștenire ierarhică: Acest tip de moștenire urmează regula conform căreia ar trebui să existe o singură superclasă și din acea superclasă trebuie să existe mai multe subclase derivate. Veți găsi un exemplu al acestuia mai jos:

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

b. Moștenire multiplă: dacă faceți moștenire multiplă, asta ar însemna că aveți doar o subclasă derivată care moștenește de la mai multe superclase. Veți găsi un exemplu simplu de moștenire multiplă mai jos:

1. //Clasa de bază
2. clasa a
3. {
4. public void funA()
5. {
6. //
7. }
8. }
10. //Clasa de bază
11. clasa B
12. {
13. public void funB()
14. {
15. //
16. }
17. }
19. //Clasă derivată
20. clasa C: A, B
21. {
22. public void funC()
23. {
24. //
25. }
26. }

c. Moștenire unică: aceasta este poate cea mai simplă formă de moștenire. Există doar o clasă de bază și o clasă derivată. Veți găsi un exemplu mai jos:

1. //Clasa de bază
2. clasa a
3. {
4. public void funA()
5. {
6. //A FACE:
7. }
8. }
10. //Clasă derivată
11. clasa B: A
12. {
13. public void funB()
14. {
15. //A FACE:
16. }
17. }

Polimorfismul

Definiția de bază a cuvântului polimorfism înseamnă a avea mai multe forme. Această definiție este foarte precisă în explicarea polimorfismului în contextul programării. În această paradigmă, polimorfismul ia sensul unei singure funcții, dar mai multor forme. Polimorfismul are loc de fapt în timpul compilării. Polimorfismul în timpul compilării este posibil doar datorită conceptului de supraîncărcare, iar în timpul rulării, caracteristica suprascrierii face ca polimorfismul să devină realitate. Rând pe rând, să abordăm atât definiția supraîncărcării, cât și a suprasolicitarii.

Supraîncărcarea necesită ca codul pe care îl scrieți sau funcția clasei să fie scris de mai multe ori cu parametri diferiți, dar având același tip de returnare. Înseamnă că argumentele pe care le treceți în funcție pot fi diferite și, doar privind valorile finale care sunt trecute în funcție în timpul rulării, se decide ce formă a funcției urmează să fie apelată. În general, vedem că constructorul de clasă este cea mai supraîncărcată funcție. Toată această teorie va deveni mult mai clară și îți va fi mai ușor să o înrădăciți în minte cu ajutorul unui exemplu.

1. supraîncărcare de clasă{
2. int a, b;
3. public:
4. int supraîncărcare (int x){ // primul constructor supraîncărcare().
5. a=x;
6. returnează a;
7. }
8. supraîncărcare int (int x, int y){ //secunda supraîncărcare() constructor
9. a=x;
10. b=y;
11. returnează a*b;
12. }
13. };
14. int main (){
15. suprasarcina O1;
16. O1. suprasarcină (20); //primul apel de constructor overload().
17. O1. suprasarcină (20,40); // al doilea apel de constructor overload().

Aici, în acest exemplu, vedem supraîncărcarea în acțiune. Priviți cum sunt numiți diferiți constructori în funcție de valoarea finală a parantezei obiectului este fie un număr întreg, fie doi.

Să abordăm în continuare definiția Overriding. Puteți efectua suprascrie numai acelor funcții specifice care sunt moștenite. Da, moștenirea este un punct cheie în a face posibilă anularea funcțiilor. Dacă doriți să scrieți o funcție și, de asemenea, să o suprascrieți, în C++ va trebui să utilizați cuvântul cheie virtual înainte de definiția funcției, iar în clasa derivată folosind același nume pentru funcția dvs., trebuie doar să eliminați cuvântul cheie virtual. Pentru a vă consolida înțelegerea, iată un exemplu:

1. baza de clasa{
2. public:
3. virtual void funct (){ //funcția virtuală a clasei de bază
4. cout<<“Acesta este funct() a unei clase de bază”;
5. }
6. };
7. clasa derivată1: bază publică{
8. public:
9. void funct (){ //funcția virtuală a clasei de bază redefinită în clasa derivată1
10. cout<<“Acesta este funct() a unei clase derivate1”;
11. }
12. };
13. int main ()
14. {
15. baza *p, b;
16. derivat1 d1;
17. *p=&b;
18. p-> funct (); //apel la clasa de bază funct().
19. *p=&d1;
20. returnează 0;
21. }

Uitați-vă la modul în care cuvântul cheie virtual este utilizat în clasa de bază, iar în clasa derivată, aceeași definiție a funcției există, doar cuvântul cheie virtual este absent.

Câteva diferențe persistente între polimorfism și moștenire:

1. Moștenirea înseamnă, în esență, a crea o clasă, iar apoi a avea alte clase în programul tău să-și obțină caracteristicile din clasa de bază deja existentă. Cu toate acestea, polimorfismul este o interfață și, deoarece este o interfață, poate lua diferite forme și forme.
2. Moștenirea este o proprietate care aparține doar claselor, în timp ce polimorfismul se extinde în orice metodă și/sau funcție.
3. Moștenirea permite clasei derivate să folosească toate funcțiile și variabilele declarate în clasa de bază fără a le defini din nou în mod explicit. De aceea spunem că moștenirea crește reutilizabilitatea codului și reduce lungimea codului, pe care ar trebui să-l scriem dacă moștenirea ar fi absentă. În timp ce polimorfismul permite ca același nume de funcție să aibă două coduri foarte diferite. Deci, într-un fel, în loc să reducem lungimea codului pe care ar trebui să-l scriem, polimorfismul îl extinde și mai mult.
4. Există multe forme pe care le poate lua moștenirea; poți fi cu adevărat creativ cu moștenirea. Cu toate acestea, polimorfismul poate fi realizat doar prin două mijloace, adică supraîncărcare și suprascriere. Încă poți înnebuni foarte mult când folosești polimorfismul, dar ești limitat la doar două moduri de implementare a acestuia în codul tău de scriere.

Trebuie să citiți: Trebuie să citiți 47 de întrebări și răspunsuri la interviu OOPS pentru cei proaspăt și cu experiență

Polimorfism vs. moștenire: diferențierea tabulară

În tabelul de mai jos, veți găsi o diferență clară între polimorfism și moștenire:

Verificați: Ce este Type Casting în Java | Înțelegerea tipului de casting ca începător

Concluzie

Este sigur să spunem că atât polimorfismul, cât și moștenirea sunt concepte esențiale pentru a face orice program în realitate. Ambele sunt fundamentul pe care a fost pusă ideea de programare orientată pe obiecte. Există multe diferențe între polimorfism și moștenire, deoarece acestea servesc la două scopuri foarte diferite.

Polimorfismul permite programatorului să scrie mai multe definiții ale unei funcții. În același timp, moștenirea permite utilizatorului să refolosească codul deja scris. Pentru a înțelege și a aprecia pe deplin cele două concepte, este recomandat să citiți în continuare despre ambele subiecte.

Un lucru pe care ar trebui să-l țineți întotdeauna în minte ori de câte ori scrieți cod este că, dacă doriți să refactorizați codul pe care l-ați scris deja (în principiu, definiția unei clase și să o utilizați din nou în codul dvs. pentru a servi un cod similar sau diferit). scop), ar trebui să folosiți moștenirea. Dacă doriți să reduceți confuzia generală din codul dvs. și doriți să utilizați același nume al funcției pentru a face sarcini similare, ar trebui să utilizați polimorfismul.

Dacă sunteți interesat să aflați mai multe despre dezvoltarea de software full-stack, consultați UpGrad & IIIT-B PG Diploma in Full-stack Software Development, care este conceput pentru profesioniști care lucrează și oferă peste 500 de ore de formare riguroasă, peste 9 proiecte și misiuni, statutul de absolvenți IIIT-B, proiecte practice practice și asistență pentru locuri de muncă cu firme de top.

Planificați-vă acum cariera de dezvoltare software.

Aplicați pentru certificarea upGrad PG legată de locuri de muncă în inginerie software