Maîtriser les classes C# : blueprint pour la programmation orientée objet

Définir une classe, c'est définir un plan (blueprint) pour un type de données. Cela ne crée pas de données, mais définit ce que signifie le nom de la classe : composition d'un objet et opérations possibles.

Les objets sont des instances d'une classe. Les méthodes et variables constitutives sont les membres de la classe.

Définition d'une classe

Syntaxe :

<specificateur_accès> class nom_classe
{
    // variables membres
    <specificateur_accès> <type> variable1;
    <specificateur_accès> <type> variable2;
    ...
    
    // méthodes membres
    <specificateur_accès> <type_retour> methode1(liste_paramètres)
    {
        // corps méthode
    }
    ...
}

Notes :

• Accès par défaut classe : internal ; membres : private
• Accès aux membres via l'opérateur point .

Exemple simple : classe Box

using System;

namespace ApplicationBoite
{
    class Boite
    {
        public double longueur;
        public double largeur;
        public double hauteur;
    }
    
    class TestBoite
    {
        static void Main(string[] args)
        {
            Boite b1 = new Boite();
            Boite b2 = new Boite();
            double volume = 0.0;
            
            // Boîte 1
            b1.hauteur = 5.0; b1.longueur = 6.0; b1.largeur = 7.0;
            volume = b1.hauteur * b1.longueur * b1.largeur;
            Console.WriteLine("Volume Boîte 1 : {0}", volume);
            
            // Boîte 2
            b2.hauteur = 10.0; b2.longueur = 12.0; b2.largeur = 13.0;
            volume = b2.hauteur * b2.longueur * b2.largeur;
            Console.WriteLine("Volume Boîte 2 : {0}", volume);
            
            Console.ReadKey();
        }
    }
}

Résultat :

Volume Boîte 1 : 210
Volume Boîte 2 : 1560

Fonctions membres et encapsulation

Les variables membres (attributs) sont gardées private pour l'encapsulation. L'accès se fait via des méthodes publiques (getters/setters).

Exemple avec encapsulation

using System;

namespace ApplicationBoite
{
    class Boite
    {
        private double longueur;
        private double largeur;
        private double hauteur;
        
        public void DefinirLongueur(double len) { longueur = len; }
        public void DefinirLargeur(double bre) { largeur = bre; }
        public void DefinirHauteur(double hei) { hauteur = hei; }
        public double ObtenirVolume() { return longueur * largeur * hauteur; }
    }
    
    class TestBoite
    {
        static void Main(string[] args)
        {
            Boite b1 = new Boite();
            Boite b2 = new Boite();
            double volume;
            
            b1.DefinirLongueur(6.0); b1.DefinirLargeur(7.0); b1.DefinirHauteur(5.0);
            b2.DefinirLongueur(12.0); b2.DefinirLargeur(13.0); b2.DefinirHauteur(10.0);
            
            volume = b1.ObtenirVolume();
            Console.WriteLine("Volume Boîte 1 : {0}", volume);
            
            volume = b2.ObtenirVolume();
            Console.WriteLine("Volume Boîte 2 : {0}", volume);
            
            Console.ReadKey();
        }
    }
}

Constructeurs

Fonction membre spéciale exécutée à la création d'un objet. Même nom que la classe, pas de type retour.

Constructeur par défaut

public Ligne()
{
    Console.WriteLine("Objet en cours de création");
}

Constructeur paramétré

public Ligne(double len)
{
    Console.WriteLine("Objet créé, longueur = {0}", len);
    longueur = len;
}

Destructeurs

Exécuté quand l'objet sort de portée. Nom de classe préfixé par ~, pas de retour, pas de paramètres.

~Ligne()
{
    Console.WriteLine("Objet en cours de suppression");
}

Membres statiques

Mot-clé static : une seule copie partagée par toutes les instances.

Variables statiques

public static int compteur;
public void Incrementer() { compteur++; }
public int ObtenirCompteur() { return compteur; }

Méthodes statiques

Accèdent seulement aux membres statiques. Existent avant création d'objet.

public static int ObtenirCompteur() { return compteur; }
// Appel : MaClasse.ObtenirCompteur();