C # Héritage multiple

Les programmeurs peuvent utiliser un héritage multiple pour construire des classes qui intègrent des fonctionnalités de différentes classes et hiérarchies. Il est également utile quand une classe d'enfants veut combiner plusieurs contrats de classe de base. L'héritage multiple n'est pas pris en charge en C # parce que les programmeurs pensent qu'il ajoute une complexité excessive à la langue tout en faisant de ne pas offrir suffisamment d'avantages. Dans le langage de programmation C #, les classes ne peuvent hériter que d'une classe parentale, qui est appelée héritage unique.

Cependant, les interfaces ou une combinaison de classe et d'interface peuvent être utilisées, l'interface (s) étant suivie du nom de classe dans la signature. Cet article montre comment l'héritage multiple peut être réalisé en C # en utilisant différentes approches.

Que sont les interfaces C #

L'héritage multiple n'est pas possible avec les classes, comme nous le savons, mais il est réalisable avec les interfaces lorsque le mot-clé d'interface est utilisé. L'interface ne fournit que les définitions des méthodes, des propriétés, des événements et des indexateurs mais ne donne aucune implémentation de code. Nous ne pouvons pas ajouter de modificateurs d'accès aux membres de l'interface car ils sont implicitement publics et abstraits. Les variables, les membres constants, les constructeurs, les destructeurs et les membres statiques ne sont pas tous autorisés dans une interface.

Importance des interfaces C #

Une interface n'est pas la même chose qu'une classe. Il n'a que des signatures de méthode. Il ne peut pas être créé car il n'a aucune implémentation. Les classes qui en dérivent offrent la logique d'implémentation. Une interface est souvent considérée comme une classe abstraite pure. Cependant, l'utilisation d'une interface plutôt qu'une classe abstraite a l'avantage de soutenir un héritage multiple.

Comment implémenter les interfaces pour C # multiple héritage

Dans la langue C #, il existe de nombreuses approches pour atteindre plusieurs fonctionnalités de succession. Pour connaître les bases de l'utilisation des interfaces pour mettre en œuvre plusieurs héritages, nous avons quelques programmes dans les illustrations suivantes:

Exemple n ° 1: implémentation de l'héritage de la classe multiple

Nous essayons d'implémenter un héritage multiple dans la classe suivante. Initialement, nous essayons de hériter des propriétés de la première classe parent et deuxième classe parent dans la classe infantile. Cependant, le compilateur lancera l'erreur d'exécution car C # ne prend pas en charge directement l'héritage de la classe multiple.

Nous avons inclus les bibliothèques de systèmes au début du code. Après cela, nous avons créé une classe de parents, des «fruits», et avons également défini une méthode de la classe comme «MyFruits». Dans la méthode «MyFruits», nous avons créé une liste comme «MyList» et ajouté différents éléments à la liste en utilisant la méthode ADD. La boucle Foreach est utilisée pour parcourir chaque élément de la liste et attribuer les éléments de la liste à une nouvelle variable, «Éléments». Ensuite, nous avons créé une autre classe parent, «FruitColors», et avons fourni la méthode «couleurs» pour la mise en œuvre. Nous avons également ajouté les éléments de la liste des «couleurs» de classe comme dans la classe précédente.

Maintenant, nous avons une classe d'enfants nommée «FruitDetails», et cette classe d'enfants hérite des deux classes parentales données. En fin de compte, nous avons la classe principale «GetDetails», dans laquelle nous avons une méthode principale, et nous avons créé l'objet de la classe d'enfants «fruitsdetails» dans la méthode principale. Ces objets invoquent ici la méthode de classe parent, ce qui provoquera une ambiguïté dans le code.

Au moment de la compilation, le programme ci-dessus lance une exception que «les classes ne peuvent pas avoir plusieurs classes de base», comme indiqué dans l'image suivante:

Exemple n ° 2: implémentation d'interface pour un héritage multiple

Même si C # n'implémente pas plusieurs héritages avec les classes, nous pouvons l'atteindre en utilisant l'interface. Bien que les interfaces donnent une abstraction complète, ils ne peuvent pas inclure de méthodes spécifiques.

Dans le code précédent, nous avons construit l'interface avec le mot-clé «interface», et l'interface reçoit le nom «Interface1». Nous n'avons créé qu'une méthode «noms» et rien d'autre dans l'interface. Ensuite, nous avons défini une classe parent, «Student», pour laquelle nous avons créé une interface. Dans la classe parent, nous avons fourni l'implémentation des «noms» de la méthode. Dans la méthode «noms», nous avons une liste de tableaux représentés comme une «liste» où nous avons ajouté des noms aléatoires en utilisant la méthode ADD. L'écriture imprime les éléments de la liste. La boucle Foreach est utilisée ici pour parcourir chaque élément de liste à l'aide des «valeurs» variables nouvellement créées.

Ensuite, nous avons créé une autre interface, «Interface2», pour la deuxième classe parent. L'interface n'a que la méthode «sujets». Nous avons notre deuxième classe parent, qui met en œuvre la méthode d'interface «Sujets». Ensuite, nous avons ajouté les éléments de la liste comme dans la première classe parentale. Ensuite, nous avons la classe d'enfants «Détails», qui hérite des deux interfaces spécifiées, «Interface1» et «Interface2». Dans la classe enfant, nous avons créé les objets pour les classes parentales et accédé aux méthodes «noms» et «sujets» directement en utilisant ces objets. Les méthodes «noms» et «sujets» ne sont pas modifiées car les interfaces sont héritées par la classe infantile. À la fin du code, nous avons une classe principale, «démo», pour déclarer les objets de la classe infantile et afficher les résultats.

Voici les résultats que nous avons obtenus à partir de la mise en œuvre de l'héritage de la classe multiple à l'aide d'interfaces:

Exemple # 3: L'implémentation de l'interface hérite d'une autre interface

L'héritage d'une interface à une autre interface est possible en C #. Lorsqu'une classe définit une interface héritée, elle doit implémenter tous les membres déclarés à l'intérieur de la chaîne d'héritage. Notez que si une classe utilise une interface, toutes les méthodes fournies par cette interface doivent être implémentées avec les méthodes d'interface de base. Sinon, une erreur est lancée par le compilateur. Lorsque une interface dérivée et une interface de base sont spécifiées, le nom du membre de l'interface dérivée masque le nom du membre de l'interface de base.

Dans le code précédent, nous avons déclaré une interface «livres» et créé une méthode «book_no» dans l'interface. Notez que nous n'avons défini aucune méthode avec un spécificateur d'accès. Par défaut, les méthodes d'interface sont publiques. Si nous lui attribuons un spécificateur d'accès, le compilateur lance une erreur. Ensuite, nous avons implémenté une autre interface, «Détails», qui hérite de l'interface «livres». Nous avons également une méthode pour cette interface. La classe est créée avec le nom «Auteur», pour lequel nous avons implémenté les interfaces précédentes. La classe n'hésite qu'à l'interface «détails», mais nous avons hérité des méthodes des deux interfaces ici. En fin de compte, nous avons défini une «démo» de classe de pilote, dans laquelle nous avons créé un objet pour la classe «auteur» et avons appelé ces objets pour accéder aux méthodes de classe «Auteur». Ensuite, nous avons transmis les valeurs à ces méthodes.

Ce qui suit est la sortie que nous obtenons de l'héritage de l'interface à une autre interface:

Conclusion

Nous avons discuté du concept d'héritage multiple en C #. Et nous avons appris que en C, un seul héritage unique est autorisé, bien que plusieurs héritage puissent être accomplis en utilisant simultanément une ou plusieurs interfaces. Nous avons une définition claire de l'interface ainsi que son importance. Nous avons également implémenté l'interface dans l'exemple de code pour montrer comment l'interface peut être utilisée dans C #. De plus, l'utilisation d'interfaces est très utile car ils cachent la mise en œuvre d'une classe au monde extérieur. Maintenant, j'espère que vous avez appris l'héritage multiple en C #. Des sujets plus connexes sur C # sont disponibles à Linux Hint.