Programmation C sharp/Les classes
La notion de classe est à la base de la programmation orientée objet. Elle définit un type d'objet. Ce type rassemble des variables (créées pour chaque objet et appelées « attributs ») et des fonctions (appelées dans ce cas « méthodes »).
Ces attributs et méthodes sont les « membres » de la classe. Ils peuvent avoir chacun un niveau de protection différent.
Déclarer une classe[modifier | modifier le wikicode]
La déclaration d'une classe utilise le mot clé class :
class nom_de_la_classe
{
}
Les membres sont définis à l'intérieur des accolades.
Exemple :
class Fraction
{
int numerateur,
denominateur;
void multiplier(Fraction autre)
{
this.numerateur *= autre.numerateur;
this.denominateur *= autre.denominateur;
}
}
Membres d'une classe[modifier | modifier le wikicode]
Les membres d'une classe sont de différents types :
- Les fonctions, appelées méthodes, traitent les données, appellent d'autres méthodes, retournent éventuellement une valeur ;
- Les variables, appelées attributs, stockent les données ;
- Les propriétés sont des méthodes spéciales utilisées comme des variables.
Membres statiques de classe et membres d'instance[modifier | modifier le wikicode]
Un membre statique de classe est un membre déclaré avec le mot clé static. Il est défini une seule fois en mémoire, et il n'est pas nécessaire de créer un nouvel objet pour qu'il soit créé et utilisable.
Un membre d'instance est déclaré sans le mot clé static. Il n'est créé que pour chaque objet (une instance) créé par l'opérateur new.
Exemple :
public class UnExemple
{
int numero; // Défini pour chaque objet
static int numero_suivant; // Défini pour la classe
}
Console.WriteLine("N° suivant = " + UnExemple.numero_suivant );
Console.WriteLine("N° = " + UnExemple.numero );
// Erreur de compilation, car la variable n'est pas définie pour la classe
UnExemple InstanceDUnExemple = new UnExemple();
Console.WriteLine("N° = " + InstanceDUnExemple.numero );
Classe statique[modifier | modifier le wikicode]
Une classe statique ne contient que des membres statiques, et ne peut être instanciée. Le mot clé static précède la déclaration de cette classe.
Exemple :
public static class UneClasseStatique
{
public static void Afficher(string message)
{
// ...
}
}
UneClasseStatique.Afficher("Un exemple de message");
Instance d'une classe[modifier | modifier le wikicode]
L'instance d'une classe est aussi appelée un objet. Une variable de ce type est un type référence, c'est à dire que la référence est nulle par défaut. Il faut donc utiliser le mot clé new pour allouer une instance de la classe.
Exemple :
UnExemple objetExemple; // par défaut : null
// Equivaut à UnExemple objetExemple = null;
objetExemple = new UnExemple();
Le mot clé new est suivi du nom de la classe et d'une liste de paramètres entre parenthèses. Il s'agit en fait d'un appel au constructeur (abordé plus loin dans ce chapitre) initialisant l'objet créé.
La référence nulle[modifier | modifier le wikicode]
Toute variable de type objet est en fait une référence initialisée à null par défaut.
Cette référence peut être utilisée quel que soit le type d'objet.
Il est souvent nécessaire de tester si la référence est nulle avant d'accéder à un membre de l'objet référencé. Si le test n'est pas fait et que la référence est nulle, une exception est levée.
Niveaux de protection[modifier | modifier le wikicode]
Le niveau de protection est spécifié par un mot clé placé avant la déclaration d'une classe ou d'un membre de classe (attribut, méthode, propriété, ...) :
public- Accès autorisé à tous ;
private- Accès depuis la classe seulement ;
protected- Accès depuis la classe et ses sous-classes seulement ;
internal- Accès depuis l'assembly seulement.
Exemple :
public class Fraction
{
private int
numerateur,
denominateur;
public void multiplier(Fraction autre)
{ }
}
En général, les règles de l'encapsulation sont les suivantes :
- Toute méthode est publique, à moins qu'elle ne soit destinée à être exclusivement appelée dans la classe, auquel cas est peut être privée ou protégée,
- Les attributs sont privés. Si un accès est nécessaire, il faut ajouter des méthodes d'accès («accesseurs»), voire une propriété.
Constructeur[modifier | modifier le wikicode]
Un constructeur est une méthode spéciale portant le nom de la classe, ne retournant aucune valeur, chargée d'initialiser l'instance. Un constructeur peut avoir des paramètres permettant de définir les valeurs initiales des attributs du nouvel objet.
Une classe possède souvent plusieurs constructeurs. Chacun possédant une liste d'arguments différente.
Exemple[modifier | modifier le wikicode]
Pour initialiser une fraction :
public class Fraction
{
private int
numerateur,
denominateur;
// Constructeur
public Fraction(int numerateur, int denominateur)
{
// this est utilisé pour désigner les attributs de l'objet
// plutôt que les paramètres
// recopie des paramètres :
this.numerateur = numerateur;
this.denominateur = denominateur;
}
public void multiplier(Fraction autre)
{ }
}
Utilisation :
Fraction estimation_pi = new Fraction( 355 , 113 );
Constructeur par défaut[modifier | modifier le wikicode]
Le constructeur par défaut est celui qui n'a aucun paramètre. Si aucun constructeur n'est déclaré dans une classe, le compilateur crée un constructeur par défaut qui ne fait rien, laissant les attributs à leur valeur par défaut (dépendant du type : 0 pour les numériques, null pour tous les autres).
En fait, ce constructeur par défaut appelle le constructeur sans argument (qu'il soit par défaut ou explicitement implémenté) de la classe de base (System.Object par défaut). Voir le chapitre sur l'héritage de classe.
Constructeur statique[modifier | modifier le wikicode]
Il est possible d'exécuter un code lors de la première utilisation de la classe. Cette initialisation peut être vue comme un constructeur statique :
public class Fraction
{
private static int valeur;
static Fraction()
{
valeur = 1;
}
}