La programmation orientée objet est l'un des paradigmes de programmation les plus populaires. En effet, il modélise à la fois les données et les fonctions et vous permet de penser en termes d'objets du monde réel. Les classes sont un aspect fondamental de la programmation orientée objet car elles fournissent le plan dont vous avez besoin pour créer des objets.

C # est un langage de programmation multi-paradigme populaire, qui utilise le paradigme orienté objet. Dans cet article, vous apprendrez à créer et à utiliser des classes en C#.

Création d'une déclaration de classe

En C#, une classe est un type de référence, qui contiendra le nul valeur jusqu'à ce que vous créiez un nouvel objet de la classe. Pour créer une nouvelle classe en C#, vous aurez besoin de plusieurs composants :

  • Un modificateur d'accès.
  • La classer mot-clé.
  • Le nom que vous souhaitez attribuer à la classe.
  • Une paire d'accolades ouvrantes et fermantes (qui entoureront les attributs, les constructeurs et les méthodes de la classe).
instagram viewer 
interne classerClient{ }

Le code ci-dessus crée une nouvelle classe accessible par d'autres classes dans le même assembly (fichier de compilation). C# a exactement six modificateurs d'accès que vous pouvez utiliser pour contrôler les niveaux d'accessibilité de vos classes, variables et méthodes. Les six modificateurs d'accès sont :

  • Publique: chaque classe (quel que soit son assemblage) peut accéder à la classe publique et à ses membres publics (attributs, constructeurs et méthodes).
  • privé: seule la classe privée et ses membres peuvent y accéder.
  • protégé: seules les classes dérivées (classes enfants et petits-enfants) peuvent accéder à la classe protégée.
  • interne: seules les classes d'un même assembly peuvent accéder à la classe interne.
  • interne protégé: seules les classes du même assembly ou une classe dérivée d'un autre assembly peuvent accéder à la classe interne protégée.
  • privé protégé: seules les classes dérivées du même assembly peuvent accéder à la classe privée protégée.

Déclaration et accès aux attributs

Les attributs sont les blocs de construction des classes que vous créez. Ils contiennent des données sensibles et ont généralement un modificateur d'accès privé ou protégé. Par conséquent, pour accéder à ces classes à partir de classes externes, vous devez utiliser des accesseurs et des mutateurs (getters et setters).

C# vous permet de déclarer vos attributs, mutateurs et accesseurs comme suit :

interne classerClient
{
// les attributs
privéentier Numéro d'identification ;
privé nom de chaîne ;
privédouble Total;
// passeurs
PubliqueannulerSetIdNumber(entier Numéro d'identification){ cette.IdNumber = IdNumber; }
PubliqueannulerDéfinirNom(nom de chaîne){ cette.Nom = Nom; }
PubliqueannulerDéfinirTotal(double Total){ cette.Total = Total; }
// getters
PubliqueentierGetIdNumber(){ revenircette.NuméroId; }
Publique chaîne de caractères ObtenirNom(){ revenircette.Nom; }
PubliquedoubleObtenirTotal(){ revenircette.Total; }
}

Autre populaire langages orientés objet utilisez également l'approche ci-dessus. En fait, si vous voulez créer des classes Java, vous devrez utiliser la structure ci-dessus. Cependant, C# dispose désormais d'un moyen plus simple de créer des attributs et des accesseurs. En C#, cette classe a la même fonction que celle ci-dessus :

interne classerClient
{
 public int NuméroIdentifiant { obtenir; Positionner; }
 chaîne publique Nom { obtenir; Positionner; }
 publique double Total { obtenir; Positionner; }
}

La classe ci-dessus contient ce que C# appelle Propriétés, qui est une combinaison d'attributs (champs) et de méthodes. Avec Propriétés, vous pouvez réduire de moitié votre code de déclaration d'attribut, de mutateurs et d'accesseurs.

Déclarer des constructeurs

Les constructeurs sont un autre aspect fondamental d'une classe. Pour créer un objet à partir d'une classe, vous devrez appeler l'un de ses constructeurs. Chaque constructeur a un modificateur d'accès facultatif et le même nom que sa classe. Pour les langages de programmation orientés objet, il existe généralement trois types de constructeurs :

  • Constructeur par défaut: ne prend aucun argument et fournit à chaque attribut une valeur par défaut.
  • Constructeur principal: prend un ou plusieurs arguments (selon le nombre de variables dans la classe).
  • Copier le constructeur: prend un autre constructeur comme argument.

C# a un terme générique pour les constructeurs par défaut et principaux ci-dessus: les constructeurs d'instance. Ce langage de programmation possède également deux autres constructeurs (privé et statique). Cet article se concentre sur les trois constructeurs traditionnels.

Constructeur par défaut

// constructeur par défaut
Publique Client()
{
 NuméroId = 0 ;
 Nom = "inconnue";
 totale = 0 ;
}

Constructeur principal

// constructeur principal
PubliqueClient(entier IdNumber, chaîne Name, chaîne CustomerType, double Total)
{
cette.IdNumber = IdNumber ;
cette.Nom = Nom ;
cette.Total = Total ;
}

Copier le constructeur

// copie le constructeur
Publique Client (Client précédentClient)
{
cette.IdNumber = client précédent. Numéro d'identification ;
cette.Name = client précédent. Nom;
cette.Total = client précédent. Total;
}

Création de méthodes

Les méthodes ne sont pas un composant de classe crucial, mais elles sont utiles. Une classe peut avoir une ou plusieurs méthodes. Une méthode a un modificateur d'accès, un type de retour, un nom et un corps.

// méthode
Publique chaîne DétailsClient()
{
 revenir " IDENTIFIANT: " + Numéro d'identification + " Nom: " + Nom + " Total: " + Total ;
}

Le code ci-dessus renvoie une représentation sous forme de chaîne de l'objet client.

Création d'objets

Après avoir créé une classe complète, l'ayant équipée d'attributs, de constructeurs et d'une méthode, vous pouvez commencer à créer des objets à l'aide des différents constructeurs. Pour créer un objet sans attribut, vous pouvez utiliser le constructeur par défaut :

Client Jean = Nouveau Client();

La ligne de code ci-dessus crée un client par défaut et l'affecte à une variable appelée John. Avec John, vous pouvez accéder à la valeur par défaut de chaque attribut client.

Console.WriteLine(John.Nom);

L'exécution du code ci-dessus imprime ce qui suit dans la console :

Inconnue

Vous pouvez également utiliser le John variable pour accéder à n'importe quelle méthode de la classe client.

Console.WriteLine(John.DétailClient());

L'exécution de la ligne de code ci-dessus imprime la sortie suivante dans la console :

ID: 0 Nom: inconnu Total: 0

Pour créer un objet avec des attributs, vous utiliseriez le constructeur principal :

Client John = nouveau Client (1001, "Jean Doe", 250.20);
Console.WriteLine(John.DétailClient());

L'exécution du code ci-dessus imprime le résultat suivant dans la console :

IDENTIFIANT: 1001 Nom: JohnBicheTotal: 250.2

Pour créer une copie de l'objet ci-dessus, vous pouvez utiliser le constructeur de copie :

Client Johnny = Nouveau Client (Jean);
Console.WriteLine(Johnny.DétailClient());

L'exécution du code ci-dessus imprime le résultat suivant dans la console :

IDENTIFIANT: 1001 Nom: JohnBicheTotal: 250.2

Comme vous pouvez le voir, le constructeur de copie est une copie du constructeur principal. Le constructeur de copie peut également prendre un constructeur par défaut comme argument :

Client Jean = Nouveau Client();
Client Johnny = Nouveau Client (Jean);
Console.WriteLine(Johnny.DétailClient());

L'exécution du code ci-dessus imprime le résultat suivant dans la console :

ID: 0 Nom: inconnu Total: 0

Vous pouvez maintenant créer et utiliser des classes C#

Vous pouvez utiliser le paradigme orienté objet en C# pour définir des classes et créer des objets à partir de celles-ci. Vous pouvez créer des méthodes pour chaque classe qui peuvent ensuite opérer sur les attributs de leurs objets.

Cependant, le paradigme orienté objet n'est pas le seul que vous devez connaître. Les trois principaux paradigmes de programmation sont impératifs, orientés objet et fonctionnels.