Les constructeurs en C#

Bienvenue dans la prochaine leçon ! Vous allez découvrir les constructeurs en C#, leur utilité et la manière de les utiliser pour initialiser des objets. Commençons !

Qu’est-ce qu’un constructeur ?

Un constructeur est une méthode spéciale d’une classe qui est appelée automatiquement lorsqu’un objet de cette classe est créé. Il sert à initialiser les données de l’objet ou à effectuer des tâches de configuration.

Point clé : Un constructeur porte le même nom que la classe et n’a pas de type de retour.

Définir un constructeur

Pour définir un constructeur, créez une méthode portant le même nom que la classe. Exemple :

Conseil : Utilisez des constructeurs pour vous assurer que vos objets sont toujours créés dans un état valide.

using System;

class Car {
    public string Color;

    // Constructor
    public Car() {
        Color = "Red"; // Initialize the Color attribute
    }
}

class Program {
    static void Main() {
        Car myCar = new Car(); // Constructor is automatically called
        Console.WriteLine("Car color: " + myCar.Color); // Outputs: Car color: Red
    }
}

Constructeurs avec paramètres

Un constructeur avec paramètres vous permet de transmettre des valeurs afin d’initialiser les données d’un objet lors de sa création. Exemple :

Point clé : Utilisez des constructeurs avec paramètres pour initialiser les objets avec davantage de flexibilité.

using System;

class Car {
    public string Color;

    // Parameterized Constructor
    public Car(string color) {
        Color = color; // Initialize Color with the passed value
    }
}

class Program {
    static void Main() {
        Car myCar = new Car("Blue"); // Pass "Blue" to the constructor
        Console.WriteLine("Car color: " + myCar.Color); // Outputs: Car color: Blue
    }
}

Constructeurs par défaut

Si aucun constructeur n’est défini explicitement, C# fournit un constructeur par défaut qui initialise les champs avec leurs valeurs par défaut. Exemple :

Conseil : Définissez votre propre constructeur lorsqu’une initialisation particulière est nécessaire.

using System;

class Car {
    public string Color; // Default value is null
}

class Program {
    static void Main() {
        Car myCar = new Car(); // Default constructor is automatically called
        Console.WriteLine("Car color: " + (myCar.Color ?? "Not set")); // Outputs: Car color: Not set
    }
}

Surcharge des constructeurs

C# prend en charge la surcharge des constructeurs, ce qui signifie qu’une classe peut avoir plusieurs constructeurs avec des listes de paramètres différentes. Exemple :

Point clé : La surcharge des constructeurs offre davantage de flexibilité lors de la création d’objets.

using System;

class Car {
    public string Color;

    // Default Constructor
    public Car() {
        Color = "Red";
    }

    // Parameterized Constructor
    public Car(string color) {
        Color = color;
    }
}

class Program {
    static void Main() {
        Car defaultCar = new Car(); // Calls the default constructor
        Console.WriteLine("Default car color: " + defaultCar.Color); // Outputs: Default car color: Red

        Car customCar = new Car("Green"); // Calls the parameterized constructor
        Console.WriteLine("Custom car color: " + customCar.Color); // Outputs: Custom car color: Green
    }
}

Défi pratique

Créez une classe appelée Book avec un constructeur par défaut qui définit le titre sur « Inconnu » et un constructeur avec paramètres qui accepte un titre. Affichez le titre du livre avec chacun des deux constructeurs. Exemple :

using System;

class Book {
    public string Title;

    // Default Constructor
    public Book() {
        Title = "Unknown";
    }

    // Parameterized Constructor
    public Book(string title) {
        Title = title;
    }
}

class Program {
    static void Main() {
        Book defaultBook = new Book();
        Console.WriteLine("Default book title: " + defaultBook.Title); // Outputs: Default book title: Unknown

        Book customBook = new Book("C# Programming");
        Console.WriteLine("Custom book title: " + customBook.Title); // Outputs: Custom book title: C# Programming
    }
}

Bonnes pratiques pour les constructeurs

Voici quelques bonnes pratiques à suivre lors de l’utilisation des constructeurs :

• Gardez les constructeurs simples et concentrez-les sur l’initialisation.
• Évitez la logique complexe dans les constructeurs afin de préserver la clarté.
• Utilisez la surcharge des constructeurs pour rendre la création d’objets plus flexible.

Conseil : Les constructeurs doivent préparer un objet afin qu’il soit immédiatement pleinement fonctionnel après sa création.

Excellent travail !

Félicitations ! Vous avez appris ce que sont les constructeurs, comment les définir et pourquoi ils sont importants pour l’initialisation des objets. Dans la prochaine leçon, nous découvrirons le concept d’héritage et apprendrons à réutiliser efficacement le code. Continuons à coder !