TP Programmation Orientée Objets   

TP n°1 
Premiers Pas en programmation Objets 
Licence mention ISIL, semestre 4 
 

Exercice 1 ‐ Créer un premier programme avec C# 2008 
Pour créer un premier programme avec C# 2008, on pourra procéder comme suit, après avoir 
lancé C# : 
1) prendre l'option File / New Project 
2) choisir une application de type Console 
3) donner un nom au projet ‐ il va être changé ci‐dessous 
4) valider 
• création du nouveau projet 
• le projet créé 
• Program.cs est le programme C# généré par défaut dans le projet. 

 
5) sauvegarder le projet dans un dossier précis. 
6) donner un nouveau nom au projet,  
7) préciser son dossier.  
8) Sélectionner un emplacement pour la sauvegarde du projet. Ici, le projet sera au final dans 
le dossier [C:\temp\08-01-31\MyApplication1]. 
9) en cochant [9], on peut créer un dossier pour la solution nommée dans [10]. Si Solution1 est 
le nom de la solution : un dossier [C:\temp\08-01-31\Solution1] sera créé pour la 
solution Solution1 
• un dossier [C:\temp\08‐01‐31\Solution1\MyApplication1] sera créé pour le projet 
MyApplication1. Cette solution convient bien aux solutions composées de plusieurs 
projets. Chaque projet aura un sous‐dossier dans le dossier de la solution. 
 

1 

 
     TP Programmation Orientée Objets   

 
 

 
 
le dossier windows du projet  son contenu  le projet dans l'explorateur de 
MyApplication1  projets de Visual Studio 
 

1.1 Ecrire votre premier programme 

1. A l’intérieur de la fonction Main qui se trouve dans le fichier Program.cs, taper la

lettre C de Console. Qu’est ce que vous remarquez ?
2. Taper le « on » de Console et cliquer sur Tab, Entrer, or la barre d’espace pour
sélectionner Console. Main ressemblera à :

static void Main(string[] args)

{
Console
}

3. Taper un point après Console. Une autre liste apparaît pour afficher les méthodes,
propriétés, et champs de la classe Console. Parcourir la liste jusqu’à WriteLine.
Main ressemblera à :
4. Taper une parenthèse ouvrante. La liste affiche les paramètres de WriteLine.
2 

 
     TP Programmation Orientée Objets   

5. Taper une parenthèse fermante suivie d’un point virgule.

6. Taper la chaîne de caractères "Mon premier Programme avec C# 2008" entre les
parenthèses.

1. using System;
2.
3. namespace ConsoleApplication1{
4. class Program {
5. static void Main(string[] args) {
6. Console.WriteLine("Mon premier Programme avec C# 2008");
7. Console.ReadKey();
8. }
9. } 
10. } 
 

1.2 Construire et exécuter l’application 

1. Dans le menu Build, cliquer sur Build Solution.  
2. Dans le menu Debug, cliquer sur Start Without Debugging. 
3. Dans  le  volet  Solution  Explorer,  cliquer  sur  le  projet  ConsoleApplication1 puis 
sur le bouton Show All Files.  
4. Cliquer  sur  le  +  de  l’entrée  bin  puis  sur  le  +  de  l’entrée  Debug :  le  fichier 
ConsoleApplication1.exe est le programme compilé, il est exécuté lorsque Start 
Without  Debugging  est  lancé.  Les  deux  autres  fichiers  contiennent  des  informations 
utilisées par Visual Studio 2008 pour une exécution en mode Debug mode.  

1.3 Etude de la structure et de la syntaxe du programme 

− A quoi sert la directive using ? Pourquoi est‐elle nécessaire dans le cas présent ?
− Que représente la ligne 3 du code ? 
− A quoi sert la méthode Main ?
− Pourquoi appeler ReadKey à la fin de la méthode Main ?

3 

 
     TP Programmation Orientée Objets   

Rappel de syntaxe 
 
En C#, une classe sera toujours définie de la manière suivante : 
public class Personne
{
//Déclaration des attributs (ou champs)
...
//Déclaration des contructeurs
...
//Déclaration des méthodes
...
} 
 
− Champs 
Les champs représentent les « variables » traduisant l’état de l’objet. Ces variables 
peuvent être de toutes natures : des entiers, des chaînes de caractères, des listes, 
d’autres objets, etc. Par convention, leur nom commence toujours par une 
minuscule.  
Dans le cas de la classe Personne, nous allons déclarer les champs suivants : nom,
prenom, age et numéro de téléphone : 
 
public class Personne
{
private string nom;
private string prenom;
private int age;
private int telephone;
}

− Constructeurs 
Un constructeur est une fonction appelée au moment de la création d’un objet. Il 
permet d’initialiser correctement cet objet, éventuellement à partir de paramètres. 
Une classe peut avoir un ou plusieurs constructeurs. Par défaut, la classe ne contient 
que le constructeur sans argument (qui peut être redéfini dans la définition de la 
classe). 
 
Le  mot  clef  this  est  une  référence  sur  l’instance  courante.  Elle  permet  d’accéder  à 
l’objet appelant depuis la méthode et aussi d’éviter les confusions lorsque deux variables 
ont  le  même  nom.  Par  exemple,  dans  le  deuxième  constructeur,  le  fait  d’écrire 
this.nom permet de ne pas confondre le champ nom de l’objet Personne avec la 
variable nom passée en paramètre pour l’initialisation. Le troisième constructeur est un 
constructeur  particulier  dans  le  sens  ou  il  crée  un  objet  Personne  en  copiant  les 
informations  contenues  dans  un  autre  objet  Personne.  On  appelle  cela  un 
constructeur par copie. 
4 

 
     TP Programmation Orientée Objets   

 
public class Personne
{
//Attributs
private string nom;
private string prenom;
private int age;
private int telephone;
//Constructeurs
public Personne(){} //Constructeur par défaut
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 premier constructeur est aussi un peu particulier vu qu’il ne prend aucun paramètre 
en entrée. Il est cependant essentiel de le définir afin d’éviter les surprises au moment 
de  l’exécution  et  il  est  aussi  utile  si  on  définit  une  classe‐fille  comme  nous  le  verrons 
ultérieurement. 
 
L'accès est public ou private selon que le champ ou le constructeur sera visible ou 
non par les autres classes.  
 
Une fois la classe Personne définie, on peut déclarer des références à des objets de type 
Personne grâce à l'instruction  
Personne p;
La création de l'objet proprement dit se fait à l'aide d'un constructeur avec l'instruction  
p=new Personne();

5 

 
     TP Programmation Orientée Objets   

Exercice 2 ‐ Équations du second degré à coefficients réels 
 

On veut écrire un programme permettant de résoudre les équations du second degré à 
coefficients réels : Ax2+Bx+C=0.

1. Écrire une classe Equation avec les propriétés coefficients (a, b, c), discriminant 
(delta) et racines (r1 et r2). Ces propriétés suffisent‐elles à décrire les équations 
du second degré à coefficients réels du monde mathématique? 

2. Écrire un constructeur qui permette d'initialiser les coefficients. 

3. On veut ajouter le comportement calculRacines aux instances de la classe 
Equation. Cette méthode doit calculer le discriminant puis les racines et affecter 
leurs valeurs aux attributs delta, r1 et r2.   

Remarque : on ne s'intéresse qu'aux racines réelles. Si l'équation possède une racine 
double, on affecte la même valeur aux deux attributs r1 et r2. 

4. Écrire une méthode ToString qui convertit une instance en chaîne de caractères. 
Cette méthode doit avoir le comportement suivant : 

− Si les racines n’ont pas été calculées, ToString renvoie par exemple la chaîne 
de caractères : 
Equation 2*x^2 + 3*x + 1 = 0.  Racines -1 et -0.5 
− Si le discriminant est positif, ToString renvoie par exemple la chaîne de 
caractères : 
Equation 2*x^2 + 3*x + 1 = 0.  Racines -1 et -0.5 
− Si le discriminant est strictement négatif, ToString renvoie par exemple la 
chaîne de caractères : 
Equation 1*x^2 + 1*x + 4 = 0. Pas de racine réelle. 
 

Remarque : on appelle toujours ToString la méthode qui convertit une instance en 
chaîne de caractères. 

5. Écrire une classe Probleme contenant la méthode Main. Dans cette méthode, créer 
une instance monEquation de la classe Equation puis, en utilisant les méthodes de 
cette instance, afficher l'équation, calculer ses racines et afficher les. 

6. Dans la méthode Main, on insère l'instruction monEquation.a=0; après le calcul des 
racines de monEquation. Le résultat affiché est‐il juste? 
6 

 
     TP Programmation Orientée Objets   

Qu'est‐ce que l'encapsulation ? Pour empêcher le type de problème que l'on vient de 
rencontrer,  on  rend  systématiquement  inaccessible  les  attributs  des  instances  d'une 
classe par les instances des autres classes. Plutôt que de spécifier l'accès  public lors 
de  la  définition  d'un  attribut,  on  spécifie  toujours  l'accès  private.  On  dit  que  les 
attributs sont encapsulés, comme si elles étaient protégées par une capsule. 

7. Modifier en private l'accès aux attributs de la classe Equation. 

8. On veut néanmoins pouvoir lire et modifier (accès en lecture/ écriture) chacun des 
coefficients d'une équation et on veut pouvoir lire le discriminant et les racines. 

Comment accéder aux attributs ? Comme il est maintenant impossible de lire ou de 
modifier les propriétés directement, on ajoute des méthodes d'instances qui ont 
uniquement pour rôle de permettre de lire ou de modifier certains des attributs.  

− On appelle accesseur une méthode qui permet de lire un attribut. 
L’identificateur d’un accesseur commence toujours par get. Par exemple, 
l'accesseur de delta se nommera getDelta. 

− On appelle modifieur une méthode qui permet de modifier un attribut. 
L'identificateur d'un modifieur commence toujours par set. Par exemple, le 
modifieur de a se nommera setA. 

Écrire les modifieurs et accesseurs nécessaires. Quelle instruction faut‐il ajouter dans 
les modifieurs des coefficients pour éviter le bug de la question 6 ? 

Remarque : vous pouvez aussi utiliser les propriétés qui sont des membres offrant 
un mécanisme souple pour la lecture, l'écriture ou le calcul des valeurs de champs 
privés (voir support de TP). 

Interface  d'un  objet  :  on  appelle  interface  d'un  objet  tout  ce  qui  permet  d'interagir  avec 
celui‐ci. Comme les attributs  doivent toujours être  spécifiés  avec l'accès private, seules 
les méthodes avec accès public permettent d'interagir avec l'objet. L'interface d'un objet 
est donc définie par ses méthodes publiques. 

7