Menu

Concepts OOPS en C #: didacticiel sur le concept de programmation orientée objet

  • Principal
  • Autre
  • Concepts OOPS en C #: didacticiel sur le concept de programmation orientée objet

oops concepts c object oriented programming concept tutorial

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel explique les concepts OOPS en C #. Vous pouvez en savoir plus sur les principes de programmation orientée objet tels que le polymorphisme, l'encapsulation, l'héritage et l'abstraction:

La programmation orientée objet est un modèle de programmation qui fonctionne sur un principe qui tourne autour d'objets plutôt que d'action ou de logique. Il permet aux utilisateurs de créer des objets en fonction de l'exigence, puis de créer des méthodes pour opérer sur ces objets.

Travailler sur ces objets pour obtenir le résultat souhaité est le but de la programmation orientée objet.

=> Découvrez toute la série de didacticiels de formation C # ici

Concepts OOPS en C #

Révisons certains des concepts que nous avons appris dans nos précédents tutoriels !!

Espace de noms

Un espace de noms en C # est une collection de classes. Il fournit une structure pour garder un nom de classe séparé d'un autre nom de classe en les déclarant dans un espace de noms différent. Pour que les classes portant le même nom ne soient pas en conflit les unes avec les autres.

Classer

Une classe est un plan d'un type de données. C'est en fait une collection d'objets. Il contient des objets et la définition de l'opération qui doit être effectuée sur cet objet.

Objets

Les objets sont les instances de la classe.

Dans nos didacticiels précédents, nous avons déjà appris en détail les classes et les objets.

Ce que vous apprendrez:

Concepts OOPS en C #

La programmation orientée objet offre plusieurs avantages par rapport aux autres modèles de programmation tels que:

  1. L'approche modulaire précise et claire des programmes facilite la compréhension et la maintenance.
  2. Les classes et objets créés dans le projet peuvent être utilisés dans tout le projet.
  3. L'approche modulaire permet à différents modules d'exister indépendamment, permettant ainsi à plusieurs développeurs différents de travailler ensemble sur différents modules.

Dans ce didacticiel, nous nous concentrerons davantage sur d'autres concepts OOPS majeurs:

  1. Encapsulation
  2. Polymorphisme
  3. Héritage
  4. Abstraction

Encapsulation

L'encapsulation est un concept de programmation orienté objet qui permet aux programmeurs d'encapsuler des données et des extraits de code dans une enceinte. En utilisant le programme d'encapsulation, vous pouvez masquer les membres d'une classe d'une autre classe. C'est comme encercler un élément logique dans un package. Il ne permet que les informations pertinentes disponibles et visibles à l'extérieur et cela aussi uniquement à des membres spécifiques.

L'encapsulation est implémentée à l'aide de spécificateurs d'accès. Access Specifier est utilisé pour définir la visibilité et l'accessibilité du membre de classe en C #.

C # contient les spécificateurs d'accès suivants.

comparer deux fichiers sous linux et trouver les différences
  • Publique
  • Privé
  • Protégé
  • Interne

Les spécificateurs d'accès définissent la visibilité de la classe et ses valeurs. Il vous permet de rendre les données visibles pour une partie particulière du code et de les masquer d'une autre partie. La visibilité la plus couramment utilisée est publique et privée.

Jetons un œil à eux.

Publique: Le mot clé public permet à ses membres d'être visibles de n'importe où dans le projet. Ce spécificateur d'accès a la moindre restriction de visibilité.

Privé: Les membres privés ne sont accessibles que par le membre de la même classe. Cela a une des visibilité les plus restreintes.

Protégé: L'accessibilité protégée permet d'accéder au membre depuis la classe et depuis une autre classe qui hérite de cette classe.

Interne: Interne fournit l'accessibilité depuis l'intérieur du projet. Une autre accessibilité interne similaire est la protection interne. Cela permet la même chose que l'interne et la seule différence est qu'une classe enfant peut hériter de cette classe et atteindre ses membres même à partir d'un autre projet.

Polymorphisme

Le polymorphisme est dérivé du dictionnaire grec, cela signifie un avec de nombreuses formes. Poly signifie beaucoup et Morph signifie formes. Il permet à la classe en C # d'avoir plusieurs implémentations avec le même nom.

Le polymorphisme est essentiellement divisé en deux parties:

  1. Polymorphisme à la compilation
  2. Polymorphisme d'exécution

# 1) Polymorphisme statique ou à la compilation

Le polymorphisme à la compilation est également connu sous le nom de polymorphisme statique. La surcharge de méthode est l'un des moyens par lesquels le polymorphisme à la compilation est obtenu. Il est connu sous le nom de polymorphisme au moment de la compilation car la décision d'appel de la méthode est prise au moment de la compilation.

Ceci est réalisé en gardant le nom de la méthode identique mais en passant différents ensembles de paramètres. Lors de la surcharge de méthode, le système vérifie d'abord le paramètre utilisé et en fonction de l'ensemble de paramètres, il décide d'appeler la méthode appropriée.

Exemple:

class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i+j) ); } void print(string a, string b) { Console.WriteLine('Printing String: ' , (a+b)); } static void Main(string() args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello','World'); Console.ReadKey(); } }

Dans l'exemple ci-dessus, nous avons appelé la même méthode «imprimer» deux fois en utilisant des paramètres différents. Dans un premier temps, nous passons deux entiers comme paramètres, puis nous avons passé deux chaînes comme paramètres. Il existe deux méthodes «d'impression» portant le même nom.

Quand nous passons un paramètre avec le système d'entiers, il recherchera la méthode nommée «print» qui accepte deux paramètres entiers et il l'exécutera en ignorant les autres méthodes du même nom.

Dans la deuxième partie, nous avons passé le paramètre string. Là encore, le système recherchera la méthode qui accepte deux paramètres de chaîne. Par conséquent, en fonction des paramètres passés, la première méthode ajoutera deux entiers et la suivante concaténera deux chaînes.

# 2) Polymorphisme dynamique ou polymorphisme d'exécution

Le polymorphisme d'exécution ou le polymorphisme dynamique se produit lorsque le nom et la signature de méthode ont le même nom et les mêmes paramètres. Le remplacement de méthode est un exemple de polymorphisme dynamique. Il permet à l'utilisateur de créer une classe abstraite avec une implémentation d'interface partielle.

Le remplacement de méthode est obtenu à l'aide de l'héritage. Pour obtenir une méthode, le remplacement de la classe de base et de la classe dérivée doit avoir le même nom et le même paramètre. Pendant la compilation, le compilateur n’est pas capable de reconnaître la méthode de remplacement, par conséquent, il ne renvoie aucune erreur. La décision d'exécuter une méthode est prise pendant l'exécution.

Exemple:

class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public void print() { Console.WriteLine('Printing from class Execute'); } public static void Main(string() args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }

Si nous exécutons le programme ci-dessus, nous obtiendrons la sortie suivante:

Printing from class Execute

Même si la classe Execute a hérité de toutes les méthodes de la classe Program mais lorsque nous avons appelé la méthode print qui est présente dans les deux classes, la méthode présente dans la classe enfant remplacera la méthode de la classe parent.

Le polymorphisme dynamique est utilisé pour implémenter l'abstraction. Il permet à l'utilisateur de créer une classe abstraite qui est utilisée pour fournir une implémentation pour une interface lorsqu'elle est héritée par une classe dérivée. La classe abstraite peut contenir les noms / signatures des méthodes et la classe dérivée peut avoir une définition plus spécialisée pour la méthode.

Héritage

L'héritage est une partie importante du concept OOPS. En héritage, nous définissons les classes parent et enfant. La classe enfant peut hériter de toutes les méthodes, objets et propriétés de la classe parent. Une classe enfant peut également avoir ses propres méthodes et une implémentation spécifique.

La classe parente est également appelée classe de base et la classe enfant qui hérite de la classe de base est également appelée classe dérivée.

Exemple:

class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public static void Main(string() args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }

Ici, nous avons une classe nommée comme un programme qui a une méthode. Nous avons une autre classe Execute qui hérite de la classe Program. La classe Execute est la classe dérivée et le programme de classe est appelé classe de base.

Maintenant, au lieu de créer une instance d'objet pour le programme de classe, nous avons créé une instance d'objet pour la classe Execute. En utilisant cette instance, nous pouvons accéder à la méthode d'impression à partir de la classe de base.

Ainsi, la sortie du code ci-dessus sera:

Printing from class Program

La classe dérivée n'hérite pas seulement des méthodes, elle hérite également de presque tous les membres de la classe tels que les champs, les propriétés, etc. en fonction de la visibilité. L'héritage en C # ne permet pas l'utilisation de plusieurs héritages, c'est-à-dire qu'une classe ne peut pas hériter de plusieurs classes différentes, cependant, une classe peut hériter d'une autre classe qui peut hériter d'une classe différente.

Abstraction

L'abstraction est l'un des principes majeurs de la programmation orientée objet. L'abstraction permet au programmeur d'afficher uniquement les détails nécessaires au monde tout en cachant les autres. L'abstraction est réalisée en C # en utilisant la classe et l'interface Abstract.

Une classe peut être déclarée comme classe abstraite en utilisant le mot-clé «Abstract». La classe Abstract en C # est toujours la classe de base dans la hiérarchie. Ce qui les différencie de l'autre classe, c'est qu'ils ne peuvent pas être instanciés. Une classe abstraite C # doit être héritée.

Exemple:

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public void Describe() { return 'Description of the car'; } } class Hyundai : Car { }

Le résultat de ce qui suit est:

Description of the car

Si vous le comparez avec nos exemples précédents lors de l'héritage ou du polymorphisme dynamique, vous trouverez les similitudes. La différence la plus reconnaissable est l'utilisation d'un mot-clé abstrait avant la classe Car. Au cas où vous voudriez remplacer cela ou fournir votre propre implémentation similaire à ce que nous avons fait dans le polymorphisme dynamique. Ensuite, vous pouvez y parvenir de la manière suivante.

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }

Donc, si vous exécutez ce code maintenant, il donnera la sortie suivante:

Description of the car is now Hyundai

La méthode de classe dérivée remplace la méthode de classe de base. De cette manière, vous pouvez créer une classe dérivée différente telle que Ferrari, Porsche, BMW, etc. avec leurs propres méthodes d'implémentation.

Si vous regardez de près, vous pouvez voir que notre méthode de description dans la classe abstraite ne contient aucune implémentation.

Alors, pourquoi définissons-nous des méthodes vides?

En effet, une classe abstraite fournit une signature des méthodes et oblige les sous-classes à créer une implémentation pour toutes ces méthodes. Cela permet le partage de la classe de base mais en même temps, il garde également un contrôle sur l'implémentation de la méthode de la classe dérivée.

Interface

En C #, l'interface est le plan directeur d'une classe. L'interface est similaire à une classe abstraite et est utilisée pour obtenir une abstraction à cent pour cent. Toutes les méthodes décrites dans l'interface sont abstraites par défaut. Il n’a pas de corps de méthode et ne peut pas être instancié.

L'interface est principalement utilisée pour obtenir un héritage multiple et une abstraction complète. Toute la signature de méthode déclarée à l'intérieur de l'interface doit être fournie avec l'implémentation de la classe ou de la structure qui l'implémente.

Exemple:

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } interface Car { string Describe(); } class Hyundai : Car { public string Describe() { return 'Description of the car is now Hyundai'; } }

La sortie du code ci-dessus sera:

Description of the car is now Hyundai

Ici, nous avons créé une interface Car. Comme l'interface ne peut avoir aucune définition de méthode, nous venons de fournir le nom de la méthode et le type de retour dans l'interface. Nous avons ensuite implémenté l'interface Car sur une autre classe Hyundai. Dans la classe implémentée, nous avons fourni la définition des méthodes définies dans l'interface.

Conclusion

Dans le concept de programmation orientée objet, chaque partie du programme est traitée comme un objet. La classe est une collection de types d'éléments similaires et un objet est l'instance de la classe.

L'encapsulation en C # permet à l'utilisateur d'établir la visibilité de la classe et de ses membres. Le polymorphisme permet aux méthodes d'avoir le même nom mais avec des paramètres différents dans la même classe ou avec le même paramètre dans une classe différente.

L'héritage se produit lorsqu'une classe enfant également connue sous le nom de classe dérivée hérite de toutes les propriétés, y compris les méthodes, les objets, les champs, etc. de la classe parente, également appelée classe de base. L'abstraction permet au programme d'afficher uniquement la signature tout en masquant les détails de l'implémentation.

Programme consolidé

class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i + j)); } void print(string a, string b) { Console.WriteLine('Printing String '+ a + b); } static void Main(string() args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello', 'World'); Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }

=> Découvrez toute la série de didacticiels de formation C # ici

lecture recommandée

^