Tableau de comparaison
| Base de comparaison | Héritage | Polymorphisme |
|---|---|---|
| De base | L'héritage est la création d'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é en POO 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 classe 'table' peut hériter de la caractéristique de la classe 'meubles', 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, quelle forme de la fonction set_color () invoquer peut être décidée à la fois, la compilation et temps d'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 «capacité de réutilisation». 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 d'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 réalisé 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 classe 'super' 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 doit être appelée à quel moment», à la fois à la compilation et à l’exécution.
Discutons 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, alors 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 ()} Discutons maintenant de la seconde forme de polymorphisme, c’est-à-dire la substitution. 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 fonction de la classe de base funct ()"; }}; classe dérivée1: base publique {public: void funct () {// fonction virtuelle de la classe de base redéfinie dans la classe dérivée1 Différences clés entre l'héritage et le polymorphisme
- 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 la longueur du code. . 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é comme surcharge et 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.
