Classes (Visual C# Express)
Mise à jour : novembre 2007
C# est un langage de programmation orienté objet, et tout comme d'autres langages modernes, il regroupe des champs, méthodes, propriétés et événements connexes dans des structures de données appelées des classes.
Classes et objets
Une classe est fondamentalement une ébauche de type de données personnalisé. Une fois que vous définissez une classe, vous l'utilisez en la chargeant dans la mémoire. Une classe qui a été chargée dans la mémoire est appelée un objet ou une instance. Vous créez une instance d'une classe à l'aide du mot clé C# new.
Voici un exemple de définition de classe appelée SampleClass, et la création d'un objet appelé sampleClass1, qui est une instance de cette classe. Parce que C# requiert que la fonction Main soit définie à l'intérieur d'une classe, le code suivant définit également une classe Program, mais cette classe n'est pas utilisée pour créer un objet.
using System;
class SampleClass
{
public void SayHello()
{
Console.WriteLine("Hello, World!");
}
}
class Program
{
//Main is the entrypoint, where every C# program starts
static void Main(string[] args)
{
SampleClass sampleClass1 = new SampleClass(); // Create an object
sampleClass1.SayHello(); // Call a method
}
}
Tout comme vous pouvez générer un nombre quelconque de maisons selon le même plan, vous pouvez instancier n'importe quel nombre d'objets de la même classe. Il est très fréquent d'avoir des tableaux ou des listes qui contiennent de nombreux objets de la même classe. Chaque instance de la classe occupe un espace mémoire séparé et les valeurs de ses champs (sauf ses champs statiques, comme illustré ci-après) sont séparées et indépendantes. Dans l'exemple de code ci-après, vous pourriez créer un objet de type Animal et définir sa taille à 2, et un autre objet dont vous définissez la taille à 3. Toutefois, il y a une exception importante à cette règle, le membre statique.
Membres statiques et d'instance
Un membre statique est une méthode ou champ auquel il est possible d'accéder sans référence à une instance particulière d'une classe. La méthode statique la plus courante est Main, qui est le point d'entrée pour tous les programmes C#. Notez que vous n'avez pas besoin de créer une instance de la classe conteneur pour appeler la méthode Main. Une autre méthode statique communément utilisée est WriteLine dans la classe Console. Notez la différence de syntaxe lors de l'accès aux méthodes statiques ; vous utilisez le nom de la classe, pas le nom de l'instance, sur le côté gauche de l'opérateur point : Console.WriteLine.
Lorsque vous déclarez une classe comme étant un champ statique, toutes les instances de cette classe « partagent » ce champ. Si size dans l'exemple de code suivant était déclaré comme étant statique, et qu'un objet Animal modifiait la valeur, la valeur serait modifiée pour tous les objets de type Animal.
Une classe statique est une classe dont les membres sont tous statiques. Les classes, méthodes et champs statiques sont utiles dans certains scénarios pour des raisons de performance et d'efficacité. Toutefois, de légères erreurs peuvent survenir si vous supposez qu'un champ est un champ d'instance alors qu'en fait, il est statique. Pour plus d'informations, consultez Classes statiques et membres de classe statique (Guide de programmation C#).
Classes et fichiers
Chaque programme C# possède au moins une classe. Lors de la conception de votre programme, il est conseillé, sans être obligatoire, de conserver une seule classe dans chaque fichier de code source (.cs). Si vous utilisez l'environnement de développement intégré C# (IDE) pour créer des classes, celui-ci créera automatiquement en même temps un nouveau fichier de code source à votre intention.
Encapsulation
Une classe représente en général les caractéristiques d'une chose, et les actions qu'elle peut exécuter. Par exemple, pour représenter un animal sous la forme d'une classe C#, vous pouvez lui donner une taille, une vitesse et une force représentées par des nombres, et certaines fonctions telles que MoveLeft(), MoveRight(), SpeedUp(), Stop(), et ainsi de suite, dans lequel vous écrivez le code pour faire en sorte que votre « animal » effectue ces actions. En C#, votre classe d'animal aurait l'aspect suivant :
public class Animal
{
private int size;
private float speed;
private int strength;
public void MoveLeft() // method
{
// code goes here...
}
// other methods go here...
}
Si vous parcourez .NET Framework Class Library, vous verrez que chaque classe représente une « chose », telle que XmlDocument, String, Form, et que chaque chose a différentes actions qu'elle peut effectuer (méthodes), des caractéristiques que vous pouvez lire et peut-être modifier (propriétés) et des notifications (événements) qu'elle envoie lorsqu'elle effectue une action donnée. Les méthodes, propriétés et événements, ainsi que toutes les autres variables internes et constantes (champs), sont désignées par le nom de membres de la classe.
Le regroupement des membres en classes est non seulement logique, mais il permet également de masquer des données et des fonctions que vous ne voulez pas être accessibles à d'autre code. Ce principe est l'encapsulation. Lorsque vous parcourez les bibliothèques de classes .NET Framework, vous voyez uniquement les membres publics de ces classes. Chaque classe a probablement également des membres privés qui sont utilisés en interne par cette classe ou les classes qui lui sont associées, mais qui ne sont pas censés être utilisés par les applications. Lorsque vous créez vos propres classes, vous décidez quels membres doivent être publics, et quels doivent être privés.
Héritage
Une classe peut hériter d'une autre classe, ce qui signifie qu'elle inclut tous les membres, publics et privés, de la classe d'origine, plus les membres supplémentaires qu'elle définit. La classe d'origine s'appelle classe de base et la nouvelle classe s'appelle classe dérivée. Vous créez une classe dérivée pour représenter quelque chose qui est un type plus spécialisé de la classe de base. Par exemple, vous pourriez définir une classe Cat qui hérite d'Animal. Un Cat peut faire tout ce qu'un Animal peut faire, plus une action. Le code C# présente l'aspect suivant :
public class Cat : Animal
{
public void Purr()
{
}
}
La notation Cat : Animal indique que Cat hérite d'Animal et que par conséquent, Cat a également une méthode MoveLeft et les trois variables privées, size, speed et strength. Si vous définissez une classe SiameseCat qui hérite de Cat, elle aura tous les membres de Cat plus tous les membres d'Animal.
Polymorphisme
Dans le domaine de la programmation informatique, le polymorphisme fait référence à la capacité d'une classe dérivée de redéfinir ou de substituer, des méthodes qu'elle hérite d'une classe de base. Vous procédez ainsi lorsque vous avez besoin de faire quelque chose de spécifique dans une méthode qui est différente ou non définie dans la classe de base. Par exemple, la méthode Animal.MoveLeft, puisqu'elle doit être très générale pour être valide pour tous les animaux, est probablement très simple : par exemple, « changer l'orientation de façon à ce que la tête de l'animal pointe dans la direction X ». Toutefois, ce n'est peut-être pas suffisant dans votre classe Cat. Vous pouvez avoir besoin de préciser la façon dont le Cat déplace ses pattes et sa queue pendant qu'il tourne. Et si vous avez également défini une classe Fish ou Bird, vous devrez probablement substituer la méthode MoveLeft de différentes façons pour chacune de ces classes. Puisque vous pouvez personnaliser le comportement de la méthode MoveLeft pour votre classe particulière, le code qui crée votre classe et appelle ses méthodes n'a pas de méthode séparée pour chaque animal du monde. Tant que l'objet hérite d' Amimal, le code appelant peut appeler juste la méthode MoveLeft et la propre version de l'objet de la méthode sera appelée.
Constructeurs
Chaque classe a un constructeur : une méthode qui partage le même nom que la classe. Le constructeur est appelé lorsqu'un objet est créé selon la définition de classe. Les constructeurs définissent généralement les valeurs initiales des variables définies dans la classe. Ceci n'est pas nécessaire si les valeurs initiales doivent être zéro pour les types de données numériques, false pour les types de données Booléens, ou null pour les types référence, car ces types de données sont initialisés automatiquement.
Vous pouvez définir des constructeurs avec n'importe quel nombre de paramètres. Les constructeurs qui n'ont pas de paramètres sont appelés constructeurs par défaut. L'exemple suivant définit une classe avec un constructeur par défaut et un constructeur qui prend une chaîne, puis utilise chacun des éléments suivants :
class SampleClass
{
string greeting;
public SampleClass()
{
greeting = "Hello, World";
}
public SampleClass(string message)
{
greeting = message;
}
public void SayHello()
{
System.Console.WriteLine(greeting);
}
}
class Program
{
static void Main(string[] args)
{
// Use default constructor.
SampleClass sampleClass1 = new SampleClass();
sampleClass1.SayHello();
// Use constructor that takes a string parameter.
SampleClass sampleClass2 = new SampleClass("Hello, Mars");
sampleClass2.SayHello();
}
}
Surcharge d'opérateur
La création de méthodes différentes portant le même nom, dans l'exemple antérieur SampleClass(), est appelée surcharge. Le compilateur sait quelle méthode utiliser parce que la liste d'arguments, si elle existe, est fournie à chaque fois qu'un objet est créé. Les surcharges peuvent rendre votre code plus souple et plus lisible.
Destructeurs
Vous connaissez peut-être déjà les destructeurs si vous avez utilisé C++. À cause du système de garbage collection automatique en C#, il est peu probable que vous deviez implémenter un destructeur à moins que votre classe utilise des ressources non managées. Pour plus d'informations, consultez Destructeurs (Guide de programmation C#).
Structures
Un struct est une sorte de type qui est à bien des égards semblable à une classe, mais qui ne prend pas en charge l'héritage. Pour plus d'informations, consultez Structures (Visual C# Express).
Voir aussi
Tâches
Comment : appeler une méthode sur un objet (Visual C#)
Comment : hériter d'une classe (Visual C#)