Syntaxe de déclaration d'une classe et sa structure

1. Structure générale de la déclaration d'une classe

Alors, imagine : une classe en C#, c'est comme le plan d'un immeuble. Sur le plan, on décrit combien il y a de pièces, la couleur des murs, où sont les portes et les fenêtres. Dans la classe — quelles propriétés possède l'objet (genre nom, âge) et ce qu'il sait faire (genre "dire bonjour", "demander un salaire").

La déclaration d'une classe contient toujours trois blocs principaux :

1. Modificateur d'accès (public, private, internal, protected) — qui peut utiliser cette classe. Pour faire simple, on va utiliser public pour que la classe soit "visible" partout.
2. Le mot-clé class — pour que le compilateur pige qu'on décrit bien une classe.
3. NomDeLaClasse — avec une majuscule, c'est la convention.
4. Le corps de la classe entre accolades — c'est là qu'on décrit tout ce qui compose notre classe : champs, propriétés, méthodes.

Schématiquement, ça donne ça :

public class NomDeLaClasse
{
    // Ici il y aura les champs, propriétés et méthodes de la classe
}

Exemple : Classe étudiant

public class Student
{
    // Champs (variables appartenant à l'objet)
    public string Name;
    public int Age;
}

Pour l'instant, cette classe — c'est comme une boîte vide : on a dit qu'un étudiant a droit à un nom et un âge, mais on ne lui a encore rien appris.

2. Champs de la classe (fields)

Les champs — ce sont des variables qui appartiennent à l'objet de la classe. Par exemple, chaque étudiant doit avoir son propre nom et son propre âge — donc on les décrit comme des champs :

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

Maintenant, quand tu crées un objet de type Student, chaque objet aura son propre nom et âge.

Exemple de création d'objet :

Student sasha = new Student();
sasha.Name = "Sacha";
sasha.Age = 20;

Ici, on a créé l'objet sasha, puis on a attribué séparément des valeurs à ses champs. Cette approche est utilisée pour démarrer simplement (on parlera des constructeurs en détail à la prochaine leçon).

3. Méthodes de la classe (functions)

Les méthodes — ce sont les "verbes" de l'objet, c'est-à-dire son comportement. Les actions qu'il sait faire. Par exemple, un étudiant peut dire bonjour. Pour ça, on décrit une méthode dans la classe :

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

    public void SayHello()
    {
        Console.WriteLine($"Salut, je m'appelle {Name}, j'ai {Age} ans !");
    }
}

Maintenant, chaque étudiant peut "dire bonjour" — et il utilisera son propre nom et âge.

Exemple d'utilisation de la méthode :

Student sasha = new Student();
sasha.Name = "Sacha";
sasha.Age = 20;
sasha.SayHello(); // Affichera : Salut, je m'appelle Sacha, j'ai 20 ans !

4. Propriétés de la classe (properties)

Les propriétés — ce sont des "champs intelligents", où tu peux définir des actions spéciales lors de la lecture ou l'écriture de la valeur. En C# moderne, on utilise plus souvent les propriétés que les champs, parce qu'elles offrent plus de contrôle et de flexibilité. C'est comme l'électricité : ça a l'air simple, mais les possibilités sont énormes.

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Ici, get; set; crée automatiquement un champ, mais permet d'ajouter de la logique plus tard quand la valeur change. Pour l'utilisateur de la classe, les propriétés ressemblent presque à des champs.

Exemple :

Student katya = new Student();
katya.Name = "Katya";
katya.Age = 18;
Console.WriteLine(katya.Name); // Katya

Plus de détails sur les propriétés de classe — dans les prochaines leçons :P

5. Commentaires

Sujet chiant mais important ! Comme dans le reste du code, à l'intérieur d'une classe tu peux (et tu dois) écrire des commentaires pour expliquer à quoi sert tel champ ou telle méthode :

public class Student
{
    // Nom de l'étudiant
    public string Name { get; set; }
    
    // Âge de l'étudiant (en années)
    public int Age { get; set; }

    // L'étudiant dit bonjour
    public void SayHello()
    {
        Console.WriteLine($"Salut, je m'appelle {Name}, j'ai {Age} ans !");
    }
}

Ça rend le code plus lisible et ça aide à ne pas se perdre même dans un gros projet.

6. Modificateurs d'accès

Les modificateurs d'accès — c'est un peu comme des portes avec différentes serrures. Ils définissent qui et d'où peut accéder aux membres de la classe. Les principaux modificateurs :

• public : accessible partout (c'est notre cas par défaut).
• private : accessible seulement à l'intérieur de cette classe.
• internal : accessible dans l'assembly courant (projets, bibliothèques).
• protected : accessible dans la classe et ses héritiers.

Exemple pour un champ caché du monde extérieur :

public class Student
{
    private int age; // Seulement dans Student
    public string Name { get; set; }

    public void SetAge(int value)
    {
        if (value > 0)
            age = value;
    }

    public int GetAge()
    {
        return age;
    }
}

Au début, on déclare souvent tous les membres en public pour ne pas se prendre la tête, mais dans les vrais projets c'est une mauvaise pratique : certains détails d'implémentation doivent rester cachés.

7. Membres statiques de la classe

Parfois, une classe a des données ou des méthodes qui n'appartiennent pas à un objet en particulier, mais à toute la classe. Ce sont les membres statiques (static members).

Par exemple : on veut garder un compteur global d'étudiants.

public class Student
{
    public static int StudentsCount = 0;

    public string Name { get; set; }
    public int Age { get; set; }
}

On accède à un membre statique via le nom de la classe :

Student.StudentsCount = 0;

Chaque objet a ses propres propriétés/champs, mais les statiques — c'est commun à tous. Dans l'exemple ci-dessus, si on a 10 étudiants, chacun a son Name, mais StudentsCount — c'est le même pour tous.

8. Exemple : Classe complète étudiant (version avec méthodes)

On va tout rassembler et créer une classe étudiant qui sait tout faire et qui est bien fichue :

public class Student
{
    // Compteur statique d'étudiants - concerne tous les étudiants
    public static int Count = 0;

    // Nom et âge - propriétés
    public string Name { get; set; }
    public int Age { get; set; }

    // Constructeur (on parlera des constructeurs à la prochaine leçon)
    public Student(string name, int age)
    {
        Name = name;
        Age = age;
        Count++; // À chaque création d'objet, on incrémente le compteur
    }

    // Méthode pour dire bonjour
    public void SayHello()
    {
        Console.WriteLine($"Salut ! Je suis {Name}. J'ai {Age} ans.");
    }
}

Utilisation dans l'appli principale :

class Program
{
    static void Main()
    {
        Student sasha = new Student("Sacha", 20);
        Student katya = new Student("Katya", 22);

        sasha.SayHello();
        katya.SayHello();

        Console.WriteLine($"Nombre total d'étudiants : {Student.Count}");
    }
}

9. Organisation du code : un fichier = une classe

En .NET, c'est la norme de mettre chaque classe publique dans un fichier séparé qui porte le même nom que la classe. Par exemple :

Student.cs
|
|__ public class Student

Et dans le fichier principal du programme (Program.cs) — le point d'entrée et le code principal. Ça rend la navigation dans le projet plus facile, surtout quand il y a plein de classes.

10. Erreurs typiques avec les classes et objets

Erreur n°1 : tu as oublié les accolades ou tu les as mises au mauvais endroit.
Le compilateur va râler direct, mais c'est pas toujours évident de piger pourquoi. Surtout si les accolades sont paumées dans une grosse structure — retrouver où ça a cassé, c'est pas simple.

Erreur n°2 : tu as déclaré deux classes avec le même nom dans le même namespace.
Ce genre de "créativité", le compilateur n'aime pas. Et tant mieux — sinon tu ne saurais même plus à quelle classe tu fais référence.

Erreur n°3 : tu as donné accidentellement au champ le même nom qu'à la propriété.
Ça fout la pagaille quand tu accèdes aux membres de la classe. Même les devs expérimentés se prennent la tête : "Là, j'accède au champ ou à la propriété ?"

Erreur n°4 : tu n'as pas mis de modificateur d'accès.
Par défaut, la classe devient internal, et si tu écris une bibliothèque — ça peut limiter l'accès à la classe de façon inattendue.

Erreur n°5 : tu accèdes aux membres statiques via une instance.
Si tu écris student.Count au lieu de Student.Count, le compilateur ne va peut-être pas râler, mais ça embrouille. On dirait que Count appartient à un étudiant précis, alors qu'en vrai — c'est pour tous.

2

Mission

C# SELF, niveau 16, leçon 1

Bloqué

Ajout d'une méthode à une classe

Ajout d'une méthode à une classe

Ouvrir