Differenza tra ereditarietà e polimorfismo
Contenuto
L'ereditarietà consente, riutilizzabilità del codice e il polimorfismo è, il verificarsi di una funzione con forma diversa. La differenza fondamentale tra eredità 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.
- Tabella di comparazione
- Definizione
- Differenze chiave
- Conclusione
Tabella di comparazione
| Base per il confronto | Eredità | Polimorfismo |
|---|---|---|
| Di base | L'ereditarietà sta creando una nuova classe usando le proprietà della classe già esistente. | Il polimorfismo è sostanzialmente un'interfaccia comune per forme multiple. |
| Implementazione | L'ereditarietà è sostanzialmente implementata sulle classi. | Il polimorfismo è sostanzialmente implementato su funzione / 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 in fase di esecuzione (sostituzione). |
| Le forme | L'ereditarietà può essere una singola eredità, eredità multipla, eredità multilivello, eredità gerarchica ed eredità ibrida. | Il polimorfismo può essere un polimorfismo in fase di compilazione (sovraccarico) o polimorfismo di runtime (scavalcamento). |
| Esempio | Il tavolo di classe può ereditare la caratteristica dei mobili di classe, poiché 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 () quindi, quale forma della funzione set_color () da invocare può essere decisa sia in fase di compilazione che in fase di esecuzione. |
Definizione di ereditarietà:
L'ereditarietà è una delle caratteristiche cruciali di OOP, che supportano fortemente la "riusabilità". La riusabilità potrebbe essere descritta come la creazione di una nuova classe riutilizzando le proprietà della classe esistente. In eredità, esiste una classe base, che viene ereditata dalla classe derivata. Quando una classe eredita qualsiasi altra classe, i membri della classe base diventano i membri di una classe derivata.
La forma generale di ereditare una classe è la seguente:
class derivato-class-name: specificatore di accesso base-class-name {// body della classe};
Qui, l'identificatore 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 viene considerato "privato". In C ++, se la classe derivata è "struct", lo specificatore di accesso è "pubblico" per impostazione predefinita.
In C ++, l'ereditarietà può essere ottenuta in cinque forme. Possono essere classificati come: -
- Eredità singola (solo una superclasse)
- Ereditarietà multipla (diverse superclassi)
- Hierarchical Inheritance (una superclasse, molte sottoclassi)
- Ereditarietà 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 superclasse 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-class-name estende la base-class-name {// 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 dettagli dell'implementazione e rendere una parte di tali dati "privata". Come in Java, una sottoclasse non può accedere ai membri privati della superclasse e se una sottoclasse desidera accedere o inizializzare tali membri, Java fornisce una soluzione. La sottoclasse può fare riferimento ai 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 per chiamare il costruttore di super class. Il secondo è, per accedere al membro della superclasse che è stato nascosto dal membro della sottoclasse.
// prima forma di chiamata al costruttore. class supper_class {supper_class (argomento_elenco) {..} // costruttore di super classe}; class sub_class estende supper_class {sub_class (argomento_elenco) {..} // costruttore di sub_classe super (argomento_elenco); // sub_class chiama il costruttore di super class}};
// second for for 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 superclasse i = b; // i della sottoclasse}};
Definizione di polimorfismo
Il termine polimorfismo significa semplicemente "una funzione, più forme". Il polimorfismo si ottiene 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 si ottiene 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.
Discutiamo il primo concetto di sovraccarico. Nel sovraccarico, 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. Il più delle volte le funzioni del sovraccarico sono costruttori della classe.
sovraccarico di classe {int a, b; public: int overload (int x) {// primo costruttore overload () a = x; restituire a; } int overload (int x, int y) {// secondo costruttore overload () a = x; b = y; ritorna a * b; }}; int main () {sovraccarico O1; O1.overload (20); // prima chiamata del costruttore overload () O1.overload (20,40); // seconda chiamata del costruttore overload ()}
Ora, parliamo della seconda forma di polimorfismo, vale a dire la sostituzione. Il concetto di override può essere implementato solo per la funzione delle classi che implementano anche il concetto di eredità. In C ++, la funzione da sovrascrivere è preceduta dalla parola chiave "virtuale" nella classe base e ridefinita nella classe derivata con lo stesso prototipo tranne la parola chiave "virtuale".
class base {public: virtual void funct () {// funzione virtuale della classe di base cout << "Questa è una classe di base funct ()"; }}; class deriv1: public base {public: void funct () {// funzione virtuale della classe base ridefinita nella classe deriv1 cout << "Questa è una classe derivata funct ()"; }}; int main () {base * p, b; derivato1 d1; * P = & b; p-> funz (); // chiama alla classe base funct (). * P = & d1; ritorna 0; }
- L'ereditarietà sta creando una classe che deriva 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 tali elementi o di ripetere il metodo, quindi possiamo dire che aumenta la riusabilità del codice e, quindi, riduce la lunghezza del codice . D'altra parte, il polimorfismo consente a un oggetto di decidere quale forma del metodo vuole invocare sia in fase di compilazione che in fase di esecuzione.
- L'eredità può essere classificata come eredità singola, eredità multipla, eredità multilivello, eredità gerarchica ed eredità ibrida. D'altra parte, il polimorfismo è classificato come sovraccarico e prevalente.
Conclusione:
L'ereditarietà e il polimorfismo sono concetti correlati, in quanto il polimorfismo dinamico si applica alle classi che implementano anche il concetto di eredità.
