Interface C #

Après avoir défini l'interface, nous les implémenterons maintenant en utilisant la syntaxe suivante:

Cette déclaration se fait en utilisant le nom de l'interface associée à une classe avec un côlon. Ce faisant, tous les membres de l'interface sont déclarés vides une classe qui implémente l'interface doit implémenter toutes les fonctionnalités de l'interface.

Implémentation de l'interface

Exemple 1

Nous déclarerons l'interface avec son nom après la déclaration d'une bibliothèque. À l'intérieur de l'interface, nous ne déclarerons que le nom de la fonction. Le type de retour sera également mentionné. L'interface ne contient que les en-têtes de la fonction Il ne contient pas la description liée à la fonction. Ainsi, nous fermons le corps de l'interface car une seule fonction est définie ici.

Pour que la fonction soit exécutée, nous utilisons une classe comme un simple programme C Sharp est déclaré. Mais pour l'interface, le nom de classe est déclaré le long de l'interface pour s'y associer.

À l'intérieur de la classe, la fonction est écrite. Nous avons simplement utilisé l'instruction Console pour afficher un exemple de phrase.

Dans le programme principal, nous créerons l'objet pour la classe. Cette déclaration se fait dynamiquement avec l'utilisation du «nouveau» mot clé.

TestClass t = new TestClass (); Cet objet sera utilisé pour appeler la fonction déclarée à l'intérieur de la classe après la création de l'objet.

Nous allons maintenant exécuter le code en utilisant un compilateur MCS et mono pour exécuter le fichier avec le .extension exe.

En exécution, vous verrez que la phrase est affichée qui a été déclarée dans l'interface et exécutée dans une fonction distincte accessible par l'objet dans le programme principal.

Exemple 2

Contrairement au premier exemple, nous utiliserons trois méthodes abstraites dans une interface. Ces fonctions sont liées au véhicule. Chaque fonction contient des paramètres pour accepter les valeurs qui ont été envoyées à partir de l'appel de fonction.

Au fur et à mesure que l'interface est déclarée, une classe est implémentée pour utiliser toutes les fonctions à l'intérieur de l'interface. Nous avons utilisé deux classes qui ont deux types de véhicules différents. Chacun implémentant les trois fonctions déclarées à l'intérieur de l'interface.

La première fonction liée à l'équipement attribuera une nouvelle valeur de vitesse à la précédente en acceptant la valeur du paramètre.

La deuxième fonction concerne l'accélération. Ainsi, la valeur envoyée dans le paramètre sera ajoutée à la précédente.

Contrairement à l'accélération, la fonction de freins moins ou diminuera la valeur envoyée de la précédente.

Les valeurs de vitesse et d'équipement seront affichées via la fonction. Il n'est pas déclaré dans l'interface et c'est la fonction statique de la classe.

Une autre classe est conçue pour implémenter l'interface. Toutes les approches de chaque fonction sont les mêmes que nous avons décrites pour la première classe. De même, la fonction d'affichage affichera toutes les données présentes.

Maintenant, il est temps de déclarer le programme principal pour accéder à chaque classe via les objets respectivement. Un échantillon de classe est créé avec le programme principal à l'intérieur. Comme nous avons deux classes pour implémenter l'interface (vélo et vélo), nous créerons des objets séparément pour chaque classe.

Tout d'abord, pour le vélo:

La création d'objets sera effectuée dynamiquement. À travers cet objet, chaque fonction est appelée.

Chaque paramètre de la fonction contient la valeur de type entier dans l'argument. Ensuite, chaque résultat est affiché en appelant la fonction d'affichage.

Après le vélo, l'instance pour le vélo sera créée.

De même, tous les appels de fonction seront effectués via cet objet de vélo.

Maintenant, nous allons exécuter le code pour voir comment il fonctionne. Lors de l'exécution, les valeurs pour l'équipement et la vitesse pour chaque classe sont affichées séparément en fonction de la séquence de la création d'objets et de la fonction appelant l'objet.

Exemple 3

Dans l'exemple précédent, nous n'avons affiché les valeurs que directement dans le programme qui est déclaré dans l'interface. Mais cette fois, nous calculerons la zone d'un polygone en ayant la fonction en deux formes différentes. Examinons la mise en œuvre de l'exemple. Tout d'abord, nous déclarerons l'interface ici.

La fonction ne contient aucun paramètre avec. Cela signifie que toutes les variables sont définies localement à l'intérieur de la fonction. Après l'interface, nous déclarerons un rectangle de classe qui implémentera l'interface Ipolygon. Donc, nous associerons la classe au nom de l'interface.

À l'intérieur de la classe, la fonction calculateaa est utilisé. À l'intérieur de la fonction, toutes les variables sont attribuées avec une valeur. Ces valeurs sont ensuite utilisées dans la formule pour calculer la zone du rectangle.

Après les calculs, la valeur résultante est affichée.

Le même phénomène de mise en œuvre de l'interface Ipolygon est effectué pour la forme carrée. Mais comme tous les côtés du carré sont égaux, nous n'avons pas besoin de longueurs deux faces. Tous les côtés sont de longueur égale, donc la zone sera calculée en multipliant les deux longueurs les unes des autres.

Dans le programme principal, les objets des deux classes sont créés, puis la fonction est appelée via ces objets.

La même approche va pour la classe carrée.

Maintenant, exécutez le code, vous pouvez voir que les deux zones de différentes carrés sont montrées en appelant les fonctions via leurs objets respectivement.

Conclusion

C Interface Sharp est utilisée pour masquer certaines informations spécifiées d'une certaine manière pour afficher uniquement les informations importantes. Tout en définissant l'interface, nous avons vu que seul l'en-tête de la fonction est décrit. La déclaration d'en-tête se compose du type de retour de la fonction, et l'argument qui est présent dans le paramètre. Dans cet article, nous avons mis en œuvre quelques exemples dans le système d'exploitation Linux. Dans chaque exemple, une interface distincte est définie qui contient un seul ou un nombre d'interfaces décrites plus loin dans leurs classes respectives.