Classes et objets : création, constructeurs et initialisation

1. Création d'un objet

Voilà, on arrive enfin à la création d'objets. Tu as déjà croisé ça avant, mais là on va creuser un peu plus. En vrai, créer des objets c'est super simple.

Pour créer un objet, il faut utiliser l'opérateur new. En général, tu crées une nouvelle instance (objet) d'une classe et tu la stockes direct dans une variable du même type.

Classe nom = new Classe(paramètres);

Où Classe — le type de l'objet, nom — le nom de la variable (souvent en minuscule, genre cat), et à droite du = — la création du nouvel objet de cette classe.

Exemples :

object o = new object();

Cat pet = new Cat();

var reader = new StreamReader("file.txt");

Très souvent, les devs appellent leurs variables comme la classe, mais en minuscule. Pour un débutant, ce genre de code peut être perturbant :

Student student = new Student();

Car car = new Car();

PersonInfo personInfo = new PersonInfo();

En vrai, y'a rien de grave dans ce code — c'est juste du code classique où on crée une variable et on l'initialise direct avec un objet du même type.

À gauche — déclaration de la variable, à droite — création d'un nouvel objet en mémoire avec new. Voilà !

2. Constructeur

T'as sûrement déjà vu qu'en créant un objet, on passe parfois des paramètres. Et parfois non. Mais comment ça marche tout ce bazar avec les paramètres ?

Là aussi, c'est simple : chaque classe a une méthode spéciale (ou plusieurs) qui gère les paramètres à la création de l'objet. Ces méthodes s'appellent des constructeurs. Et une seule méthode, c'est donc un constructeur.

Reconnaître un constructeur dans le code, c'est facile. Il a deux particularités :

• le nom du constructeur est le même que celui de la classe (et commence par une majuscule)
• le constructeur n'a pas de type de retour (même pas void).

En général, ça ressemble à ça :

modificateurs Classe(paramètres)
{
   code du constructeur
}

Exemple de déclaration d'un constructeur :

public class Point
{
    public int X;
    public int Y;

    public Point(int x, int y) // Constructeur
    {
        X = x;
        Y = y;
    }
}

Utilisation :

Point p = new Point(5, 10); // Appel du constructeur

Quand tu crées un objet avec new Point(5, 10), c'est le constructeur avec deux paramètres qui est appelé, et il initialise les champs X et Y.

Parfois, les paramètres du constructeur ont le même nom que les champs — c'est pour la praticité. Ce conflit de noms se règle avec le mot-clé this :

public Point(int x, int y)
{
    this.x = x; // this.x — champ de l'objet, x — paramètre du constructeur
    this.y = y;
}

3. Appel du constructeur

Quand tu écris new Classe(paramètres), C# :

• crée un nouvel objet en mémoire,
• appelle le constructeur adapté, en passant tes paramètres.

Exemple avec la classe chat :

public class Cat
{
    public string Name;
    public int Age;

    public Cat(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

Utilisation :

Cat cat = new Cat("Vaska", 2); // OK : le constructeur avec deux paramètres est appelé
Cat cat2 = new Cat("Vaska");   // Non : pas de constructeur comme ça — erreur de compilation
Cat cat3 = new Cat();          // Non : pas de constructeur sans paramètres — erreur de compilation

Si ta classe a seulement un constructeur avec paramètres, tu dois obligatoirement fournir des valeurs à la création de l'objet.

4. Plusieurs constructeurs

Mais si t'en as besoin, tu peux ajouter plusieurs constructeurs dans ta classe. Y'a aucune limite sur le nombre de constructeurs ou leurs paramètres. À la création de l'objet, le compilateur choisit tout seul le constructeur qui correspond aux paramètres.

Exemple :

public class Cat
{
    public const int INCONNU = -1;
    public string Name;
    public int Age;

    public Cat(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public Cat(string name)
    {
        Name = name;
        Age = INCONNU; // Valeur "par défaut" pour âge inconnu
    }
}

Utilisation :

Cat cat1 = new Cat("Vaska", 2); // Utilise le premier constructeur
Cat cat2 = new Cat("Murka");    // Utilise le second constructeur
Cat cat3 = new Cat();           // Erreur ! Pas de constructeur sans paramètres

On a pensé au cas où l'âge du chat serait inconnu. Pour ça, on a ajouté une constante spéciale — INCONNU et un constructeur qui prend juste le nom du chat.

Fais gaffe, on initialise toujours les deux variables de classe dans les deux constructeurs. Les paramètres inconnus/absents sont remplacés par la constante INCONNU.

5. Constructeur par défaut

Si ta classe n'a aucun constructeur, le compilateur ajoute automatiquement un constructeur vide sans paramètres :

public ClassName()
{
}

Mais si tu déclares au moins un constructeur dans la classe — le constructeur vide n'est plus ajouté automatiquement.

Exemple 1 :

public class Cat
{
    public string Name;
    public int Age;
}

// OK :
Cat cat = new Cat(); // Le constructeur par défaut (sans paramètres) sera appelé

Exemple 2 :

public class Cat
{
    public string Name;
    public int Age;

    public Cat(string name) { Name = name; }
}

// Non :
Cat cat = new Cat(); // Erreur : plus de constructeur sans paramètres !

6. Initialisation des variables

En C#, tu peux initialiser les variables de classe soit direct à la déclaration, soit dans le constructeur.

Exemple :

public class Cat
{
    public string Name;
    public int Age = -1; // Valeur de départ

    public Cat(string name, int age)
    {
        Name = name;
        Age = age; // Écrase la valeur de départ
    }

    public Cat()
    {
        Name = "SansNom";
        // Age reste à -1 (valeur de départ)
    }
}

Explication :

• Si tu fais new Cat("Vaska", 2) la variable Age sera d'abord -1, puis le constructeur lui mettra 2.
• Si tu fais new Cat() — Age restera à -1.

7. Ordre d'initialisation des variables

Les données d'un nouvel objet sont initialisées dans cet ordre :

1. Les champs de la classe reçoivent d'abord des valeurs par défaut (0 pour int, null pour les types référence, etc.).
2. Puis les initialisateurs que tu as mis à la déclaration des champs sont exécutés, dans l'ordre où ils apparaissent dans le code.
3. Et seulement après, le code du constructeur s'exécute.

Les variables sont initialisées avant le constructeur et dans l'ordre de déclaration. Donc fais gaffe aux dépendances entre les champs.

Mauvais exemple

Les champs non statiques ne peuvent pas être initialisés avec d'autres variables non statiques :

public class Solution
{
    public int a = 1; 
    public int b = a;        // impossible d'utiliser a
    public int c = a + b;   // impossible d'utiliser a et b
}
// Ce code va provoquer une erreur de compilation !

Bon exemple

Pour les variables statiques tout fonctionne :

public class Solution
{
    public static int a = 1;          // On met explicitement a = 1
    public static int b = a + 2;      // b = 1 + 2 ⇒ 3
    public static int c = a + b + 3;  // c = 1 + 3 + 3 ⇒ 7

    public Solution()
    {
        Console.WriteLine($"a = {a}, b = {b}, c = {c}");
        // Affichera : a = 1, b = 3, c = 7 — exactement ce qu'on attend
    }
}

Bon exemple 2

Pour les champs statiques, tu peux même faire comme ça :

public class Solution
{
    public static int a = b + c + 1;    // b et c valent encore 0
    public static int b = a + c + 2;    // a == 1, c vaut encore 0
    public static int c = a + b + 3;    // a == 1, b == 3
}

2

Mission

C# SELF, niveau 12, leçon 0

Bloqué

Création d'une classe et d'un objet

Création d'une classe et d'un objet

Ouvrir

2

Mission

C# SELF, niveau 12, leçon 0

Bloqué

Initialisation des variables et plusieurs constructeurs

Initialisation des variables et plusieurs constructeurs

Ouvrir