Introduction à Constructor en C #
Le constructeur joue un rôle très important dans la programmation orientée objet. Comprenons le rôle du constructeur en C # à l'aide des points suivants:
- Un constructeur est une méthode spéciale présente à l'intérieur d'une classe qui est chargée d'initialiser les variables de la classe.
- Son nom est le même que le nom de la classe.
- Il est automatiquement exécuté lorsque nous créons une instance de la classe.
- Un constructeur ne renvoie aucune valeur.
- Si nous ne définissons pas de constructeur, un constructeur implicite est toujours fourni par la classe qui est appelée le constructeur par défaut.
Syntaxe:
public class Student()
(
//constructor
public Student()
(
//code
)
)
Ici, public Student () est une méthode qui n'a pas de type de retour, même pas void et son nom est le même que le nom de la classe, c'est-à-dire 'Student'. Ainsi, cette méthode est le constructeur de cette classe.
Quand nous allons créer un objet de cette classe en utilisant:
Student obj = new Student();
Ensuite, le code à l'intérieur du constructeur sera exécuté.
Fonctionnement du constructeur en C #
1. Le constructeur initialise les membres de données pour le nouvel objet. Il est invoqué par l'opérateur «nouveau» immédiatement après que la mémoire a été allouée au nouvel objet.
2. Les constructeurs explicites (constructeurs définis par l'utilisateur) peuvent être sans paramètre ou paramétrables. S'il est paramétré, les valeurs transmises au constructeur peuvent être affectées aux membres de données de la classe.
3. Le constructeur implicite initialise les variables de la classe avec la même valeur même si nous créons plusieurs instances de cette classe.
Exemple:
Code:
using System;
public class ConstructorDemo
(
public int num = 10;
public static void Main()
(
ConstructorDemo obj1 = new ConstructorDemo();
ConstructorDemo obj2 = new ConstructorDemo();
ConstructorDemo obj3 = new ConstructorDemo();
Console.WriteLine("obj1.num = "+obj1.num+"\nobj2.num = "+obj2.num
+"\nobj3.num = "+obj3.num);
)
)
Production:
Représentation picturale du programme ci-dessus:
4. Un constructeur explicite avec des paramètres nous permet d'initialiser les variables de la classe avec une valeur différente chaque fois que nous créons une instance de cette classe.
Exemple:
Code:
using System;
public class ConstructorDemo
(
public int num;
//explicit constructor
public ConstructorDemo(int num)
(
this.num = num;
)
public static void Main()
(
ConstructorDemo obj1 = new ConstructorDemo(10);
ConstructorDemo obj2 = new ConstructorDemo(20);
ConstructorDemo obj3 = new ConstructorDemo(30);
Console.WriteLine("obj1.num = "+obj1.num+"\nobj2.num = "+obj2.num
+"\nobj3.num = "+obj3.num);
)
)
Production:
Représentation picturale du programme ci-dessus:
Les 5 principaux types de constructeur en C #
C # fournit cinq types de constructeurs. Ils sont les suivants:
1. Constructeur par défaut
- Un constructeur sans paramètre est appelé constructeur par défaut. Si nous ne le définissons pas explicitement, alors il sera implicitement fourni par le compilateur.
- Dans un tel cas, nous pouvons l'appeler constructeur implicite. Le constructeur implicite ou par défaut initialise tous les membres de données de la classe avec leurs valeurs par défaut telles que tous les champs numériques à zéro et tous les champs chaîne et objet à null.
Exemple:
Code:
using System;
public class DefaultConstructor
(
public int num;
public string str;
)
public class Demo
(
public static void Main()
(
DefaultConstructor obj = new DefaultConstructor();
Console.WriteLine("obj.num = "+obj.num+"\nobj.str = "+obj.str);
)
)
Production:
2. Constructeur paramétré
Le constructeur avec au moins un paramètre est appelé constructeur paramétré. Les paramètres du constructeur peuvent être passés lors de la création de l'instance de la classe. Il nous permet d'initialiser chaque instance d'une classe avec des valeurs différentes.
Exemple:
Code:
using System;
public class ParameterizedConstructor
(
public int num;
public string str;
//parameterized constructor
public ParameterizedConstructor(int num, string str)
(
this.num = num;
this.str = str;
)
)
public class Demo
(
public static void Main()
(
//passing values to constructor while creating instance
ParameterizedConstructor obj = new ParameterizedConstructor(50, "constructor");
Console.WriteLine("obj.num = "+obj.num+"\nobj.str = "+obj.str);
)
)
Production:
3. Copier le constructeur
Il s'agit d'un constructeur paramétré qui prend l'objet de la même classe comme paramètre. Il copie la valeur de l'objet existant (qui est passée en paramètre) à l'objet nouvellement créé instancié par le constructeur. On peut dire qu'il copie les données d'un objet vers un autre objet.
Exemple:
Code:
using System;
public class CopyConstructor
(
public int num;
public CopyConstructor(int num)
(
this.num = num;
)
//copy constructor
public CopyConstructor(CopyConstructor obj)
(
num = obj.num;
)
)
public class Demo
(
public static void Main()
(
CopyConstructor obj1 = new CopyConstructor(50);
//passing same class's object as parameter
CopyConstructor obj2 = new CopyConstructor(obj1);
Console.WriteLine("Original object:");
Console.WriteLine("obj1.num = "+obj1.num);
Console.WriteLine("\nCopied object:");
Console.WriteLine("obj2.num = "+obj2.num);
)
)
Production:
4. Constructeur statique
- Il peut être défini en préfixant le nom du constructeur avec un mot-clé. Il est implicitement défini par le compilateur (s'il n'est pas défini explicitement) si la classe contient une variable statique.
- C'est le premier bloc à être exécuté dans la classe et sera appelé automatiquement. Il ne sera exécuté qu'une seule fois quel que soit le nombre d'instances de classe. Il est sans paramètre et n'accepte aucun modificateur d'accès.
Exemple:
Code:
using System;
public class StaticConstructor
(
//static constructor
static StaticConstructor()
(
Console.WriteLine("Static constructor executed");
)
public static void Display()
(
Console.WriteLine("\nDisplay method executed");
)
)
public class Demo
(
public static void Main()
(
StaticConstructor.Display();
)
)
Production:
5. Constructeur privé
Le constructeur créé avec un spécificateur privé est appelé constructeur privé. Nous ne pouvons pas créer une instance de la classe si elle contient uniquement un constructeur privé et si elle ne permet pas aux autres classes de dériver de cette classe. Utilisé dans une classe qui ne contient que des membres statiques.
Exemple:
Code:
using System;
public class PrivateConstructor
(
public static int num = 100;
//private constructor
private PrivateConstructor()
(
)
)
public class Demo
(
public static void Main()
(
//PrivateConstructor obj = new PrivateConstructor(); //Error
Console.WriteLine("num = "+PrivateConstructor.num);
)
)
Production:
Conclusion
Si nous définissons n'importe quel type de constructeur dans la classe, alors il n'y aura pas de constructeur implicite dans la classe fournie par le compilateur. Comme les méthodes, les constructeurs paramétrés peuvent également être surchargés avec différents nombres de paramètres. Les constructeurs définis implicitement par le compilateur sont toujours publics.
Article recommandé
Ceci est un guide du constructeur en C #. Nous discutons ici des types de constructeur en C # et de son fonctionnement avec l'implémentation et la sortie du code. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus -
- Constructeur en JavaScript et types
- Qu'est-ce que le générateur de nombres aléatoires en C #?
- Constructeur en C ++ et types
- Copier le constructeur en C # (exemples)
- Constructeur statique en Java | Travailler | Applications