Menu

Concepts C #: Constructeur, Destructeur, Classe statique, Struct & Enum

  • Principal
  • Autre
  • Concepts C #: Constructeur, Destructeur, Classe statique, Struct & Enum

c concepts constructor

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel explique certains des concepts importants de la programmation C # tels que le constructeur, les destructeurs, la classe statique, les structures et les énumérations:

Dans l'un de nos précédents didacticiels sur les objets et les classes, nous avons appris ce que sont une classe et un objet.

Un objet est similaire à un objet du monde réel et une classe est une collection logique de types d'objets similaires. C'est l'un des types les plus fondamentaux présents en C #. Dans ce didacticiel, nous allons approfondir les autres concepts C # associés.

=> Explorez la série complète de formations C # ici

Constructeur C # et autres concepts

Dans ce didacticiel, nous allons découvrir certains aspects importants des cours et comment les utiliser dans nos programmes. Nous allons essayer de créer des programmes C # simples basés sur les concepts que nous avons appris dans nos tutoriels précédents.

Ce que vous apprendrez:

Qu'est-ce qu'un constructeur en C #?

Le constructeur est un type spécial de méthode dans le langage de programmation C # qui est appelé ou invoqué automatiquement lorsqu'un objet de la classe donnée est créé.

Sa fonction principale est d'initialiser les données membres de l'objet nouvellement créé. L'une des caractéristiques les plus distinctives du constructeur est son nom. Il porte le même nom que la classe.

Les constructeurs sont essentiellement de deux types:

  1. Défaut
  2. Paramétré

Constructeur par défaut C #

Comme son nom l'indique, le constructeur par défaut est le constructeur de base d'une classe. Il n'a aucun argument et est directement invoqué au moment de la création de l'objet.

public class Program { public Program(){ Console.WriteLine('Constructor has been invoked'); } public static void Main(string() args) { Program p = new Program(); } }

La sortie du programme suivant sera:

Le constructeur a été appelé

Explication

Nous avons défini un constructeur «Program» à l'intérieur de la classe «Program». Désormais, lorsque nous initialisons la classe dans la méthode main, le constructeur est appelé automatiquement.

Par conséquent, quel que soit l'extrait de code que nous avons conservé dans le constructeur, il sera appelé. Ici, nous avons imprimé un message «Le constructeur a été appelé» dans les accolades du constructeur, donc lorsque nous initialisons la classe, le constructeur par défaut sera initialisé et le message sera affiché en sortie.

Constructeur paramétré

Comme son nom l'indique, les constructeurs paramétrés sont le constructeur avec des paramètres. Ces constructeurs sont utilisés pour transmettre différentes valeurs aux objets.

public class Details { public Details(int a, int b){ int c = a+b; Console.WriteLine('The sum is: '+ c); } } public class Program { public static void Main(string() args) { Details d = new Details(2, 3); } }

La sortie du programme suivant sera:

différence entre les tests agiles et en cascade

La somme est: 5

Explication

Dans notre exemple précédent avec le constructeur par défaut, nous avons notre méthode main dans la même classe. Dans cet exemple, nous avons la méthode principale dans une classe différente.

Nous avons une classe nommée «Details» qui contient un constructeur paramétré acceptant deux valeurs entières. Dans le constructeur, nous imprimons la somme des entiers. Nous avons une autre classe appelée «Program» qui contient notre méthode principale. Dans la méthode main, nous avons initialisé la classe «Details».

Comme expliqué précédemment, lorsqu'une classe est initialisée, ses constructeurs sont appelés automatiquement. Ainsi, dans ce cas, notre méthode constructeur «Détails» a été invoquée et lorsque nous avons passé le paramètre lors de l'initialisation, elle imprime la sortie.

Destructeurs en C #

Les destructeurs sont juste l'opposé des constructeurs. C'est une méthode spéciale de la classe qui est appelée lorsqu'un objet de classe sort de la portée. Semblable à un constructeur, un nom de destructeur est également exactement le même que celui du nom de classe mais avec le préfixe «~» (tilde).

Destructor n'accepte aucun paramètre et ne renvoie aucune valeur. Destructor détruit les objets de classe, il est donc principalement utilisé pour libérer de la mémoire après l'exécution du programme. Une autre chose importante à noter à propos du destructeur est qu'il ne peut être ni surchargé ni hérité.

Exemple de destructeurs:

public class Program { public Program(){ Console.WriteLine('Constructor has been invoked'); } ~Program(){ Console.WriteLine('Destructor has been invoked'); } public static void Main(string() args) { Program p = new Program(); } }

La sortie du programme suivant sera:

Le constructeur a été appelé
Le destructeur a été invoqué

Explication

Nous avons utilisé le même exemple que nous avons utilisé pour apprendre le constructeur. Nous venons d'ajouter un destructeur dans la classe de programme (~ Program). Lorsque nous initialisons l'objet de la classe, le constructeur est appelé et l'objet de la classe est créé. Cela imprime la phrase «Le constructeur a été appelé» sur la console.

Lorsque l'exécution est terminée et que l'objet de classe est hors de portée, le programme se déplace vers le destructeur. Le destructeur est alors appelé, qui à son tour détruit l'objet. Ici, nous avons imprimé un message à l'intérieur du destructeur, qui est imprimé sur la console après l'appel du destructeur.

Membres statiques dans une classe

Les membres de la classe peuvent être déclarés statiques à l'aide du mot clé static. Lorsqu'un objet est déclaré statique, quel que soit le nombre d'objets créés, il n'y aura qu'une seule copie de l'objet statique.

Être statique implique qu'il y aura une seule instance du membre qui existera pour une classe donnée. Cela signifie que la valeur de la fonction statique ou des variables à l'intérieur de la classe peut être appelée sans créer d'objet pour elles.

Les variables statiques sont utilisées pour déclarer des constantes car leurs valeurs peuvent être obtenues directement en appelant la classe plutôt qu'en créant une instance de celle-ci.

Exemple:

public class Details { public static void stat(){ Console.WriteLine('Static method invoked'); } } public class Program { public static void Main(string() args) { Details.stat(); } }

La sortie du programme suivant sera:

Méthode statique invoquée

Explication

Dans l'exemple ci-dessus, nous avons créé une classe «Détails» qui contient une méthode statique «stat». Nous avons une autre classe «Programme» qui contient la méthode principale. Dans nos rubriques précédentes, nous avons vu comment nous pouvons initialiser une classe pour accéder aux méthodes. Mais comme nous l'avons vu, les membres statiques de la classe sont accessibles avec l'initialisation des objets de classe.

Ainsi, dans la méthode main, nous venons d'appeler la méthode en utilisant directement la classe sans créer d'objet. La sortie du programme a exécuté le code écrit à l'intérieur de la méthode statique. Dans ce cas, nous avons imprimé un message sur la console.

Classe statique en C #

Une classe statique est similaire à une classe normale en C #. La classe statique ne peut avoir que des membres statiques et ne peut pas être instanciée. Une classe statique est utilisée pour s'assurer que la classe n'est pas instanciée. Une classe statique est déclarée en utilisant le mot-clé static avant la classe de mot-clé lors de la déclaration.

Exemple:

public static class Details { public static void multiply(int a, int b){ int c = a*b; Console.WriteLine('Multiplication result is: '+c); } } public class Program { public static void Main(string() args) { Details.multiply(2,8); } }

La sortie du programme suivant sera:

Le résultat de la multiplication est: 16

Explication

Dans l'exemple ci-dessus, nous avons créé une classe statique «Détails» et à l'intérieur de la classe statique, nous avons créé une autre méthode statique «multiplier». À l'intérieur de la méthode, nous avons des extraits de code que nous voulons exécuter. Nous avons également une autre classe «Programme» avec la méthode principale.

Dans la méthode main, nous avons invoqué la méthode multiply présente dans la classe statique. Si vous regardez notre méthode principale, vous verrez que nous n'avons pas initialisé ou créé un objet pour la classe statique au lieu de cela, nous avons directement appelé la classe depuis la méthode principale.

Ainsi, lorsque nous invoquons directement la méthode multiplication en utilisant le nom de la classe et en fournissant des paramètres, elle exécute le code et imprime la sortie.

Structs en C #

L'entité de type valeur dans le C # est appelée structure. Il aide l'utilisateur à stocker des données associées de plusieurs types de données différents dans une seule variable. Comme indiqué, une structure est une entité de type valeur qui contient des champs, des méthodes, des constructeurs, des opérateurs, des événements, etc. Une structure est déclarée en utilisant le mot-clé «struct».

sous-chaîne (0,0) java

Caractéristiques des Structs:

  • Il peut inclure des constantes, des méthodes, des propriétés, des index, des opérateurs, des constructeurs, etc.
  • Il ne peut pas avoir de constructeur par défaut.
  • Il peut implémenter une interface mais ne peut pas hériter avec d'autres structures ou classes.
  • Les structures doivent être initialisées à l'aide d'un nouveau mot-clé pour l'utilisation.

Différence entre Struct et Class

Struct et Class peuvent sembler similaires d'une certaine manière, mais ils présentent plusieurs différences.

Les différences incluent:

  • Une structure est un type valeur alors qu'une classe est un type référence.
  • Le nouveau mot-clé est requis pour initialiser les structures.
  • Les structures ne peuvent avoir qu'un constructeur paramétré et d'autre part, une classe peut avoir à la fois des constructeurs par défaut et paramétrés.

Struct: Définition

Une structure peut être définie à l'aide du mot-clé struct. Une structure peut définir un nouveau type de données avec plusieurs membres différents pour le programme.

Une structure peut être initialisée d'une manière similaire à celle d'une initialisation d'objet, c'est-à-dire en utilisant le mot-clé new. Comme un struct est une entité de type valeur, il est plus rapide à fonctionner qu'un objet de classe. Partout où il est nécessaire de stocker des données, nous devons utiliser une structure. D'autre part, si vous avez besoin de transférer des données, il est conseillé d'utiliser une classe plutôt qu'une structure.

Exemple:

public struct Cuboid { public int length; public int width; public int height; } public class Program { public static void Main(string() args) { Cuboid cb = new Cuboid(); cb.length = 10; cb.width = 20; cb.height = 30; Console.WriteLine('The volume of cuboid is: {0}', (cb.length*cb.width*cb.height)); } }

La sortie du programme suivant sera:

Le volume du cuboïde est: 6000

Explication

Dans l'exemple ci-dessus, nous avons défini un cuboïde struct à l'intérieur duquel nous avons stocké les types de données pour la longueur, la largeur et la hauteur du cuboïde. Nous avons un autre programme de classe où nous avons notre méthode principale.

Dans la méthode principale, nous initialisons la structure «Cuboid» en utilisant le mot-clé new. Ensuite, nous avons utilisé l'objet pour appeler et affecter des valeurs aux types de données stockés dans la structure. Ensuite, nous avons effectué une opération sur les variables de la structure et imprimé le résultat sur la console.

Donc, si vous souhaitez utiliser une propriété, des événements ou des méthodes, la structure doit être initialisée à l'aide du mot-clé new, sinon elle vous donnera une erreur de compilation.

Énumérations en C #

Enum est un ensemble de constantes entières et, similaire à une structure, il s'agit également d'une entité de type valeur. Il est principalement utilisé pour déclarer une liste d'entiers en utilisant le mot-clé «enum» dans un espace de noms, une classe ou même une structure. Dans enum, nous fournissons un nom à chacune des constantes entières, afin de pouvoir les référencer en utilisant leurs noms respectifs.

Enum peut avoir un nombre fixe de constantes. Il contribue à améliorer la sécurité et peut également être traversé.

Caractéristiques de Enum

  • Enum améliore la lisibilité et la maintenabilité du code en fournissant des noms significatifs aux constantes.
  • Enum ne peut pas être utilisé avec les constantes de type chaîne.
  • Enum peut inclure des constantes telles que int, long, short, byte, etc.
  • Par défaut, la valeur des constantes enum commence par zéro

Déclarer une énumération

La syntaxe pour déclarer enum est donnée ci-dessous.

enum { list of integer constants };

Toutes les constantes enum ont des valeurs par défaut. La valeur commence à 0 et monte un par un.

Exemple:

public enum Cuboid{ length, width, height } public class Program { public static void Main(string() args) { int l = (int)Cuboid.length; int w = (int)Cuboid.width; int h = (int)Cuboid.height; Console.WriteLine('The length is :{0}”, l); Console.WriteLine('The width is :{0}”, w); Console.WriteLine('The height is :{0}”, h); } }

La sortie du programme suivant sera:

La longueur est: 0
La largeur est: 1
La hauteur est: 2

Explication

Nous avons travaillé avec un exemple similaire que nous avons appris lors de struct. Dans cet exemple, nous avons créé une énumération nommée Cuboid. Cette énumération contient trois membres, à savoir la longueur, la largeur et la hauteur.

Nous avons une autre classe Program dans laquelle nous avons notre méthode principale. Un cast explicite a été utilisé pour convertir les variables de type enum en type entier, puis nous avons stocké leurs valeurs dans différentes variables à l'intérieur de la méthode principale et les avons imprimées sur la console.

Par défaut, la valeur de la première énumération sera zéro, la seconde aura 1 et ainsi de suite. Par conséquent, lorsque nous avons imprimé les valeurs, nous avons reçu la sortie susmentionnée.

Modification de la valeur d'énumération

Enum permet également aux utilisateurs de modifier l'index de départ par défaut des membres. Une fois que vous avez modifié l'index de départ de la variable, les membres suivants verront leurs valeurs mises à jour dans la séquence incrémentielle.

Attribuons une valeur au premier membre de l'énumération que nous avons définie dans notre exemple précédent et voyons ce qui se passe:

public enum Cuboid { length = 10, width, height } public class Program { public static void Main(string() args) { int l = (int)Cuboid.length; int w = (int)Cuboid.width; int h = (int)Cuboid.height; Console.WriteLine('The length is :{0}”, l); Console.WriteLine('The width is :{0}”, w); Console.WriteLine('The height is :{0}”, h); } }

La sortie du programme suivant sera:

La longueur est: 10
La largeur est: 11
La hauteur est: 12

Explication

Lorsque nous attribuons une valeur au premier membre de l'énumération, tous les membres suivants de l'énumération seront affectés avec l'incrément de cette valeur. Comme nous l'avons défini, la première valeur vaut 10, la valeur suivante devient 11 et la suivante devient 12.

L'utilisateur peut attribuer n'importe quelle valeur selon son choix et tous les membres de l'énumération seront automatiquement attribués avec l'incrément des valeurs définies par l'utilisateur.

Propriétés en C #

Les propriétés en C # sont essentiellement le membre nommé de l'interface, des classes et de la structure. Les propriétés sont une extension des variables / méthodes membres de struct ou class. Ils sont utilisés pour lire, écrire ou modifier la valeur des champs privés.

Les propriétés sont accessibles comme les champs. Ils ont des accesseurs qui peuvent être utilisés pour obtenir, définir et calculer les valeurs. Nous pouvons également mettre de la logique lors de la définition des valeurs dans les propriétés. Il peut également être utilisé avec la classe privée qui restreint l'accès de l'extérieur, mais en même temps, il permet à l'utilisateur d'utiliser des propriétés pour obtenir ou définir des valeurs.

Que sont les accesseurs?

Les accesseurs de propriété constituent les instructions qui peuvent être utilisées pour lire, écrire ou calculer une propriété donnée. La déclaration de propriété peut contenir get, set ou les deux.

Exemple:

public class Cube { private int side; //Declare a Side property of type integer public int Side{ get{ return side; } set{ side = value; } } } public class Program { public static void Main(string() args) { Cube cb = new Cube(); cb.Side = 5; Console.WriteLine('The volume of cube is :{0}', (cb.Side * cb.Side* cb.Side)); } }

Lorsque l'extrait de code ci-dessus est correctement compilé et exécuté, la sortie suivante est observée.

Le volume du cube est: 125

Explication

Dans l'exemple ci-dessus, nous avons une classe «Cube» à l'intérieur de laquelle nous avons déclaré une propriété «Side» de type integer. Après cela, nous avons obtenu et défini la propriété où nous avons retourné et fourni la valeur du côté variable.

commande unix pour comparer deux fichiers et montrer les différences

Nous avons une autre classe «Program» avec la méthode main à l'intérieur de laquelle nous avons initialisé la classe Cube et fourni la valeur de la propriété Side, puis nous avons imprimé le résultat calculé sur la console.

Conclusion

Dans ce didacticiel, nous avons découvert les fonctions membres de la classe. Une fonction membre peut opérer sur n'importe quel objet de la classe où elle est présente. Nous avons également découvert les constructeurs et les destructeurs.

Les constructeurs sont initialisés automatiquement au moment de la création de l'objet de classe tandis que les destructeurs détruisent la classe et sont principalement utilisés pour supprimer l'allocation de mémoire après la fin de l'exécution. Les constructeurs peuvent être de deux types, c'est-à-dire par défaut et paramétrés.

Le destructeur n'accepte aucun paramètre et ne renvoie aucune valeur. Le constructeur et les destructeurs ont des noms qui sont exactement les mêmes que le nom de la classe. Nous avons également découvert les variables statiques et les classes statiques et comment y accéder sans utiliser d'instances de classe. Nous avons appris qu'une classe statique ne peut avoir que des membres statiques.

Nous avons également discuté des Structs ou des structures. Les structures sont des entités de type valeur et doivent être initialisées pour l'accès.

L'énumération et les propriétés de C # ont également été discutées. Enum est un ensemble de constantes entières nommées. Semblable à la structure, il s'agit également d'une entité de type valeur. L'énumération aura ses membres et chaque membre aura sa propre valeur par défaut.

À la fin, nous avons discuté des propriétés, qui sont une extension des variables membres / méthode de struct ou class. Ils sont utilisés pour obtenir, définir ou modifier la valeur des champs privés.

=> Voir notre série complète de formations C # ici

lecture recommandée

^