Diferència entre herència i polimorfisme
Content
L’herència permet, la reutilització del codi i el polimorfisme és l’aparició d’una funció amb forma diferent. La diferència bàsica entre herència i polimorfisme és que l’herència permet que el codi ja existent es pugui tornar a reutilitzar en un programa i el polimorfisme proporciona un mecanisme per decidir dinàmicament quina forma d’una funció s’ha d’invocar.
- Gràfic de comparació
- Definició
- Diferències claus
- Conclusió
Gràfic de comparació
| Bases per a la comparació | Herència | Polimorfisme |
|---|---|---|
| Bàsic | Herència està creant una nova classe utilitzant les propietats de la classe ja existent. | El polimorfisme és bàsicament una interfície comuna per a formes múltiples. |
| Implementació | L’herència és bàsicament implementada a les classes. | El polimorfisme s’implementa bàsicament sobre funció / mètodes. |
| Utilitzeu | Donat suport al concepte de reutilitzabilitat en OOP i redueix la longitud del codi. | Permet a l'objecte decidir quina forma de la funció ha de ser invocada quan, tant en compilar el temps (sobrecàrrega) com en el temps d'execució (sobrevaloració). |
| Formes | La herència pot ser una herència única, herència múltiple, herència multinivell, herència jeràrquica i herència híbrida. | El polimorfisme pot ser un polimorfisme en temps de compilació (sobrecàrrega) o un polimorfisme en temps d'execució (major). |
| Exemple | La taula de classe pot heretar la característica dels mobles de la classe, ja que la taula és un moble. | La classe Study_table també pot tenir la funció set_color () i una classe Dining_table també pot tenir la funció set_color () de manera que, quina forma de la funció set_color () a invocar es pot decidir a la vegada, compilar el temps i el temps d'execució. |
Definició d'herència:
L'herència és una de les característiques crucials de l'OOP, que suporta fermament la "reutilització". Es pot descriure la reutilitzabilitat com a creació d'una nova classe mitjançant la reutilització de les propietats de la classe existent. En herència, hi ha una classe base, que és heretada per la classe derivada. Quan una classe hereta qualsevol altra classe, el membre de la classe base es converteix en el membre (s) d'una classe derivada.
La forma general d’heretar una classe és la següent:
class derivat-classe-nom: accés-especificador base-classe-nom {// cos de la classe};
Aquí, l’especificador d’accés proporciona el mode d’accés (privat, públic, protegit) als membres (es) de la classe base a la classe derivada. Si per defecte no hi ha cap especificador d'accés, es considera "privat". En C ++, si la classe derivada és "struct", l'especificador d'accés és "públic" per defecte.
A C ++, l’herència es pot aconseguir de cinc formes. Es poden classificar com: -
- Herència única (només una super classe)
- Herència múltiple (diverses superclasses)
- Herència jeràrquica (una classe super, moltes subclasses)
- Herència múltiple (derivada d’una classe derivada)
A Java, la classe hereta l'altra classe mitjançant la paraula clau "estén". A Java, la classe base es denomina classe super, i la classe derivada es coneix com a subclasse. Una subclasse no pot accedir a aquells membres de la classe base que estan declarats com a "privats". El formulari general heretant la classe a Java és el següent.
class derivat-classe-nom s'estén base-classe-nom {// cos de la classe};
Java no admet l’herència de l’herència múltiple, mentre que és compatible amb la jerarquia de diversos nivells. De vegades, a Java una classe super pot voler ocultar els detalls de la seva implementació i fa que algunes de les dades siguin “privades”. Com en Java, una subclasse no pot accedir als membres privats de la superclasse i si una subclasse vol accedir o inicialitzar aquests membres, Java ja proporciona una solució. La subclasse pot referir els membres de la seva superclasse immediata mitjançant la paraula clau "super". Recordeu que només podeu accedir als membres de la superclasse immediata.
El "super" té dues formes generals. El primer és que serveix per trucar al constructor de super classe. El segon és accedir al membre de la superclasse que ha estat ocult pel membre de la subclasse.
// primera forma de trucar al constructor. class supper_class {supper_class (argument_list) {..} // constructor de super classe}; classe sub_class s'estén supper_class {sub_class (argument_list) {..} // constructor de sub_class super (argument_list); // sub_classe truca al constructor de super classe}};
// segon per a classe supper_class {int i; } classe sub_class s'estén supper_class {int i; sub_classe (int a, int b) {super.i = a; // i de super classe i = b; // i de sub classe}};
Definició de polimorfisme
El terme polimorfisme significa simplement "una funció i diverses formes". El polimorfisme s'aconsegueix tant en compilar el temps com en el temps d'execució. El polimorfisme del temps de compilació s'aconsegueix mitjançant la "sobrecàrrega", mentre que, el polimorfisme en temps d'execució s'aconsegueix mitjançant "superació".
El polimorfisme permet a l’objecte decidir “quina forma de la funció que s’ha d’invocar quan”, compila el temps i el temps d’execució.
Parlem del primer concepte de sobrecàrrega. En la sobrecàrrega, definim una funció a la classe més d'una vegada amb diferents, tipus de dades i el nombre de paràmetres, mentre que la funció que s'ha de sobrecarregar ha de tenir el mateix tipus de retorn. La majoria de vegades les funcions per a la sobrecàrrega són constructors de la classe.
sobrecàrrega de classe {int a, b; public: int sobrecàrrega (int x) {// constructor de primera sobrecàrrega () a = x; tornar a; } int sobrecàrrega (int x, int y) {// constructor de segona sobrecàrrega () a = x; b = y; retorna a * b; }}; int principal () {sobrecàrrega O1; Descàrrega extra (20); // trucada del primer fabricant de sobrecàrrega () trucada O1.overload (20,40); // trucada al constructor de segona sobrecàrrega ()}
Ara, anem a discutir la segona forma de polimorfisme, és a dir, sobreposada. El concepte de sobreposició només es pot implementar en funció de les classes que també implementen el concepte d'herència. A C ++, la funció que es pot substituir està precedida de la paraula clau "virtual" de la classe base i es redefineix a la classe derivada amb el mateix prototip excepte la paraula clau "virtual".
class base {public: virtual void function () {// funció virtual de base class cout << "Aquesta és una funció de classes base ()"; }}; class deriv1: public base {public: void function () {// funció virtual de la classe base redefinida a la classe derivada cout << "Aquesta és una classe derivada de les funcions ()"; }}; int principal () {base * p, b; derivat1 d1; * p = & b; p-> funct (); // trucar a la funció de classe base (). * p = & d1; retornar 0; }
- Herència està creant una classe que deriva la seva característica d’una classe ja existent. D'altra banda, el polimorfisme és una interfície que es pot definir en diverses formes.
- L'herència és implementada en les classes, mentre que, el polimorfisme s'implementa en mètodes / funcions.
- Com que l'herència permet a una classe derivada utilitzar els elements i mètodes definits a la classe base, la classe derivada no necessita definir aquests elements ni el mètode de nou, així que podem dir que augmenta la reutilització del codi i, per tant, redueix la longitud del codi. . D'altra banda, el polimorfisme fa que un objecte pugui decidir quina forma del mètode vol invocar tant en compilar el temps com en el temps d'execució.
- L’herència es pot classificar com a herència única, herència múltiple, herència multinivell, herència jeràrquica i herència híbrida. D'altra banda, el polimorfisme es classifica com a sobrecàrrega i sobrecàrrega.
Conclusió:
L'herència i el polimorfisme són conceptes interrelacionats, ja que el polimorfisme dinàmic s'aplica a les classes que també implementen el concepte d'herència.
