Differenza tra ereditarietà e polimorfismo

2019

L'ereditarietà consente, la riusabilità del codice e il polimorfismo è, l'occorrenza di una funzione con forma diversa. La differenza fondamentale tra ereditarietà e polimorfismo è che l'ereditarietà consente di riutilizzare il codice già esistente in un programma, e il polimorfismo fornisce un meccanismo per decidere dinamicamente quale forma di una funzione deve essere invocata.

Grafico comparativo

Base per il confronto	Eredità	Polimorfismo
Di base	L'ereditarietà sta creando una nuova classe utilizzando le proprietà della classe già esistente.	Il polimorfismo è fondamentalmente un'interfaccia comune per forme multiple.
Implementazione	L'ereditarietà è fondamentalmente implementata sulle classi.	Il polimorfismo è fondamentalmente implementato su funzioni / metodi.
Uso	Supportare il concetto di riusabilità in OOP e ridurre la lunghezza del codice.	Consente all'oggetto di decidere quale forma della funzione deve essere invocata quando, in fase di compilazione (sovraccarico) e di esecuzione (sovrascrittura).
Le forme	L'ereditarietà può essere un'eredità singola, ereditarietà multipla, ereditarietà multilivello, ereditarietà gerarchica e ereditarietà ibrida.	Il polimorfismo può essere un polimorfismo del tempo di compilazione (sovraccarico) o un polimorfismo di esecuzione (overriding).
Esempio	Il "tavolo" della classe può ereditare la caratteristica della "mobilia" della classe, in quanto un "tavolo" è un "mobile".	La classe 'study_table' può anche avere la funzione 'set_color ()' e una classe 'Dining_table' può anche avere la funzione 'set_color ()' così, quale forma della funzione set_color () da invocare può essere decisa in entrambi, tempo di compilazione e tempo di esecuzione.

Definizione di ereditarietà:

L'ereditarietà è una delle caratteristiche cruciali di OOP, che sostiene fortemente la "riusabilità". La riusabilità potrebbe essere descritta come la creazione di una nuova classe riutilizzando le proprietà della classe esistente. Nell'ereditarietà esiste una classe base, che è ereditata dalla classe derivata. Quando una classe eredita un'altra classe, i membri della classe base diventano i membri di una classe derivata.

La forma generale di ereditare una classe è la seguente:

 classe derivata-nome-classe: access-specificatore base-nome-classe {// body della classe};

Qui, lo specificatore di accesso fornisce la modalità di accesso (privata, pubblica, protetta) ai membri della classe base alla classe derivata. Se non è presente alcun identificatore di accesso, per impostazione predefinita è considerato "privato". In C ++, se la classe derivata è "struct", lo standard di accesso è "pubblico" per impostazione predefinita.

In C ++, l'ereditarietà può essere ottenuta in cinque forme. Possono essere classificati come: -

Single Inheritance (solo una super classe)
Eredità multipla (diverse superclassi)
Ereditarietà gerarchica (una super classe, molte sottoclassi)
Eredità multipla (derivata da una classe derivata)

In Java, la classe eredita l'altra classe usando la parola chiave "extends". In Java, la classe base viene definita super classe e la classe derivata viene definita sottoclasse. Una sottoclasse non può accedere a quei membri della classe base, che sono dichiarati come "privati". La forma generale che eredita la classe in Java è la seguente.

 class-derivato-nome-classe estende nome-classe-base {// body della classe};

Java non supporta l'ereditarietà dell'ereditarietà multipla, mentre supporta la gerarchia multilivello. In Java, a volte una super classe potrebbe voler nascondere i suoi dettagli di implementazione e rende "privata" parte di quei dati. Come in Java, una sottoclasse non può accedere ai membri privati della superclasse e se una sottoclasse desidera accedere o inizializzare tali membri, allora Java fornisce una soluzione. La sottoclasse può riferire i membri della sua superclasse immediata usando una parola chiave "super". Ricorda, puoi accedere solo ai membri della superclasse immediata.

Il "super" ha due forme generali. Il primo è, usa chiamare il costruttore di super-classe. Il secondo è, per accedere al membro della superclasse che è stato nascosto dal membro della sottoclasse.

 // prima forma di chiamare il costruttore. class supper_class {supper_class (argument_list) {..} // costruttore di super-classe}; class sub_class estende supper_class {sub_class (argument_list) {..} // costruttore di sub_class super (argument_list); // sub_class chiama il costruttore di super-classe}};

 // secondo per 'super' class supper_class {int i; } class sub_class estende supper_class {int i; sub_class (int a, int b) {super.i = a; // 'i' di super-classe i = b; // 'i' della sottoclasse}};

Definizione di Polimorfismo

Il termine polimorfismo significa semplicemente "una funzione, più forme". Il polimorfismo è ottenuto sia in fase di compilazione che in fase di esecuzione. Il polimorfismo del tempo di compilazione si ottiene attraverso il "sovraccarico" mentre il polimorfismo del tempo di esecuzione viene raggiunto attraverso "l'override".

Il polimorfismo consente all'oggetto di decidere "quale forma della funzione deve essere invocata quando" in entrambi, tempo di compilazione e tempo di esecuzione.
Parliamo del primo concetto di sovraccarico. In overloading, definiamo una funzione in classe più di una volta con diversi tipi di dati e il numero di parametri, mentre la funzione da sovraccaricare deve avere lo stesso tipo di ritorno. La maggior parte delle volte le funzioni di overload sono costruttori della classe.

 sovraccarico di classe {int a, b; public: int overload (int x) {// first overload () costruttore a = x; return a; } overload int (int x, int y) {// second overload () costruttore a = x; b = y; restituire un * b; }}; int main () {overload O1; O1.overload (20); // primo overload () chiamata costruttore O1.overload (20, 40); // second overload () chiamata costruttore}

Ora, discutiamo della seconda forma di polimorfismo, cioè di sovrascrittura. Il concetto di override può essere implementato solo per la funzione delle classi che implementano anche il concetto di ereditarietà. In C ++, la funzione da sovrascrivere è preceduta dalla parola chiave "virtuale" nella classe base e ridefinita nella classe derivata con lo stesso prototipo ad eccezione della parola chiave "virtuale".

 class base {public: virtual void funct () {// funzione virtuale di base class cout << "Questa è una funzione di base della classe ()"; }}; class derived1: public base {public: void funct () {// funzione virtuale della classe base ridefinita in cout della classe derivata1 
Differenze chiave tra ereditarietà e polimorfismo 
L'ereditarietà sta creando una classe che trae la sua caratteristica da una classe già esistente. D'altra parte, il polimorfismo è un'interfaccia che può essere definita in più forme.
L'ereditarietà è implementata sulle classi mentre il polimorfismo è implementato su metodi / funzioni.
Poiché l'ereditarietà consente a una classe derivata di utilizzare gli elementi e i metodi definiti nella classe base, la classe derivata non ha bisogno di definire quegli elementi o il metodo di nuovo così, possiamo dire che aumenta la riusabilità del codice e quindi riduce la lunghezza del codice . D'altra parte, il polimorfismo rende possibile che un oggetto decida quale forma del metodo invocare sia in fase di compilazione che in fase di esecuzione.
L'ereditarietà può essere classificata come ereditarietà singola, ereditarietà multipla, ereditarietà multilivello, ereditarietà gerarchica e ereditarietà ibrida. D'altra parte, il polimorfismo è classificato come sovraccarico e prevalente.
Conclusione: 
L'ereditarietà e il polimorfismo sono concetti correlati, poiché il polimorfismo dinamico si applica alle classi che implementano anche il concetto di ereditarietà.