Notion de classe et d'objet

1. Introduction

Comme tu l'as sûrement déjà entendu, classe – c'est un modèle, et objet – c'est son instance.
Mais il est temps de creuser un peu plus sur les classes et les objets !

Imagine que tu es ingénieur-concepteur dans une usine automobile. Au lieu d'assembler chaque voiture à la main, tu crées un plan – une instruction universelle qui permet d'assembler plein de voitures du même type. Ce plan indique que la voiture doit avoir un moteur, des roues, une carrosserie, une couleur, et quelles fonctions elle peut remplir.

Ce plan, dans le monde de la programmation, s'appelle une classe.

Et maintenant, imagine que l'usine a sorti une série de voitures selon ce plan. Chacune d'elles est réelle, roule sur la route, a son propre numéro, sa couleur, et même quelques réglages individuels. Mais elles sont toutes assemblées selon le même plan.

Ces voitures réelles, dans le monde de la programmation, s'appellent des objets (ou instances de classe).

Alors, retiens bien :

• Classe — c'est comme un plan, un modèle, un schéma. Elle décrit quelles données quelque chose peut avoir (par exemple, marque, couleur, nombre de portes) et ce que ce truc peut faire (par exemple, rouler, freiner, klaxonner). La classe, c'est juste une description, elle ne prend pas beaucoup de place en mémoire et ce n'est pas quelque chose de "vivant".
• Objet — c'est une "voiture" concrète, assemblée selon le plan de la classe. C'est une entité réelle, "vivante" dans ton programme, qui occupe de la mémoire, a ses propres valeurs uniques pour les données (son numéro, sa couleur) et peut faire les actions décrites dans la classe.

Ça paraît un peu abstrait ? T'inquiète, on va tout décortiquer maintenant.

2. C'est quoi une classe ?

Classe — c'est un type de données personnalisé qui décrit à quoi doivent ressembler les objets de ce type : quelles caractéristiques (états/propriétés/champs) ils ont et quelles actions on peut faire avec eux (comportement/méthodes/fonctions).

Une classe définit :

• Champs (variables) — les données stockées dans l'objet.
• Méthodes (fonctions) — les actions que l'objet peut faire.
• Propriétés — des méthodes spéciales pour accéder aux données.
• Événements — des mécanismes pour notifier (on en parlera plus tard).
• Constructeurs — des méthodes spéciales pour créer des objets.

public class Person
{
    // Champs (données)
    public string Name;
    public int Age;

    // Méthode (action)
    public void SayHello()
    {
        Console.WriteLine($"Salut ! Je m'appelle {Name}, j'ai {Age} ans.");
    }
}

Dans cet exemple, on a déclaré la classe Person. Elle a deux champs (Name et Age) et une méthode SayHello(). C'est tout ce qu'il faut pour une classe toute simple.

3. C'est quoi un objet ?

Objet — c'est une instance de classe, c'est-à-dire une entité concrète créée en mémoire selon le "plan" (la classe).

Quand tu crées une variable de type Person, tu obtiens un objet – avec des valeurs uniques pour chaque champ. Pas juste une personne, mais, par exemple, une personne qui s'appelle Johnny et qui a 12 ans. Et quand il te salue (c'est-à-dire quand tu appelles la méthode SayHello()), il te "dit" des infos sur lui.

// On crée un objet de la classe Person
Person person1 = new Person();
person1.Name = "Alice";
person1.Age = 28;
person1.SayHello(); // => Salut ! Je m'appelle Alice, j'ai 28 ans.

// On crée un autre "personne"
Person person2 = new Person();
person2.Name = "Bob";
person2.Age = 32;
person2.SayHello(); // => Salut ! Je m'appelle Bob, j'ai 32 ans.

Chaque objet — ce n'est pas juste une copie : c'est une entité indépendante avec ses propres données (dans notre exemple — les prénoms et l'âge).

4. La différence principale entre classe et objet

La différence principale :

• Classe — "plan", instruction, type de données.
• Objet — représentant concret de ce type ; une vraie "maison" construite selon le plan ; une "voiture" fabriquée selon le plan.

Tu peux créer autant d'objets d'une même classe que tu veux. Par exemple, si tu as une classe Person, tu peux créer un million de "personnes" dans le programme.

Pourquoi c'est pratique et important ?

Essayons d'imaginer un programme sans classes. Si on avait une liste d'étudiants, il faudrait stocker le nom, l'âge, les notes et d'autres infos dans des tableaux séparés pour chaque paramètre :

string[] studentNames = { "Sally", "Greg", "Mary" };
int[] studentAges = { 20, 19, 21 };

// Si tu veux ajouter une propriété de plus, il faudra encore un tableau.
// Essayer d'échanger deux personnes devient un vrai cauchemar !

En utilisant les classes, les données ne partent pas dans tous les sens, elles sont logiquement regroupées :

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

Student[] students = new Student[3];
students[0] = new Student { Name = "Sally", Age = 20 };
students[1] = new Student { Name = "Greg", Age = 19 };
students[2] = new Student { Name = "Mary", Age = 21 };

C'est beaucoup plus clair et pratique ! Et en plus, tu peux maintenant ajouter des méthodes à chaque étudiant (par exemple, "dire bonjour" ou "calculer la moyenne des notes").

Image : lien entre classe et objet

+------------------+          +----------------+
|   class Person   |=========>|  person1:      | 
| (plan/type)      |          |  Name = "Alice"|
|                  |         /|  Age = 28      |
+------------------+        / +----------------+
                          /
+------------------------/----------------------+
                        /
                  +----------------+
                  |  person2:      |
                  |  Name = "Bob"  |
                  |  Age = 32      |
                  +----------------+

5. Où utilise-t-on les classes et objets dans la vraie vie ?

Les classes et objets — c'est la base de n'importe quelle appli en C#. Tout ce que tu vois autour dans .NET : fenêtres, boutons, formulaires, tableaux, collections, connexions à la base de données, logs — ce sont des objets créés à partir de certaines classes.

Exemples :

• La classe Button — c'est l'instruction pour savoir à quoi doit ressembler un bouton à l'écran. À chaque fois que tu crées un nouveau bouton — c'est un objet de cette classe.
• La classe Stream (du système d'entrée-sortie) : tu obtiens un objet qui bosse avec les fichiers.
• Ta future classe User pour stocker les infos sur les utilisateurs — encore un modèle du même genre.

En bref sur les noms, modificateurs et conventions

• Pour les classes, on utilise des noms avec une majuscule, par exemple Person, Order, Product.
• Pour les variables — avec une minuscule, par exemple person, user1, orderList.
• Le plus souvent, la classe est public — pour qu'elle soit accessible partout dans le projet.