Constructeur C#
Constructeur C#
Dans ce tutoriel, nous allons découvrir les constructeurs C# et leurs types à l'aide d'exemples.
En C#, un constructeur est similaire à une méthode appelée lorsqu'un objet de la classe est créé.
Cependant, contrairement aux méthodes, un constructeur :
- a le même nom que celui de la classe
- n'a aucun type de retour
Créer un constructeur C#
Voici comment créer un constructeur en C#
class Car {
// constructor
Car() {
//code
}
} Ici, Voiture() est un constructeur. Il porte le même nom que sa classe.
Appeler un constructeur
Une fois que nous avons créé un constructeur, nous pouvons l'appeler en utilisant le new mot-clé. Par exemple,
new Car(); En C#, un constructeur est appelé lorsque nous essayons de créer un objet d'une classe. Par exemple,
Car car1 = new Car(); Ici, nous appelons la Car() constructeur pour créer un objet car1 . Pour en savoir plus sur les objets, consultez Classe C# et objets.
Types de constructeurs
Il existe les types de constructeurs suivants :
- Constructeur sans paramètre
- Constructeur paramétré
- Constructeur par défaut
1. Constructeur sans paramètre
Lorsque nous créons un constructeur sans paramètres, il s'agit d'un constructeur sans paramètre. Par exemple,
using System;
namespace Constructor {
class Car {
// parameterless constructor
Car() {
Console.WriteLine("Car Constructor");
}
static void Main(string[] args) {
// call constructor
new Car();
Console.ReadLine();
}
}
} Sortie
Car Constructor
Dans l'exemple ci-dessus, nous avons créé un constructeur nommé Car() .
new Car();
On peut appeler un constructeur en ajoutant un new mot-clé au nom du constructeur.
2. Constructeur paramétré C#
En C#, un constructeur peut également accepter des paramètres. C'est ce qu'on appelle un constructeur paramétré. Par exemple,
using System;
namespace Constructor {
class Car {
string brand;
int price;
// parameterized constructor
Car(string theBrand, int thePrice) {
brand = theBrand;
price = thePrice;
}
static void Main(string[] args) {
// call parameterized constructor
Car car1 = new Car("Bugatti", 50000);
Console.WriteLine("Brand: " + car1.brand);
Console.WriteLine("Price: " + car1.price);
Console.ReadLine();
}
}
} Sortie
Brand: Bugatti Price: 50000
Dans l'exemple ci-dessus, nous avons créé un constructeur nommé Car() . Le constructeur prend deux paramètres :theBrand et lePrix .
Remarquez la déclaration,
Car car1 = new Car("Bugatti", 50000); Ici, nous transmettons les deux valeurs au constructeur.
Les valeurs transmises au constructeur sont appelées arguments. Il faut passer le même nombre et type de valeurs en paramètre.
3. Constructeur par défaut
Si nous n'avons pas défini de constructeur dans notre classe, le C# créera automatiquement un constructeur par défaut avec un code vide et aucun paramètre. Par exemple,
using System;
namespace Constructor {
class Program {
int a;
static void Main(string[] args) {
// call default constructor
Program p1 = new Program();
Console.WriteLine("Default value of a: " + p1.a);
Console.ReadLine();
}
}
} Sortie
Default value of a: 0
Dans l'exemple ci-dessus, nous n'avons créé aucun constructeur dans le Program classer. Cependant, lors de la création d'un objet, nous appelons le constructeur.
Program p1 = new Program();
Ici, C# crée automatiquement un constructeur par défaut. Le constructeur par défaut initialise toute variable non initialisée avec la valeur par défaut.
Par conséquent, nous obtenons 0 comme valeur du int variable a .
Remarque :Dans le constructeur par défaut, tous les champs numériques sont initialisés à 0, alors que string et object sont initialisés à null.
4. Copier le constructeur en C#
Nous utilisons un constructeur de copie pour créer un objet en copiant les données d'un autre objet. Par exemple,
using System;
namespace Constructor {
class Car {
string brand;
// constructor
Car (string theBrand) {
brand = theBrand;
}
// copy constructor
Car(Car c1) {
brand = c1.brand;
}
static void Main(string[] args) {
// call constructor
Car car1 = new Car("Bugatti");
Console.WriteLine("Brand of car1: " + car1.brand);
// call the copy constructor
Car car2 = new Car(car1);
Console.WriteLine("Brand of car2: " + car2.brand);
Console.ReadLine();
}
}
} Sortie
Brand of car1: Bugatti Brand of car2: Bugatti
Dans le programme ci-dessus, nous avons utilisé un constructeur de copie.
Car(Car c1) {
brand = c1.brand;
} Ici, ce constructeur accepte un objet de Car comme paramètre. Ainsi, lors de la création de la car2 objet, nous avons passé le car1 objet comme argument du constructeur de copie.
Car car2 = new Car(car1); Dans le constructeur de copie, nous avons attribué la valeur de la marque pour voiture1 s'opposer à la marque variable pour voiture2 objet. Par conséquent, les deux objets ont la même valeur de la marque .
5. Constructeur privé
Nous pouvons créer un constructeur privé en utilisant le private spécificateur d'accès. C'est ce qu'on appelle un constructeur privé en C#.
Une fois le constructeur déclaré privé, nous ne pouvons pas créer d'objets de la classe dans d'autres classes.
Exemple 1 :Constructeur privé
using System;
namespace Constructor {
class Car {
// private constructor
private Car () {
Console.WriteLine("Private Constructor");
}
}
class CarDrive {
static void Main(string[] args) {
// call private constructor
Car car1 = new Car();
Console.ReadLine();
}
}
} Dans l'exemple ci-dessus, nous avons créé un constructeur privé Car() . Étant donné que les membres privés ne sont pas accessibles en dehors de la classe, lorsque nous essayons de créer un objet de Car
// inside CarDrive class
Car car1 = new Car(); nous obtenons une erreur
error CS0122: 'Car.Car()' is inaccessible due to its protection level Remarque :Si un constructeur est privé, on ne peut pas créer d'objets de la classe. Par conséquent, tous les champs et méthodes de la classe doivent être déclarés statiques, afin qu'ils soient accessibles à l'aide du nom de la classe.
6. Constructeur statique C#
En C#, nous pouvons également rendre notre constructeur statique. Nous utilisons le static mot-clé pour créer un constructeur statique. Par exemple,
using System;
namespace Constructor {
class Car {
// static constructor
static Car () {
Console.WriteLine("Static Constructor");
}
// parameterless constructor
Car() {
Console.WriteLine("Default Constructor");
}
static void Main(string[] args) {
// call parameterless constructor
Car car1 = new Car();
// call parameterless constructor again
Car car2 = new Car();
Console.ReadLine();
}
}
} Dans l'exemple ci-dessus, nous avons créé un constructeur statique.
static Car () {
Console.WriteLine("Static Constructor");
} Nous ne pouvons pas appeler directement un constructeur statique. Cependant, lorsque nous appelons un constructeur régulier, le constructeur statique est appelé automatiquement.
Car car1 = new Car(); Ici, nous appelons la Car() constructeur. Vous pouvez voir que le constructeur statique est également appelé avec le constructeur régulier.
Sortie
Static Constructor Default Constructor Default Constructor
Le constructeur statique n'est appelé qu'une seule fois lors de l'exécution du programme. C'est pourquoi, lorsque nous appelons à nouveau le constructeur, seul le constructeur normal est appelé.
Remarque :Nous ne pouvons avoir qu'un seul constructeur statique dans une classe. Il ne peut pas avoir de paramètres ou de modificateurs d'accès.
Surcharge du constructeur C#
En C #, nous pouvons créer deux constructeurs ou plus dans une classe. C'est ce qu'on appelle la surcharge du constructeur. Par exemple,
using System;
namespace ConstructorOverload {
class Car {
// constructor with no parameter
Car() {
Console.WriteLine("Car constructor");
}
// constructor with one parameter
Car(string brand) {
Console.WriteLine("Car constructor with one parameter");
Console.WriteLine("Brand: " + brand);
}
static void Main(string[] args) {
// call constructor with no parameter
Car car = new Car();
Console.WriteLine();
// call constructor with parameter
Car car2 = new Car("Bugatti");
Console.ReadLine();
}
}
} Sortie
Car constructor Car constructor with one parameter Brand: Bugatti
Dans l'exemple ci-dessus, nous avons surchargé Car constructeur :
- un constructeur a un paramètre
- un autre a deux paramètres
En fonction du numéro de l'argument passé lors de l'appel du constructeur, le constructeur correspondant est appelé.
Ici,
- Objet voiture - appelle le constructeur avec un paramètre
- Objet voiture2 - appelle le constructeur avec deux paramètres
Pour en savoir plus, consultez Surcharge de constructeur C#.
Langue C