Définir des constructeurs
Créez des instances avec des constructeurs paramétrés.
Définir des constructeurs est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.
Qu’est-ce qu’un constructeur ?
Un constructeur est une méthode spéciale qui s’exécute lorsqu’un objet est créé avec new. Il porte le même nom que la classe et n’a aucun type de retour. Son rôle est de placer l’objet dans un état initial valide.
using System;
class Dog
{
public Dog()
{
Console.WriteLine("A dog was created");
}
}
class Program
{
static void Main()
{
var d = new Dog();
}
}Constructeurs avec paramètres
Un constructeur peut accepter des paramètres afin que le code appelant fournisse les valeurs initiales. Il s’agit du modèle le plus courant pour définir les données obligatoires.
using System;
class Person
{
public string Name;
public int Age;
public Person(string name, int age)
{
Name = name;
Age = age;
}
}
class Program
{
static void Main()
{
var p = new Person("Ada", 36);
Console.WriteLine(p.Name + " is " + p.Age);
}
}Le mot-clé this dans les constructeurs
Lorsqu’un nom de paramètre correspond à celui d’un champ, utilisez this. pour désigner le champ et le distinguer du paramètre.
using System;
class Book
{
public string Title;
public Book(string title)
{
this.Title = title;
}
}
class Program
{
static void Main()
{
var b = new Book("C# Basics");
Console.WriteLine(b.Title);
}
}Le constructeur par défaut
Si vous n’écrivez aucun constructeur, le compilateur en fournit un sans paramètre. En revanche, dès que vous définissez un constructeur, celui par défaut disparaît, sauf si vous l’ajoutez vous-même.
using System;
class Empty
{
// No constructor written -> compiler supplies a default one
public int Value;
}
class Program
{
static void Main()
{
var e = new Empty();
Console.WriteLine("Default Value: " + e.Value);
}
}Validation dans un constructeur
Un constructeur peut valider ses arguments, garantissant que l’objet n’est jamais créé dans un état invalide.
using System;
class Account
{
public decimal Balance;
public Account(decimal initial)
{
if (initial < 0)
throw new ArgumentException("Initial balance cannot be negative");
Balance = initial;
}
}
class Program
{
static void Main()
{
var a = new Account(100m);
Console.WriteLine("Balance: " + a.Balance);
}
}Surcharge des constructeurs
Une classe peut posséder plusieurs constructeurs avec des listes de paramètres différentes. Le compilateur choisit celui qui correspond aux arguments transmis.
using System;
class Point
{
public int X;
public int Y;
public Point()
{
X = 0;
Y = 0;
}
public Point(int x, int y)
{
X = x;
Y = y;
}
}
class Program
{
static void Main()
{
var origin = new Point();
var p = new Point(3, 4);
Console.WriteLine(origin.X + "," + origin.Y + " | " + p.X + "," + p.Y);
}
}Définition des propriétés depuis un constructeur
Les constructeurs affectent couramment des propriétés automatiques, y compris celles à initialisation unique ou avec un accesseur set privé.
using System;
class Product
{
public string Name { get; }
public decimal Price { get; }
public Product(string name, decimal price)
{
Name = name;
Price = price;
}
}
class Program
{
static void Main()
{
var p = new Product("Pen", 1.50m);
Console.WriteLine(p.Name + ": " + p.Price);
}
}Valeurs par défaut des paramètres
Les paramètres d’un constructeur peuvent avoir des valeurs par défaut, ce qui permet au code appelant de les omettre. Cela réduit souvent le besoin de plusieurs surcharges.
using System;
class Circle
{
public double Radius;
public string Color;
public Circle(double radius, string color = "black")
{
Radius = radius;
Color = color;
}
}
class Program
{
static void Main()
{
var c1 = new Circle(2);
var c2 = new Circle(3, "red");
Console.WriteLine(c1.Color + " | " + c2.Color);
}
}Effectuer un traitement dans un constructeur
En plus d’affecter des champs, un constructeur peut calculer des données dérivées ou préparer les ressources nécessaires à l’objet.
using System;
class Rectangle
{
public double Width;
public double Height;
public double Area;
public Rectangle(double w, double h)
{
Width = w;
Height = h;
Area = w * h;
}
}
class Program
{
static void Main()
{
var r = new Rectangle(4, 5);
Console.WriteLine("Area: " + r.Area);
}
}Constructeurs et données obligatoires
Placer les valeurs obligatoires dans le constructeur les rend indispensables : vous ne pouvez pas créer l’objet sans les fournir.
using System;
class User
{
public string Id;
public string Email;
public User(string id, string email)
{
Id = id;
Email = email;
}
}
class Program
{
static void Main()
{
var u = new User("u1", "a@b.com");
Console.WriteLine(u.Id + " / " + u.Email);
}
}Mise en pratique
Un constructeur bien conçu valide les données d’entrée, affecte les champs et laisse l’objet entièrement prêt à l’emploi.
using System;
class Temperature
{
public double Celsius { get; }
public double Fahrenheit { get; }
public Temperature(double celsius)
{
if (celsius < -273.15)
throw new ArgumentException("Below absolute zero");
Celsius = celsius;
Fahrenheit = celsius * 9 / 5 + 32;
}
}
class Program
{
static void Main()
{
var t = new Temperature(25);
Console.WriteLine(t.Celsius + "C = " + t.Fahrenheit + "F");
}
}Vérification rapide
Testez votre compréhension des constructeurs.
Récapitulatif
Un constructeur porte le même nom que la classe, n’a aucun type de retour et s’exécute avec new. Les constructeurs paramétrés acceptent des valeurs initiales ; this. permet de distinguer les champs des paramètres. Vous pouvez surcharger les constructeurs et utiliser des valeurs de paramètre par défaut. La définition d’un constructeur supprime celui par défaut généré automatiquement.
using System;
class Demo
{
public string Name;
public Demo(string name = "anon")
{
this.Name = name;
}
}
class Program
{
static void Main()
{
Console.WriteLine(new Demo().Name);
Console.WriteLine(new Demo("Kai").Name);
}
}Questions Fréquemment Posées
La leçon « Définir des constructeurs » est-elle gratuite ?
Oui — le texte complet de « Définir des constructeurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Définir des constructeurs » ?
Créez des instances avec des constructeurs paramétrés. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C# Academy ?
Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Définir des constructeurs » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?
Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Définir des constructeurs
- Chaînage de constructeurs avec this
- Initialiseurs d’objets et de collections
- Constructeurs statiques