Polimorfismo vs. Ereditarietà: differenza tra polimorfismo ed ereditarietà [2022]

Il polimorfismo e l'ereditarietà sono entrambi concetti fondamentali della programmazione orientata agli oggetti. L'aggiunta di oggetti nei linguaggi di programmazione moderni ha fatto una notevole differenza nel modo in cui usiamo il linguaggio e nelle cose che siamo in grado di fare con esso. In poche parole, la programmazione orientata agli oggetti è un insieme di metodi che consente al programmatore di utilizzare classi e, quindi, derivare oggetti basati su queste classi.

Mira ad assomigliare a entità del mondo reale e rendere più facile per i programmatori rendere il loro codice inclusivo del paradigma in cui stanno scrivendo il loro codice. Esistono essenzialmente quattro concetti di programmazione orientata agli oggetti, ovvero Ereditarietà, Astrazione, Polimorfismo e incapsulamento. Ora, ciascuna delle idee, come accennato in precedenza, può essere considerata come i pilastri su cui si regge qualsiasi lingua moderna.

Tornando al nostro argomento di polimorfismo contro eredità e diritto del pipistrello, vediamo una differenza evidente tra i due concetti. L'ereditarietà è il concetto che consente di riutilizzare il codice nello stesso programma o in un programma diverso. Possiamo anche cambiare il modo in cui si comporta il codice mantenendo le cose che ci piacciono e scartando quelle che non sono utili per i compiti che stiamo cercando di svolgere. L'ereditarietà consente di risparmiare molto tempo nello sviluppo di quasi tutto ciò che vediamo sui nostri display digitali al giorno d'oggi.

D'altra parte, il polimorfismo è responsabile di dettare il codice già scritto e decidere quale tipo di codice deve essere eseguito in base a parametri specifici in tempo reale. Sarebbe utile per chiunque esaminare prima in dettaglio ciascuno di questi concetti, prima di passare alla discussione della differenza tra polimorfismo ed ereditarietà. Le differenze diventeranno più pronunciate una volta che sapremo cosa si intende esattamente per Ereditarietà e Polimorfismo.

Ottieni lauree in ingegneria del software dalle migliori università del mondo. Guadagna programmi Executive PG, programmi di certificazione avanzati o programmi di master per accelerare la tua carriera.

Eredità

Sarebbe un crimine nel paradigma di programmazione non considerare l'ereditarietà come un concetto OOP altamente cruciale. L'importanza dell'eredità non dovrebbe mai essere trattata alla leggera perché lo scopo dell'eredità è la "riutilizzabilità". Ciò che l'ereditarietà fa, come implica il nome, è che consente al codice scritto in una classe di essere esteso a un'altra classe. Quindi, nell'ereditarietà, esiste una classe base; la classe in cui è scritto il codice deve essere riutilizzata.

La classe successiva che creeremo dovrebbe essere ereditata da questa classe base per utilizzare tutte le funzioni e le variabili associate alla classe base. Ogni volta che una classe prende le proprietà di un'altra classe (o eredita da una classe diversa), tutti i membri presenti nella classe base diventano membri di questa nuova classe derivata.

Il codice di esempio riportato di seguito ti mostrerà l'aspetto di una forma generale di ereditarietà. Una cosa fondamentale da notare qui è che l'esatta sintassi che dovresti scrivere per abilitare l'ereditarietà del tuo codice dipenderebbe esclusivamente dal linguaggio di programmazione che scegli.

1. classe derivata-nome-classe : identificatore-accesso nome-classe-base{
2. // corpo della classe derivata
3. }

Nell'esempio mostrato sopra, alcune cose richiedono una piccola spiegazione. La parola "identificatore di accesso" indica il modo in cui la classe derivata accede alle proprietà e ai metodi della classe base. Ci sono tre specificatori di accesso in generale, ognuno con il proprio significato (vale a dire privato, pubblico e protetto) e proprietà.

Ancora una volta, a seconda della lingua scelta, potresti dover utilizzare o meno questi identificatori di accesso. Quindi, nel mondo di C++, se erediti senza specificare nulla per impostazione predefinita, diventa privato. Tuttavia, se si eredita da una struttura (va dalla parola chiave struct), l'identificatore di accesso predefinito sarebbe pubblico anziché privato.

Leggi: Opportunità di carriera nel linguaggio di programmazione R

C++ offre anche molte opzioni tra cui scegliere quando si esegue l'ereditarietà. Ne troverai alcuni elencati di seguito:

un. Ereditarietà gerarchica: questo tipo di eredità segue la regola che dovrebbe esserci solo una superclasse e da quella superclasse devono esserci molte sottoclassi derivate. Ne troverai un esempio qui sotto:

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

B. Ereditarietà multipla: se stai eseguendo un'ereditarietà multipla, ciò significherebbe che hai solo una sottoclasse derivata che sta ereditando da più superclassi. Di seguito troverai un semplice esempio di eredità multipla:

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

C. Ereditarietà singola: questa è forse la forma più semplice di eredità. C'è solo una classe base e una classe derivata. Troverai un esempio qui sotto:

1. //Classe base
2. classe A
3. {
4. public void funA()
5. {
6. //DA FARE:
7. }
8. }
10. //Classe derivata
11. classe B: A
12. {
13. public void funB()
14. {
15. //DA FARE:
16. }
17. }

Polimorfismo

La definizione di base della parola polimorfismo significa avere molte forme. Questa definizione vale molto accuratamente per spiegare il polimorfismo nel contesto della programmazione. In questo paradigma, il polimorfismo assume il significato di una funzione ma molte forme. Il polimorfismo si verifica effettivamente in fase di compilazione. Il polimorfismo in fase di compilazione è possibile solo a causa del concetto di sovraccarico e, in fase di esecuzione, la caratteristica dell'override rende il polimorfismo una realtà. Uno per uno, affrontiamo la definizione sia di sovraccarico che di override.

L'overload richiede che il codice che scrivi o la funzione della classe venga scritta più di una volta con parametri diversi ma con lo stesso tipo restituito. Significa che gli argomenti che si passano alla funzione possono essere diversi e solo guardando i valori finali che vengono passati alla funzione in fase di esecuzione, viene decisa quale forma della funzione deve essere chiamata. In generale, vediamo che il costruttore di classe è la funzione più sovraccaricata. Tutta questa teoria diventerà molto chiara e ti sarà più facile radicarla nella tua mente con l'aiuto di un esempio.

1. sovraccarico di classe{
2. int a, b;
3. pubblico:
4. int overload (int x){ // primo costruttore di overload()
5. a=x;
6. restituire un;
7. }
8. int overload (int x, int y){ //secondo overload() costruttore
9. a=x;
10. b=y;
11. ritorno a*b;
12. }
13. };
14. int principale (){
15. sovraccarico O1;
16. O1. sovraccarico (20); //prima chiamata al costruttore overload()
17. O1. sovraccarico (20,40); // seconda chiamata al costruttore overload()

Qui in questo esempio, vediamo il sovraccarico in azione. Guarda come vengono chiamati i diversi costruttori a seconda che il valore finale della parentesi dell'oggetto sia uno o due interi.

Affrontiamo poi la definizione di Override. È possibile eseguire l'override solo di quelle funzioni specifiche che vengono ereditate. Sì, l'ereditarietà è un punto chiave per rendere possibile l'override delle funzioni. Se vuoi scrivere una funzione e anche sovrascriverla, in C++ dovrai usare la parola chiave virtual prima della definizione della funzione, e nella classe derivata usando lo stesso nome per la tua funzione, rimuovi semplicemente la parola chiave virtual. Per consolidare la tua comprensione, ecco un esempio:

1. base di classe{
2. pubblico:
3. virtual void funct (){ //funzione virtuale della classe base
4. cout<<“Questa è una classe base funct()”;
5. }
6. };
7. classe derivata1 : base pubblica{
8. pubblico:
9. void funct (){ //funzione virtuale della classe base ridefinita nella classe derivata1
10. cout<<“Questa è una classe derivata1 funct()”;
11. }
12. };
13. int principale ()
14. {
15. base *p, b;
16. derivato1 d1;
17. *p=&b;
18. p-> funzione (); //chiama alla classe base funct().
19. *p=&d1;
20. restituire 0;
21. }

Guarda come viene utilizzata la parola chiave virtual nella classe base e nella classe derivata la stessa definizione di funzione è presente solo la parola chiave virtual è assente.

Alcune differenze evidenti tra polimorfismo ed ereditarietà:

1. L'ereditarietà consiste essenzialmente nel creare una classe e quindi avere altre classi nel programma che ottengono le loro funzionalità dalla classe base già esistente. Tuttavia, il polimorfismo è un'interfaccia e, poiché è un'interfaccia, può assumere forme e forme diverse.
2. L'ereditarietà è una proprietà che appartiene solo alle classi, mentre il polimorfismo si estende a qualsiasi metodo e/o funzione.
3. L'ereditarietà consente alla classe derivata di utilizzare tutte le funzioni e le variabili dichiarate nella classe base senza definirle nuovamente in modo esplicito. Ecco perché diciamo che l'ereditarietà aumenta la riusabilità del codice e riduce la lunghezza del codice, che dovremmo scrivere se l'ereditarietà fosse assente. Considerando che, il polimorfismo consente allo stesso nome di funzione di avere due codici molto diversi. Quindi, in un certo senso, invece di ridurre la lunghezza del codice che dovremmo scrivere, il polimorfismo lo estende ulteriormente.
4. Ci sono molte forme che l'ereditarietà può assumere; puoi essere davvero creativo con l'eredità. Tuttavia, il polimorfismo può essere ottenuto solo con due mezzi, ovvero sovraccarico e sovrascrittura. Puoi ancora impazzire molto mentre usi il polimorfismo, ma sei limitato solo ai due modi per implementarlo nel tuo codice di scrittura.

Deve leggere: deve leggere 47 domande e risposte per interviste OOPS per matricole ed esperti

Polimorfismo vs. ereditarietà: differenziazione tabulare

Nella tabella seguente, troverai una chiara differenza tra polimorfismo ed ereditarietà:

Dai un'occhiata: cos'è il cast di tipi in Java | Capire il casting dei tipi come principiante

Conclusione

È sicuro affermare che sia il polimorfismo che l'ereditarietà sono concetti critici per trasformare qualsiasi programma in realtà. Entrambi sono le basi su cui è stata posta l'idea della programmazione orientata agli oggetti. Ci sono molte differenze tra polimorfismo ed ereditarietà perché servono a due scopi molto diversi.

Il polimorfismo consente al programmatore di scrivere più definizioni di una funzione. Allo stesso tempo, l'ereditarietà consente all'utente di riutilizzare il codice già scritto. Per comprendere e apprezzare appieno i due concetti, si consiglia di leggere ulteriormente su entrambi gli argomenti.

Una cosa che dovresti sempre tenere a mente ogni volta che scrivi codice è che se stai cercando di rifattorizzare il codice che hai già scritto (in pratica la definizione di una classe e usarla di nuovo nel tuo codice per servire un codice simile o diverso scopo), dovresti utilizzare l'ereditarietà. Se stai cercando di ridurre la confusione generale nel tuo codice e vuoi usare lo stesso nome della funzione per svolgere attività simili, dovresti usare il polimorfismo.

Se sei interessato a saperne di più sullo sviluppo di software full-stack, dai un'occhiata al Diploma PG di upGrad e IIIT-B in Sviluppo software full-stack, progettato per i professionisti che lavorano e offre oltre 500 ore di formazione rigorosa, oltre 9 progetti e incarichi, stato di Alumni IIIT-B, progetti pratici pratici e assistenza sul lavoro con le migliori aziende.

Pianifica ora la tua carriera nello sviluppo di software.

Richiedi la certificazione PG collegata al lavoro di upGrad in ingegneria del software