Cours programmation objet, tutoriel & guide de travaux pratiques C/C++ en pdf.

Notion de classe

Dans la suite de ce cours, nous allons considérer a` titre illustratif une classe Personne dont on veut stocker les nom, prénom, age et numéro de telephone tout ´etant capable de modifier et d’afficher ces informations.
Généralités
De mani`ere formelle, une classe d´eclare un ensemble d’injonctions communes a` une famille d’objets (des attributs pour l’´etat de l’objet et des m´ethodes repr´esentant le comportement de l’objet). Un bon exemple de classe existante est la classe string ou encore la classe list.
En C#, une classe sera toujours d´efinie de la mani`ere suivante :
public class Personne
{
//D´eclaration des champs
…
//D´eclaration des contructeurs
…
//D´eclaration des m´ethodes
…
}
Champs
Comme dit plus haut, les champs repr´esentent les « variables » traduisant l’´etat de l’objet (comme avec les champs des structures). Ces variables peuvent ˆetre de toutes natures : des entiers, des chaˆınes de caract`eres, des listes, d’autres objets, etc. . . Par convention, leur nom commencent toujours par une minuscule.
Dans le cas de notre classe personne, nous allons d´eclarer les champs sui-vants : nom, pr´enom, age et num´ero de t´el´ephone :
public class Personne
{
private string nom;
private string prenom;
private int age;
private int telephone;
}
Le mot clef public devant le mot clef class indique que la classe Personne est accessible depuis n’importe quelle partie du programme. Elle aura aussi son importance au moment ou nous aborderons l’h´eritage.
Le mot clef private devant les champs indique ici que ces variables ne sont pas accessibles en dehors de la classe personne. Un programmeur utilisant la classe personne ne pourra donc pas utiliser ces variables directement dans d’autres fonction sauf si private est remplac´ par le mot clef public. Si aucun mot clef n’est pr´ecis´e, private sera ajout´e par d´efaut `a la compilation.
Constructeurs
Un contructeur est une fonction appell´ee au moment de la cr´eation d’un objet `a partir d’une classe. Il permet d’initialiser correctement cet objet, ´eventuellement `a partir de param`etres.
Plusieurs contructeurs peuvent ˆetre d´efinis.
public class Personne
{
//Champs
private string nom;
private string prenom;
private int age;
private int telephone;
//Constructeurs
public personne(){} //Constructeur par d´efaut
public personne(string nom, string prenom,
int age, int telephone)
{
this.nom = nom;
this.prenom = prenom;
this.age = age;
this.telephone = telephone;
}
public personne(personne p)
{
this.nom = p.nom;
this.prenom = p.prenom;
this.age = p.age;
this.telephone = p.telephone;
}
}
Le mot clef this est une r´ef´erence sur l’instance courante. Elle permet d’acc´eder `a l’objet appelant depuis la m´ethode et aussi d´eviter les confusions lorsque deux variables ont le mˆeme nom. Par exemple, dans le deuxi`eme constructeur, le fait d’´ecrire this.nom permet de ne pas confondre le champ nom de l’objet personne avec la variable nom pass´ee en param`etre pour l’initialisation. Le troisi`eme constructeur est un constructeur particulier dans le sens ou il cr´ee un objet per-sonne en copiant les informations contenues dans un autre objet personne. On appelle cela un constructeur par copie.
Le premier constructeur est aussi un peu particulier vu qu’il ne prend aucun param`etre en entr´ee. Il est cependant essentiel de le d´efinir afin d’´eviter les surprises au moment de l’ex´ecution et il est aussi utile si on d´efinit une classe-fille comme nous le verrons ult´erieurement.
Propriétés
Nous avons vu qu’en rendant les champs priv´es, un programmeur utilisateur de la classe personne ne pourra pas lire, ni ´ecrire de valeur dans ces variables. Le comportement de l’objet devient alors ´equivalent a` celui d’une boite noire dont on ne peut pas connaitre l’´etat interne. Cependant, il se peut que le program-meur ait besoin de connaitre ces informations et ait aussi besoin de les mettre a` jour. Pour ´eviter de violer le principe d’encapsulation, nous allons donc d´efinir des moyens d’acc´eder a` ces variables a` travers des propri´et´es. Une propri´et´ permet de d´efinir des acc`es en consultation (get ) et en modification (set ). Un acc`es en consultation ou en modification est possible uniquement si le get ou set correspondant est d´efinie.
La syntaxe d’une propri´et´ se d´efinit de la mani`ere suivante :
public int Age
{
get
{
return this.age;
}
set
{
this.age = value;
}
}
Le mot clef public indique bien que la propri´et´ peut ˆetre utilis´ee dans n’im-porte quelle partie du code et que le mot clef int indique bien que get renvoie une valeur de type int et que set attend une valeur de type int.
Un autre exemple avec le champ nom :
public string Nom
{
get
{
return this.nom;
}
set
{
if (value == null || value.Trim().Length == 0)
{
Console.WriteLine(« Nom Invalide »);
nom = null;
}
else
{
nom = value;
}
}
}
Ici, pour ´eviter qu’une erreur ne survienne au moment de l’execution, il vaut mieux v´erifier que la param`etre pass´e a` set soit effectivement initialis´e et qu’il ait une longueur sup´erieure a` 0.
Méthodes
Les m´ethodes sont des « sous-porgrammes » propres a` agir sur les objets d’une classe. Elles sont assimilables a` des fonctions sauf qu’elles sont g´en´eralement appel´es par des objets et agissent potentiellement sur eux.
Méthodes d’instance
Ces m´ethodes d´ecrivent des op´erations effectu´ees sur une instance parti-culi`ere de la classe (c’est-`a-dire sur un seul objet).
Un bon exemple est la m´ethode de la classe string (chaˆınes de caract`eres) ToLower() qui permet de passer toutes les lettres d’une chaˆıne en minuscules de la fa¸con suivante :
string s = new string(« Une souris Verte
qui Courait dans l’herBe »);
s = s.ToLower();
Cette op´eration va transformer le contenu de s en : une souris verte qui courait dans le pr´e.
Champs, méthodes et propriétés de classe
Les champs de classe sont des champs que les objets d’une mˆeme classe vont partager. De mˆeme, les m´ethodes et les propri´et´es de classe sont des m´ethodes qui vont affecter l’ensemble des objets d’une classe.
Reprenons notre classe Personne. Nous aimerions disposer d’un compteur permettant de connaitre en permanence combien d’instances de Personne il existe. Il suffit alors de d´eclarer un champ d’instance de la mani`ere suivante :
private static int nbPersonne;
Remarquez au passage le mot clef static qui indique que ce champ est un champ de classe.
Il faut alors red´efinir les constructeur de la mani`ere suivante :
public class Personne
{
//Constructeurs
public personne(){nbPersonne++;} //Constructeur par d´efault
public personne(string nom, string prenom,
int age, int telephone)
{
this.nom = nom;
this.prenom = prenom;
this.age = age;
this.telephone = telephone;
nbPersonne++;
}
public personne(personne p)
{
this.nom = p.nom;
this.prenom = p.prenom;
this.age = p.age;
this.telephone = p.telephone;
nbPersonne++;
}
}
De mani`ere a` acc´eder a` la variable nbPersonne, on d´efinit une propri´et´ de classe permettant un acc`es en lecture seule. En effet, il est pr´ef´erable de ne pas laisser de possibilité au programmeur de modifier cette variable autrement qu’en cr´eant diff´erentes personnes.

……..