Différence entre l'héritage et le polymorphisme
Contenu
L'héritage permet, le code est réutilisable et le polymorphisme est l'occurrence d'une fonction avec une forme différente. La différence fondamentale entre l'héritage et le polymorphisme réside dans le fait que l'héritage permet de réutiliser le code déjà existant dans un programme, et le polymorphisme fournit un mécanisme permettant de déterminer de manière dynamique la forme d'une fonction à appeler.
- Tableau de comparaison
- Définition
- Différences Clés
- Conclusion
Tableau de comparaison
| Base de comparaison | Héritage | Polymorphisme |
|---|---|---|
| De base | L'héritage consiste à créer une nouvelle classe en utilisant les propriétés de la classe existante. | Le polymorphisme est fondamentalement une interface commune pour la forme multiple. |
| la mise en oeuvre | L'héritage est fondamentalement implémenté sur les classes. | Le polymorphisme est essentiellement implémenté sur les fonctions / méthodes. |
| Utilisation | Soutenir le concept de réutilisabilité dans la programmation orientée objet et réduire la longueur du code. | Permet à l'objet de décider quelle forme de la fonction doit être appelée à la fois lors de la compilation (surcharge) et de l'exécution (substitution). |
| Formes | L'héritage peut être un héritage unique, un héritage multiple, un héritage à plusieurs niveaux, un héritage hiérarchique et un héritage hybride. | Le polymorphisme peut être un polymorphisme lors de la compilation (surcharge) ou un polymorphisme au moment de l'exécution (substitution). |
| Exemple | La table de classe peut hériter de la fonctionnalité des meubles de classe, car une table est un meuble. | La classe study_table peut également avoir la fonction set_color () et une classe Dining_table peut également avoir la fonction set_color (), ainsi la forme de la fonction set_color () à invoquer peut être décidée à la fois, la compilation et l'exécution. |
Définition de l'héritage:
L'héritage est l'une des caractéristiques cruciales de la programmation orientée objet qui soutient fortement la «réutilisabilité». La réutilisabilité peut être décrite comme la création d'une nouvelle classe en réutilisant les propriétés de la classe existante. En héritage, il existe une classe de base, qui est héritée par la classe dérivée. Lorsqu'une classe hérite d'une autre classe, le ou les membres de la classe de base deviennent les membres d'une classe dérivée.
La forme générale d'héritage d'une classe est la suivante:
classe nom-classe-dérivé: spécificateur-accès nom-classe-base {// corps de la classe};
Ici, le spécificateur d'accès fournit le mode d'accès (privé, public, protégé) au (x) membre (s) de la classe de base à la classe dérivée. Si aucun spécificateur d'accès n'est présent, par défaut, il est considéré comme «privé». En C ++, si la classe dérivée est «struct», le spécificateur d'accès est «public» par défaut.
En C ++, l'héritage peut être obtenu sous cinq formes. Ils peuvent être classés comme: -
- Héritage simple (une seule classe)
- Héritage multiple (plusieurs super-classes)
- Héritage hiérarchique (une super classe, plusieurs sous-classes)
- Héritage multiple (dérivé d'une classe dérivée)
En Java, la classe hérite de l’autre classe en utilisant le mot-clé «expand». En Java, la classe de base est appelée une super classe et la classe dérivée est une sous-classe. Une sous-classe ne peut pas accéder aux membres de la classe de base, qui sont déclarés comme «privés». La forme générale héritant de la classe en Java est la suivante.
classe nom-classe-dérivé étend nom-classe-base {// corps de la classe};
Java ne prend pas en charge l'héritage de l'héritage multiple, alors qu'il prend en charge la hiérarchie à plusieurs niveaux. En Java, il peut arriver qu'une super-classe veuille masquer les détails de son implémentation et rend certaines de ses données «privées». Comme en Java, une sous-classe ne peut pas accéder aux membres privés de la superclasse et si une sous-classe souhaite accéder à ces membres ou l'initialiser, Java fournit une solution. La sous-classe peut référencer les membres de sa super-classe immédiate en utilisant un mot clé «super». N'oubliez pas que vous ne pouvez accéder qu'aux membres de la superclasse immédiate.
Le «super» a deux formes générales. Le premier est, il appelait le constructeur de super classe. La seconde consiste à accéder au membre de la superclasse masqué par le membre de la sous-classe.
// première forme d'appel du constructeur. class supper_class {supper_class (liste_arguments) {..} // constructeur de la super classe}; class sub_class étend supper_class {sous_class (liste_argument) {..} // constructeur de la sous_classe super (liste_argument); // sub_class appelle le constructeur de la super classe}};
// seconde pour la super classe supper_class {int i; } class sub_class étend supper_class {int i; sous-classe (int a, int b) {super.i = a; // i de super classe i = b; // i de la sous-classe}};
Définition du polymorphisme
Le terme polymorphisme signifie simplement "une fonction, plusieurs formes". Le polymorphisme est atteint à la fois lors de la compilation et de l'exécution. Le polymorphisme au moment de la compilation est obtenu par «surcharge», tandis que le polymorphisme au moment de l'exécution est obtenu par «écrasement».
Le polymorphisme permet à l'objet de décider «quelle forme de la fonction à appeler quand» à la fois, à la compilation et à l'exécution.
Parlons maintenant du premier concept de surcharge. En surcharge, nous définissons plusieurs fois une fonction dans la classe avec un type de données et un nombre de paramètres différents, tandis que la fonction à surcharger doit avoir le même type de retour. La plupart du temps, les fonctions surchargées sont des constructeurs de la classe.
surcharge de classe {int a, b; public: int surcharge (int x) {// premier constructeur overload () a = x; retourne un; } int surcharge (int x, int y) {// constructeur deuxième surcharge () a = x; b = y; retourne a * b; }}; int main () {surcharge O1; O1. overload (20); // premier constructeur appel de surcharge () O1.overload (20,40); // deuxième appel du constructeur overload ()}
Parlons maintenant de la deuxième forme de polymorphisme, c’est-à-dire la priorité. Le concept de priorité ne peut être appliqué qu'à la fonction des classes qui implémentent également le concept d'héritage. En C ++, la fonction à remplacer est précédée du mot clé "virtual" dans la classe de base et redéfinie dans la classe dérivée avec le même prototype, à l'exception du mot clé "virtual".
class base {public: virtual void funct () {// fonction virtuelle de la classe de base cout << "Ceci est une classe de base funct ()"; }}; class dérivée1: base publique {public: void funct () {// fonction virtuelle de la classe de base redéfinie dans la classe dérivée1 << - Ceci est une classe dérivée1 funct () "; }}; int main () {base * p, b; dérivé1 d1; * p = & b; p-> funct (); // appel à la classe de base funct (). * p = & d1; retourne 0; }
- L'héritage est la création d'une classe dont la fonctionnalité dérive d'une classe existante. D'autre part, le polymorphisme est une interface qui peut être définie sous plusieurs formes.
- L'héritage est implémenté sur les classes alors que le polymorphisme est implémenté sur les méthodes / fonctions.
- Comme l'héritage permet à une classe dérivée d'utiliser les éléments et les méthodes définis dans la classe de base, la classe dérivée n'a pas besoin de définir ces éléments ou cette méthode à nouveau. Nous pouvons donc affirmer qu'elle augmente la réutilisabilité du code et réduit donc sa longueur. . D'autre part, le polymorphisme permet à un objet de décider de la forme de la méthode à invoquer à la fois lors de la compilation et de l'exécution.
- L'héritage peut être classé en héritage simple, en héritage multiple, en héritage à plusieurs niveaux, en héritage hiérarchique et en héritage hybride. Par ailleurs, le polymorphisme est classé en surcharge et en priorité.
Conclusion:
L'héritage et le polymorphisme sont des concepts interdépendants, car le polymorphisme dynamique s'applique aux classes qui implémentent également le concept d'héritage.
