Formation Francais

Programmation Orientée Objet
• Formatrice : TOUFELLA Kenza

• Complexe de formation : Hay Ennahda
Powerpoint Templates
Page 1
Introduction à la P.O.O.
La programmation classique
• Dans la programmation traditionnelle un programme

faisait appel à des fonctions ou procédures qui traitaient
des données ou des structures de données.
• Le principe était de trouver l’algorithme puis ensuite de

trouver la structure de donnée la mieux appropriée pour
le passage de paramètre aux différentes fonctions.
Page 2
• Cette programmation rendait la structure de données
« fragile » car n’importe quelle fonction pouvait accéder
et changer les champs de cette structure .
• De plus la réutilisation du code de certaines fonctions

était difficile car rien n’était compartimenté.
Page 3
• La programmation objet ou P.O.O.
• Dans la programmation objet chaque paquets de

données (qui aurait fait parti d’une structure en
programmation classique) est dans une classe.
• Les différents traitements à réaliser sur ces données

sont faits par des fonctions appartenant à la classe.
L’accès aux données ne se fera que par des fonctions
de la classe. Le fait de compartimenter le code et les
données dans une classe permet la réutilisation du code.
Page 4
Exemples :
Classe Bateau :
champs : Capitaine, type, couleur, position, vitesse,…
Fonctions ou méthodes : marche, stop, plus_vite…..
Page 5
Avantages de la P.O.O.
• La découpe du problème en classes et donc en objets

(instances de la classe) permet la réutilisation du code, chose
plus difficile avec un programme classique.
• Une classe peut hériter d’une autre classe ce qui permet

d’utiliser les fonctions et les données de la classe parent et de
rajouter les données et fonctions de la nouvelle classe( en
programmation graphique toute nouvelle fenêtre windows est
un objet hérité de la classe Fenêtre dans laquelle on va
rajouter le code et les données de l’application). Page 6
• Les fonctions de la classe n’ont pas un grand nombre
d’arguments puisque les données sont lisibles par les
fonctions de la classe.
• Les données de la classes sont protégées de l’extérieur :

sécurité.
• Grâce à la P.O.O., on gagne en rapidité de fabrication du

code, puisqu’il est possible d’utiliser un grand nombre de
classe déjà existante.
Page 7
Exemple
• Cahier des charges
• Une personne est décrite par deux informations :

- son nom,
- la société où elle travaille.
• Une personne est capable de s’identifier, en

affichant les informations qui la caractérisent.
Page 8
• Programmation classique, en langage C
#include <stdio.h>
#include <string.h>
struct Personne { /* une personne est décrite par son nom et sa société */
char Nom[25];
char Societe[32];
};
void Presente(struct Personne P)

{ /* ce traitement permet d’afficher la description d’une personne */
printf (« Je m’appelle %s\n », P.Nom);
printf (« Je travaille à %s\n », P.Societe);
}
void main()
{
/* on définit la variable Individu qui décrit une personne /
struct Personne Individu;
/ on initialise cette variable /
strcpy(Individu.Nom, « DURAND »);
strcpy(Individu.Societe, « OUTILS JAVA SA »);
/ on affiche la description de Individu */
Presente(Individu);
}
Page 9
Problèmes
• Les informations qui concernent une personne

ne sont pas protégées.
• En effet, tout utilisateur du type composé

struct Personne est libre de modifier Nom ou
Société sans restriction
Page 10
Les concepts de la
programmation orientée
objet
Page 11
La classe
Page 12
• Une classe est un moule à partir duquel sont construits des
objets.
• Une classe est un ensemble de données et de fonctions

regroupées dans une même entité.
• Les fonctions qui opèrent sur les données sont appelées

des méthodes
• Une classe se compose de :

- un entête (nom)
- un corps (déclaration des données et définition des
méthodes) Powerpoint Templates
Page 13
• Les méthodes peuvent être implémentées sous
forme de procédures ou de fonctions
• Les données et méthodes sont pourvues d’attributs

de visibilité qui gère leur accessibilité par les
composants hors de la classe.
• Une classe décrit la structure des objets.
Page 14
Structure d’une classe
using System;
namespace Chap2
{
Entête public class Personne
{
// attributs
Corps
// méthodes
}
}
Page 15
Conventions d'écriture
• Ces conventions ne sont pas normalisées et peuvent

différer en fonctions des ouvrages consultés.
• Les classes
• Tous les identificateurs de classe commencent par une
Majuscule. Par exemple : Fraction.
• Les propriétés
• Tous les identificateurs public de propriétés commencent
par une majuscule, les propriétés private ou protected
par une minuscule.
• Exemple : privatePowerpoint
denominateur
Templates
(sans accent )
Page 16
• Méthode
• Elle commence par une lettre en majuscule.
• exemple : AjouterVehicule() ; Demarrer() ; InsererFichier
() ; le premier mot est un verbe.
• Les noms de fichiersConvention d’écriture:

• On codera chaque classe d'objet dans des fichiers
différents dont l'extension sera .cs Le nom de fichier sera
identique au nom de la classe.
• Exemple pour la classe Fraction : Fraction.cs

Page 17
Le concept d’objet
Page 18
• Un objet ou instance est un représentant particulier
d’une classe.
• L’objet possède les mêmes attributs et les mêmes

méthodes que les autres instance de la classe.
• Les attributs prennent des valeurs distincts dans

chacune des instances.
• Les données d’un objet sont ses variables d’instance.

Les comportements communs à toutes les instances
sont représentés Powerpoint
par des méthodes
Templates d’instance
Page 19
La visibilité
• privé : Un champ privé (private) n'est accessible que

par les seules méthodes internes de la classe
• Public : Un champ public (public) est accessible par

toute méthode définie ou non au sein de la classe
• protégé : Un champ protégé (protected) n'est accessible

que par les seules méthodes internes de la classe ou
d'un objet dérivé (voir ultérieurement le concept
d'héritage).
Page 20
• En général :
• les données d'une classe sont déclarées privées alors

que ses méthodes et propriétés sont déclarées
publiques.
• Cela signifie que l'utilisateur d'un objet (le programmeur)
- n'aura pas accès directement aux données privées de

l'objet
- pourra faire appel aux méthodes publiques de l'objet et
notamment à celles qui donneront accès à ses données
privées.
Page 21
Les deux acteurs de
la programmation objet
• Le concepteur de la classe X :est celui qui définit X.

dans les méthodes de X, il a directement accès aux
variables d’instance et aux méthodes privées.
• Un utilisateur de la classe X :est aussi un

programmeur mais il n’a directement accès qu’aux
variables et méthodes publiques de X.
Page 22
Le concept d’instanciation
• L’instanciation est l’opération qui consiste

à créer des objets à partir d’une classe
Page 23
L’opérateur new
• Personne p1=new Personne();
• Cela a pour effet de créer un objet de type Personne non

encore initialisé .
Page 24
TP1
Page 25
using System;
namespace Chap2 Classe : Personne

{
public class Personne
{
// attributs
public string prenom;
public string nom;
public int age;
// méthode
public void Affichage()
{
Console.WriteLine(« Prénom :", prenom);
Console.WriteLine(« Nom :", nom);
Console.WriteLine(« Age :", age);
}
}
}
Page 26
using System;
namespace Chap2 Classe : test
{
class test
{
static void Main()
{
Personne p1 = new Personne();
P1.prenom = « souad »;
p1.nom=« mekkaoui »;
P1.age=24;
P1.affichage();
Personne p2 = new Personne();
P2.prenom = « haouda »;
p2.nom=« Alaoui»;
P2.age=32;
P2.affichage();
}
} Powerpoint Templates
} Page 27
EXERCICES
Page 28
• Exercice 1:
• Un salarie est décrit par ses données membres :
• Un matricule (entier)
• Un statut (chaine)
• Un service (chaine)
• Un nom (nom)
• Un salaire (réel)
• Travail à faire :
1 - Codage de la classe Salarie

2- Ajouter une méthode Afficher() qui permet d’afficher
les informations d’un salarié
3- Créer etPowerpoint
afficher un objet type salarie
Templates
Page 29
• Exercice 2:
• Soit la classe module qui modélise un module et qui comportera les

attributs suivants: Référence (chaine) et Intitule (chaine)
• Soit la classe formateur qui modélise un formateur et qui comportera

les attributs suivants :
Matricule (entier), nom (chaine), prénom (chaine), date de
naissance, sexe (char),échelle (entier)
1 - Codage des classes Module et Formateur
2- Ajouter une méthode Afficher() qui permet d’afficher les
informations des objets
3 – Créer et afficher un objet type module et un autre type
formateur Powerpoint Templates Page 30
Le constructeur
Page 31
Le constructeur
• Un constructeur est une méthode qui porte le nom de la
classe et qui est appelée lors de la création de l'objet. On
s'en sert généralement pour l'initialiser.
• C'est une méthode qui peut accepter des arguments mais

qui ne rend aucun résultat. Son prototype ou sa définition ne
sont précédés d'aucun type (pas même void).
• Si une classe X n'a aucun constructeur, elle en a un par

défaut qui est le constructeur sans paramètres : public X().
Page 32
• Il peut y avoir plusieurs constructeurs pour une même
classe, chacun d'eux correspondant à une initialisation
particulière.
• Tous les constructeurs ont le même nom mais se

distinguent par le nombre et/ou le type des paramètres
passés.
• Lorsqu'une classe X a un ou plusieurs constructeurs,

l'un de ces constructeurs doit être obligatoirement utilisé
pour créer un objet de cette classe
Page 33
1- Constructeur par défaut
• Un constructeur est défini par défaut pour chaque classe
si aucun autre constructeur n'est déclaré mais celui-ci ne
peut être invoqué que s’il n’existe aucun autre
constructeur.
• A partir du moment où il existe un constructeur

d'initialisation dans la classe Personne, il devient
impossible de déclarer une instance avec le constructeur
par défaut.
• Le constructeur par défaut initialise les champs type

chaine de caractère par le vide et les champs type
numérique par 0. Powerpoint Templates Page 34
//constructeur par défaut vide
public Personne()
{
}
// instanciation
Personne P1=new Personne() ;

Page 35
2 - Constructeur d'initialisation
• Ce constructeur permet de procéder à une instanciation

en initialisant les propriétés, la valeur de celles-ci étant
passée dans les paramètres ou définie sous forme de
constante dans la classe.
• Il peut exister plusieurs constructeurs d’initialisation avec

plus ou moins d’arguments.
• Pour la classe Client, ce constructeur est déclaré

comme ceci : Page 36
public Personne(String p, String n, int a)
{
This.prenom=p;
This.nom=n;
This.age=a;
}
Cela va permettre d'instancier la classe Personne de

la façon suivante :
Personne p2 = new Personne("Jean", "Dupont", 30);
Page 37
3 - Constructeur de recopie
• Le constructeur de recopie permet de recopier
les propriétés d'un objet existant vers une
nouvelle instance de même type.
Page 38
public Personne(Personne P)
{
This.prenom=P.prenom;
This.nom=P.nom;
This.age=P.age;
}
Instanciation :

Personne p2 = new Personne(p1);
Page 39
EXERCICES
Page 40
• Exercice 1:
• Soit la classe produit caractérisé par son nom (string),

son prix d’achat (double), son prix de vente (double), le
nombre d’exemplaire en stock (int) et sa description
(string).
Page 41
1 - Codage de la classe Produit
2- Ajouter dans la classe Produit :
- une méthode Afficher() qui permet d’afficher les
produits.
- un constructeur d’initialisation qui permet
d’initialiser tous les champs
- un constructeurs de recopie.
3- en utilisant le constructeur d’initialisation créer l’objet

P1 type produit.
4 – en utilisant le constructeur de recopie copier P1 dans
le nouveau objet P2(type produit).
5- Afficher P2. Powerpoint Templates
Page 42
• Exercice 2:
• Un élève peut s’inscrire dans une association scolaire.

pour bénéficier de divers cours de soutiens (math,
français, arabe).
• Lors de l’inscription, l’élève fournit les informations
suivantes :
Code
Nom
Prénom
Date de naissance
Page 43
1- Codage de la classe élève.
2- Ajouter une méthode Afficher().
3- ajouter un constructeur qui initialisent le code et le
nom.
4-ajouter le constructeur qui initialisent les autres
attributs, ce constructeur doit faire appel au premier
constructeur.
5 - Ajouter un constructeur de recopie
6- en utilisant les constructeurs d’initialisation créer l’objet
E1 type élève.
7- en utilisant le constructeur de recopie copier E1 dans le
nouveau objet E2(type élève)
8 – afficher l’objet E2.
Page 44
L’encapsulation
Page 45
Page 46
• L'encapsulation est un concept important de la
Programmation Orientée Objet.
• L’encapsulation n’autorise pas l’accès aux attributs

d’un objet que par l’intérmidiaire de ses traitements
appelés aussi méthodes ou services.
• L’encapsulation permet de garantir l’intégrité des

données contenues dans l’objet.
Page 47
Les accesseurs
et
les modificateur
Page 48
1 - Protection des propriétés
• En Programmation Orientée Objet, on évite d'accéder

directement aux propriétés par l'opérateur « . ».
• Cette possibilité ne correspond pas au concept

d'encapsulation. certains langages l'interdisent
carrément.
Page 49
• Public : Un champ public (public) est accessible par
toute méthode définie ou non au sein de la classe
• Privé : Un champ privé (private) n'est accessible que

par les seules méthodes internes de la classe.
• .
• Protégé : Un champ protégé (protected) n'est accessible
que par les seules méthodes internes de la classe ou
d'un objet dérivé (voir ultérieurement le concept
d'héritage). Powerpoint Templates
Page 50
• Afin d’implanter correctement le concept
d'encapsulation, il convient de verrouiller l'accès aux
propriétés et de les déclarer private ou protected
tout en permettant leur accès via les méthodes de
type Accesseur en déclarant ces dernières public.
Page 51
Exemple :
// attributs
private string prenom;
private string nom;
private int age;
Page 52
2 - Fonctions d'accès aux propriétés
• Si les propriétés sont verrouillées, on ne

peut plus y avoir accès de l'extérieur de la
classe.
• Il faut donc créer des méthodes dédiées à

l'accès aux propriétés pour chacune
d'elles. Ces méthodes doivent permettre
un accès dans les deux sens.
Page 53
• A - Accès pour lecture
• Pour connaître la valeur de la propriété. Ces

méthodes sont appelées méthodes type "Get.".
La réponse de l'objet, donc la valeur retournée
par la méthode Get, doit être cette valeur.
• Par exemple, pour la propriété numeroClient,

déclarée Integer, la fonction Get serait déclarée
de la façon suivante :
Page 54
public String GetNom()
{
return nom;
}
Personne p = new Personne();
p.SetNom (« sarah »);
Console.Out.WriteLine (p.GetNom() );
Page 55
B - Accès pour modification
• Pour modifier la valeur d'une propriété. Ces

méthodes sont appelées méthodes type Set.
• Cette méthode ne retourne aucune réponse.

Par contre, un paramètre de même nature que
la propriété doit lui être indiqué.
• Par exemple, pour la propriété IDClient,

déclarée int, la fonction Set sera déclarée de la
façon suivante :Powerpoint Templates
Page 56
public void SetNom(String N)
{
this.nom = N;
}
p.SetNom (« sarah »);
Console.Out.WriteLine (p.GetNom() );
Page 57
3 - Accès aux attributs membres par les
Property de classe
• Il est préférable de définir les accès aux

attributs d'une classe par des propriétés
Property à la place des méthodes Get et Set.
Elles implémentent deux pseudo méthodes Get
et Set
• Exemple de la classe Client :
Page 58
Class personne
{
Private string nom;
Private string prenom;
……..
Page 59
Public String NomP
{
Get { Return nom ;}
Set { nom = Value ;}
}
Utilisation des proprietés
//Utilisation du Set de la proprieté NomP

p.NomP =« Tijani »
//Utilisation du Get de la la proprieté NomP

Console.Out.WriteLine(p.NomP)
Page 60
EXERCICES
Page 61
• Exercice 1:
• Un élève peut s’inscrire dans une association scolaire.

pour bénéficier de divers cours de soutiens (math,
français, arabe).
• Lors de l’inscription, l’élève fournit les informations
suivantes :
Code
Nom
Prénom
Date de naissance
Page 62
1. - Codage de la classe élève (les attributs sont de type

private)
2. Définir les accesseurs et modificateurs de cette classe.
3. créer deux objets E1 et E2.
4. en utilisant les modificateurs affecter des valeurs aux
attributs des objets et en utilisant les accesseurs
afficher ses attributs
Page 63
• Exercice 2:
• Soit la classe produit caractérisé par son nom, son prix

d’achat, son prix de vente, le nombre d’exemplaire en
stock et sa description.
1. - Codage de la classe Produit (les attributs sont de type
private)
2. Définir les accesseurs et modificateurs.
3. créer l’objet P1 (type produit).
4. en utilisant les modificateurs affecter des valeurs aux
attributs des objets et en utilisant les accesseurs
afficher ses attributs
Page 64
• Exercice 3:
• Un salarie est décrit par ses données membres :
• Un matricule (entier)
• Un statut (chaine)
• Un service (chaine)
• Un nom (nom)
• Un salaire (réel)
1. Codage de la classe Salarie (attributs de type private)

2. Définir des property pour les attributs de cette classe.
3. Créer un objet type salarie
4. en utilisant les property affecter des valeurs aux attributs des
objets et afficher lePowerpoint
contenu de ses attributs
Templates
Page 65
Propriétés et méthodes
de la classe
Page 66
Propriétés de classe
• Jusqu'à présent, les propriétés déclarées étaient des

propriétés d'instance. C'est à dire que les propriétés de
chaque objet, instancié à partir de la même classe,
peuvent avoir des valeurs différentes ( numero, nom, etc ).
• Supposons donc maintenant, que dans la classe

Personne, il soit nécessaire de disposer d'un compteur
d'instance, dont la valeur serait le nombre d'instances en
cours à un instant donné.
Page 67
• On peut inclure le compteur dans la définition de la
classe. Comme c'est un attribut de la classe elle-même
et non celui d'une instance particulière de cette classe,
on le déclare différemment avec le mot clé static :
private static int nbPersonnes

Page 68
• Pour le référencer, on écrit Personne.nbPersonnes pour
montrer que c'est un attribut de la classe Personne elle-même.
• Ici, nous avons créé un attribut privé auquel on n'aura pas

accès directement en-dehors de la classe.
• On crée donc une propriété publique pour donner accès à

l'attribut de classe nbPersonnes Pour rendre la valeur de
nbPersonnes la méthode get de cette propriété n'a pas besoin
d'un objet Personne particulier
• Pour ce compteur, seule la méthode Get est nécessaire.

Page 69
Aussi a-t-on besoin d'une propriété déclarée elle aussi
Static qui de l'extérieur sera appelée avec la syntaxe
Personne.NbPersonnes.
Voici un exemple.
public static int NbPersonnes
{
get { return nbPersonnes; }
}
Page 70
{
// attributs de classe
private static int Compteur;
public static int Compt

{
get { return Compteur; }
}
// attributs d'instance
private string nom;
private int age;
// constructeurs
public Personne(String p, String n, int age)
{
This.prenom=p;
This.nom=n;
This.age=a;
CompteurPowerpoint
++; Templates
} Page 71
static void Main(string[] args)
{
Personne p2 = new Personne(« Ktani", « leila", 30);
Console.WriteLine("Nombre de personnes créées : "

+ Personne. Compt);
}
Le résultat sera : 2
Page 72
Série 1
Page 73
L'Héritage
Page 74
1. Classe de base et sous
classe
• L'héritage est un mécanisme par lequel une classe

dérivée (ou classe fille) hérite de toutes les
caractéristiques de sa classe de base (ou classe mère).
• Lorsqu'une classe ne déclare aucune classe de base,

par défaut elle hérite de la classe System.Object.
• C# ne prend pas en charge l'héritage multiple, ce qui

signifie que les classes ne peuvent pas hériter de
plusieurs classes (Vous pouvez toutefois utiliser des interfaces
dans ce but ) Powerpoint Templates
Page 75
• L'héritage permet de :
 récupérer le comportement standard d'une classe parente
 ajouter des fonctionnalités supplémentaires en créant de

nouvelles propriétés et méthodes dans la classe dérivée
 modifier le comportement standard d'une classe parente en

surchargeant certaines méthodes de la classe parente dans
la classe dérivée. (redéfinir le comportement des méthodes de la
classe de base)
Page 76
Page 77
• Plusieurs classes filles peuvent hériter d’une même
classe mère.
• Une classe fille peut elle-même être la classe mère

d’une nouvelle classe.
• Exemple :
• La classe Employe peut elle-même être la classe mère

des classes Cadre et Ouvrier.
Page 78
Page 79
2. Syntaxe
• Pour exprimer que la classe Enseignant hérite des

propriétés de la classe Personne, on écrira :
public class Enseignant : Personne
Page 80
• Personne la classe parent et Enseignant la classe
dérivée.
• Un objet Enseignant a toutes les qualités d'un objet

Personne (attributs et méthodes).
• Ces attributs et méthodes de la classe parent ne sont

pas répétées dans la définition de la classe fille : on se
contente d'indiquer les attributs et méthodes rajoutés par
la classe fille.
Page 81
3. Constructeurs
• Le constructeur de la sous-classe appelle toujours celui

de la classe de base, implicitement ou explicitement.
• Si rien n'est spécifié, le compilateur génère un appel

implicite au constructeur de la classe de base ne
comportant aucun paramètre « constructeur par
défaut ».
• Si la classe de base ne possède plusieurs constructeurs,

il est possible de spécifier explicitement le constructeur à
appeler. Le mot-clé base désigne la classe de base.
Page 82
Exemple
Page 83
• using System;
• namespace Chap2
• { CLASSE PERSONNE
• public class Personne
• {
• // attributs
• private string prenom;
• private string nom;
• // propriétés
• public string Prenom
• { get { return prenom; }
• set {prenom = value; }
• }
• public string Nom

• { get { return nom; }
• set { nom = value; }
• }
• // constructeur
• public Personne(String n, String p)
• { this.prenom = p;
• this.nom = n;
• } Page 84
• using System;
• namespace Chap2 {
CLASSE ENSEIGNANT
• class Enseignant : Personne
• {
• // attributs
• private int section;
• // propriété Section
• public int Section
• {
• get { return section; }
• set { section = value; }
• }
• // constructeur
• public Enseignant(string p, string n, int s) : base (p, n)

• {
• // on mémorise la section via la propriété Section
• this.section=s;
• } Page 85
Tentons un premier programme de
test [Program.cs] :
• using System;
• namespace Chap2 CLASSE Program
• {
• class Program
• {
• static void Main(string[] args)
• {
• Enseignant e1= new Enseignant("Jean", "Dupont", 30, 27);
• Console.writeline (e1.Nom +" , "+ e1.Prenom +" , " + e1.Section);
• }
• }
• } Powerpoint Templates
Page 86
• La classe Enseignant rajoute aux méthodes et attributs de la
classe Personne :
* un attribut section qui est le n° de section auquel
appartient l'enseignant dans le corps des enseignants. Cet
attribut privé est accessible via la propriété publique
Section.
* un nouveau constructeur permettant d'initialiser tous les
attributs d'un enseignant.
• Une classe fille n'hérite pas des constructeurs de sa classe

Parent. Elle doit alorsPowerpoint
définir ses propres constructeurs.
Templates
Page 87
• En résumé :
• le constructeur d'une classe dérivée :
* passe à sa classe de base les paramètres dont celle-ci

a besoin pour se construire
* utilise les autres paramètres pour initialiser les attributs

qui lui sont propres
Page 88
signature
• Signature d'une méthode =
Visibilité + type de retour + nom + type et nombre des

paramètres
Page 89
Le polymorphisme
Page 90
Polymorphisme
• Le polymorphisme est souvent connu sous le nom de

troisième pilier de la programmation orientée objet, après
l'encapsulation et l'héritage.
• Le nom de polymorphisme vient du grec et signifie

plusieurs formes.
• le polymorphisme est relatif aux méthodes des objets.
• Le polymorphisme se résume par : un même nom,

plusieurs implémentations
Page 91
On distingue généralement trois types de
polymorphisme :
overloading
overriding
Page 92
La Redéfinition d’une méthode
ou d’une propriété
Page 93
La Redéfinition d’une méthode
• Par défaut, une classe dérivée hérite des méthodes de

sa classe de base. Mais si une propriété ou une
méthode doit avoir un comportement différent dans la
classe fille, elle doit y être redéfinie !
Page 94
Redéfinition : « new »
• La redéfinition d'une méthode consiste à créer une

méthode dans une sous-classe ayant le même nom et
les mêmes types d'arguments (la même signature)
qu'une méthode de la classe de base, afin de modifier
son comportement.
Page 95
Exemple
• public class Vehicule
• { Classe Vehicule
• private int poids;
• public Vehicule(int poids)

• {
• this.poids = poids;
• }
• public string Description()

• {
• return "Véhicule de "+poids+" tonnes";
• }
Page 96
• public class Automobile : Vehicule
• { Classe Automobile
• private string couleur;
• public Automobile(int poids,string couleur) : base(poids)

• {
• this.couleur = couleur;
• }
• // méthode redéfinie
• public new string Description()
• {
• return base.Description()+" de couleur "+couleur;
• }
• }
Page 97
Class Program
{
Static void main()
{
Automobile A1 = new Automobile(3, "rouge");
Console.WriteLine( A1.Description() );
}
// affiche : Véhicule de 3 tonnes de couleur rouge
Page 98
Redéfinition : « virtual - override »
• Le polymorphisme permet d'utiliser le type réel de l'objet

référencé plutôt que le type de la référence pour
déterminer la méthode ou la propriété à utiliser.
• Pour cela, il faut utiliser le mot clé virtual dans la

déclaration de la méthode de la classe de base.
Page 99
Exemple :
• public class Vehicule
• {
• private int poids;
• public Vehicule(int poids)

• {
• this.poids = poids;
• }
• public virtual string Description()

• {
• return "Véhicule de "+poids+" tonnes";
• }
• }
Page 100
Et il faut utiliser le mot clé override
dans la classe dérivée :
• public class Automobile : Vehicule
• {
• private string couleur;
• public Automobile(int poids,string couleur) : base(poids)

• {
• this.couleur = couleur;
• }
• // méthode redéfinie
• public override string Description()
• {
• return base.Description()+" de couleur "+couleur;
• }
Page 101
• Automobile A1 = new Automobile(3, "rouge");
• Console.WriteLine(A1.Description() );
• // affiche : Véhicule de 3 tonnes de couleur rouge
Page 102
La Redéfinition d’une propriété
{
• // attributs
• private string nom;
• private int age;
• //constructeur
• public Personne (sting n, int a)
• { this.nom=n; this.age=a}
public string identite
{
get { return "personne : "+_prenom+","+_nom+","+age;}
}
} Powerpoint Templates
Page 103
• class Enseignant : Personne
• {
• // attributs
• private int section;
• // propriété Section
• public int sectionP
• { get{ return section;}
set{ this.section=value;}
}
• //constructeur
• public Enseignant (string n, int a, int s):base (n,a)
• {this.section=s;}
• // propriété Identite
• public new string Identite

• { get { return base.Identite + « ,»+ Section); }
• }
Page 104
• class program
• {
• Enseignant E1 = new Enseignant (« Tazi », 20, 1);
• console.writeline (E1.identite);
• Console.readkey()
• }
Page 105
• la propriété Identite de la classe Enseignant s'appuie sur la
propriété Identite de sa classe mère (base.Identite) pour
afficher sa partie "Personne" puis complète avec le champ
section qui est propre à la classe Enseignant.
• La propriété Identite est définie à la fois dans la classe

Enseignant et sa classe mère Personne.
• Dans la classe fille Enseignant, la propriété Identite doit

être précédée du mot clé new pour indiquer qu'on redéfinit
une nouvelle propriété Identite pour la classe Enseignant.
Page 106
• De façon générale, si O est un objet et M une méthode,
pour exécuter la méthode O.M, le système cherche une
méthode M dans l'ordre suivant :
 dans la classe de l'objet O

 dans sa classe mère s'il en a une
 dans la classe mère de sa classe mère si elle existe
Page 107
• L'héritage permet donc de redéfinir dans la classe fille
des méthodes/propriétés de même nom dans la classe
mère. C'est ce qui permet d'adapter la classe fille à ses
propres besoins.
• la redéfinition de méthodes/propriétés est le principal

intérêt de l'héritage.
Page 108
Exercice
Page 109
Créer la classe Salarie. Cette classe aura 5 propriétés :
matricule (int)
catégorie (string)
service (string)
nom (string)
salaire (double)
1. Ajouter les accesseurs / modificateurs.

2. Implémenter un compteur d'instances pour la classe Salarie
avec sa propriété.
3. Ajouter le constructeur d’initialisation .
4. Ajouter une méthode AfficherSalaire() qui affiche le salaire.
Page 110
• 5. Créer une classe Commercial en dérivant la classe Salarie. Cette
classe aura 1 propriété supplémentaire pour calculer la commission
• commission int
• 6. Créer le constructeur d’initialisation de la classe Commercial.
• 7. Créer les méthodes d'accès aux attributs supplémentaires.
• 8. Redéfinir la méthode AfficherSalaire() pour calculer et afficher le

salaire réel d’un commercial (salaireReel =salaire + commission).
• Dans la classe programme :

• - créer l’objet Com1 type commercial par le constructeur d’initialisation
• - afficher le salaire réel de l’objet Com1.
Page 111
La surcharge
Page 112
• Le polymorphisme de surcharge permet d'avoir
des fonctions de même nom, avec des
fonctionnalités différentes (paramètres de
différents types)
Page 113
• La première méthode additionne 2 entiers et la
deuxième concatène 2 chaînes de caractères
• class Addition
• {
• public void add(int a, int b)
• {
• Console.WriteLine("la somme est :" + (a+b));
• }
• public void add(string a, string b)

• {
• Console.WriteLine(« le résultat est :" + (a + b));
• }
• }
Page 114
• {
• Addition a = new Addition();
• a.add(4, 5);
• a.add("yassir", "sarah");
• Console.ReadKey();
• }
Page 115
Surcharge des constructeurs
• Il peut y avoir plusieurs constructeurs pour une même

classe.
• Tous les constructeurs ont le même nom mais se

distinguent par le nombre et le type des paramètres
passés.
Page 116
• public class Client
• {
• private int numeroClient; // numéro client
• private String nomClient; // nom du client
• // constructeur d’initialisation
• public Client(int numero, String nom)
• {
• numeroClient = numero;
• nomClient = nom;
• }
• // constructeur de recopie
• public Client (Client C)
• {
• numeroClient = C. numeroClient;
• nomClient = C.nomClient ;
• }
Page 117
Question
• Une classe A définit une méthode faire sans paramètre

(void faire() {...}).
• Elle est étendue par une classe B qui définit une

méthode faire avec un paramètre entier (void faire(int n)
{...}.
• Est-ce qu'on utilise ainsi la possibilité de redéfinir une

méthode ou celle de la surcharge ?
Page 118
Réponse
• Il s'agit de la surcharge.
• La classe B possède ainsi la méthode faire sans

paramètre héritée de la classe A
• et la méthode faire avec un paramètre entier définie

dans la classe B.
Page 119
Série 2
Page 120
Classes abstraites et
interfaces
Page 121
Classe abstraite
• Une classe abstraite possède au moins une méthode

abstraite ou une propriété abstraite, c'est à dire ne
comportant aucune implémentation (pas de code).
• Une classe abstraite ne peut pas être instanciée avec

l'opérateur new.
• Il faut utiliser une sous-classe implémentant les

méthodes abstraites de la classe de base.
Page 122
• Une classe abstraite peut contenir des constructeurs pour
faire appeler par ses classes dérivées
( avec base(. . .) )
• Une méthode abstraite est automatiquement virtuelle

(mais on n’a pas le droit de fournir ce mot virtual sur l’en-
tête).
• Ces méthodes abstraites peuvent être toutes ou en partie

redéfinies (override) dans une classe dérivée.
Page 123
Syntaxe
• Le mot clé abstract doit précéder la classe abstraite et

toutes les méthodes abstraites.
• abstract class ClasseMere
• {
• public void Méthode1()
• {
• }
• public abstract void Méthode2();
• méthode "Méthode2", sans arguments et sans valeur de retour. */

Page 124
Implémenter les méthodes abstraites
• La classe implémentant les méthodes abstraites de la

classe de base doit utiliser le mot clé override, car les
méthodes abstraites sont implicitement virtuelles.
• class ClasseFille : ClasseMere

• {
• //override sert à indiquer une redéfinition de méthode.
• public override void Méthode2()
• {
• Console.Out.WriteLine("Méthode2.");
• }
• }
Page 125
• class Program
• {
• public static void Main()

• {
• ClasseFille C1=new ClasseFille();
• C1.Méthode2();
• }
• }
Page 126
Exercice
• Programmez la classe abstraite Figure et ses

classes dérivées, concrètes Cercle et Rectangle.
Page 127
classe abstraite : Figure
1)Méthode abstraite : Perimetre()
2) Méthode abstraite : Surface()
classe Cercle classe Rectangle

(concrête) (concrête)
1) La méthode périmètre renvoie la 1) La méthode périmètre renvoie la
valeur : 2xMath.Pi x rayon valeur : 2 * latgeur * longueur
2) La méthode Surface() renvoie la 2) La méthode Surface() renvoie la
valeur : Math.Pi x rayon 2
Powerpoint valeur : largeur * longueur
Templates
Page 128
Interface
• Une interface ne fait que décrire une liste de méthodes,

sans implémentation. Le code de ces méthodes est
fourni par les classes qui implémentent l'interface.
Page 129
Déclarer une interface
Le mot clé interface sert à déclarer une interface. Il est suivi

par le nom de l'interface, qui par convention commence
généralement par la lettre I (i majuscule comme interface).
Par convention, le nom d'une interface ne comportant

qu'une seule méthode est celui de la méthode suivi du
suffixe "able".
Par exemple, si la seule méthode s'appelle Afficher,

l'interface est nommée IAffichable.
Page 130
public interface IAffichable
{
/* Liste des méthodes que doivent posséder toutes les classes implémentant
l'interface IAffichable : */
void Afficher();
void Afficher(string message);

}
Page 131
Implémenter une interface
• Une interface est implémentée par une classe la

déclarant dans sa liste d'implémentation.
• Cette classe doit alors fournir le code de toutes les

méthodes de l'interface, à moins de déclarer ces
méthodes comme abstraites.
• Dans ce dernier cas, l'implémentation devra être

effectuée par une sous-classe.
Page 132
• public class Personne : Iaffichable
• {
• private string nom, prenom;
• Public Personne (string _nom,_prenom)
{
This.nom=_nom ;
This.prenom=_prenom ;
}
• public void Afficher()
• {
• Console.WriteLine(nom+" "+prenom);
• }
• public void Afficher(string message)
• {
• Console.WriteLine(nom+" "+prenom+" : "+message);
• }
Page 133
public class program
{
public static void main()
{
Personne P1= new Personne (« alami », « houda »);
P1.afficher();
P1.afficher(‘’ Technicienne’’);
Console.readkey();
Page 134
Différence
Classe abstraite et Interface
• Une classe ne peut hériter que d’une seule classe

parente (abstraite ou non), mais elle peut implémenter
plusieurs interfaces. L’interface vient pour résoudre le
problème d'héritage multiple.
• une classe abstraite contient au moins une méthode

sans implémentation alors qu'une interface ne contient
que des méthodes sans implémentation.
Page 135
• Le C# (et aussi Java) ne supporte pas l'héritage
multiple
Classe de Classe de Classe de etc …
base base base
A1 A2 A3
classe dérivée
B
Page 136
• En C# une classe n'a pas le droit d'hériter directement deux classes
de base. Par contre, C# permet à une classe d'être dérivée d'une
seule classe de base mais implémente une ou plusieurs interfaces.
Classe de base interface interface etc

en C# I1 I2
A
sous-classe B
dérivée de A
implémente I1, I2, etc
Page 137
La classe Object
Page 138
La classe Object
• En C#, il est impossible de créer une classe isolée. En

effet, lorsqu'on crée une nouvelle classe sans mentionner
de classe de base, c'est la classe Object , la classe
racine de toutes les classes C#, qui est utilisée.
• Object NewClass
• NewClass est une nouvelle classe insérée dans la

hiérarchie de classes construite à partir de Object.
Page 139
Les méthodes de la classe Object
• Les classes dérivées peuvent substituer certaines

de ces méthodes, notamment :
• Equals
• ToString
• Finalize
• GetHashCode
Page 140
Méthode ToString
• C’est une méthode virtuelle de la classe Object. Le but

de cette méthode est de renvoyer une représentation de
votre classe sous forme d'une chaine de caractères.
• La plupart des classes du Framework redéfinisse cette

méthode afin de donner une description satisfaisante
des objets de cette classe.
Page 141
• class Personne
• {
private string nom;
• public override string ToString()

• {
return String.format("[Personne: {0}{1}]", nom,prenom);
}
Page 142
• Le code que nous avons ajouté est une redéfinition
de la fonction ToString de la classe Object.
• Comme cette fonction est virtuelle dans cette classe,

nous devons utiliser le mot-clé override pour la
redéfinir.
Page 143
Méthode Equals
• La méthode Equals permet de comparer les valeurs

des propriétés de 2 objets. Si celle-ci sont égales la
méthode retourne true sinon false.
• Deux objets sont égaux s’ils ont la même référence
• Equals est une méthode virtuelle, qui permet à

n'importe quelle classe de substituer son
implémentation.
Page 144
Exemple
• class Personne
• { • public Personne(int r,string n)
• private int reference; • {
• this.reference = r;
• public int Reference • this.nom = n;
• { • }
• get { return reference; }
• set { reference = value; }
• } • public override bool Equals(object obj)
• {
• private string nom; • Personne p = (Personne)obj;
• public string Nom • return p.reference==this.reference &&

• { p.nom==this.nom;
• get { return nom; } • }
• set { nom = value; } • }
Page 145
• class Program
• {

• {
• Personne p1 = new Personne(1, "hiba");
• Personne p2 = new Personne(1, "hiba");
• if (p1.Equals(p2))
• {
• Console.WriteLine("égaux");
• }
• else
• {
• Console.WriteLine("inégaux");
• }
• }
Page 146
Exercice
• Créer une classe Equipement caractérisée par son code,

date d’acquisition, état (opérationnel ou non) et prix
d’achat.
• Ajouter des accesseurs pour tous les champs et une
méthode toString() qui renvoie les informations sur
l’équipement sous forme d’une chaine de caractères
• Ajouter un constructeur d’initialisation
• Ajouter une méthode equals qui teste l’égalité des
équipements (2 équipements sont égaux s’ils ont le
même code)
• Écrire un programme test Templates
Powerpoint
Page 147
La gestion des exceptions
Page 148
Gestion des exceptions
• Qu’est ce qu’une exception

• Lancer une exception
• Attraper une exception
• Créer une classe d'exception
Page 149
Qu’est ce qu’une
exception
• De nombreuses fonctions C# sont susceptibles de générer
des exceptions, c'est à dire des erreurs.
• Lorsqu'une fonction est susceptible de générer une

exception, le programmeur devrait la gérer dans le but
d'obtenir des programmes plus résistants aux erreurs (il
faut toujours éviter le "plantage" sauvage d'une
application).
• La gestion d'une exception se fait selon le schéma suivant :

Page 150
Lancer une exception
• En cas d'erreur dans une méthode d'un

programme (arguments invalides, ...), il est
possible de lancer une exception en utilisant le
mot clé throw.
Page 151
TP1
• {
• int a, b;
• Console.WriteLine(" Donnez le premier nombre");
• a = int.Parse(Console.ReadLine());
• Console.WriteLine(" Donnez le deuxième nombre");

• b = int.Parse(Console.ReadLine());
• if (b == 0)
• throw new Exception(" Vous ne devez pas saisir un nombre égale à 0 ");
• else
•
• Console.WriteLine("resultat : " + a / b);
• }
Page 152
Attraper une exception
• Un gestionnaire d'exception attrape une classe

d'exception particulière et gère le cas d'erreur
correspondant.
• Ce gestionnaire encadre les instructions à gérer pouvant

lancer une exception.
Page 153
Syntaxe de gestion d’une exception
• Try
• {
• // code susceptible de générer l'exception
• }
• catch ( classe_d’exception variable )

• {
• // traiter l'exception e
• }
• finally
• {
• // Instructions toujours exécutées
Page 154
• {
• try TP2
• { int a, b,c;
• Console.WriteLine(" Donnez le premier nombre");
• a = int.Parse(Console.ReadLine());
• Console.WriteLine(" Donnez le deuxième nombre");

• b = int.Parse(Console.ReadLine());
• c = a / b;
• }
• catch (Exception ex)
• { Console.WriteLine(ex.Message);
• }
• finally
• {
• Console.WriteLine("Fin du programme ");
• }
• Console.ReadKey();Powerpoint
} Templates
Page 155
Créer une classe d'exception
• Il suffit de créer une classe qui hérite de la classe

Exception
• La nouvelle classe doit implémenter un constructeur qui

permet de personnaliser sa classe d’exception
• Par convention, toutes ces sous-classes ont un nom se

terminant par Exception.
Page 156
Exemple
• class ErreurAgeException : Exception TP3
• {
• public ErreurAgeException(string msg) : base(msg)
• {
•
• }
• }
Page 157
• Class personne
• { TP3
• private int age;
• // proprieté
• Public int Age
• { Get{ return age; }
• Set{
• If(value<0)
• throw new ErreurAgeException(« valeur tapée incorrecte »);
• Else
• age=value;
• }
• // constructeur
• Public personne (int a)
• {
• if (a<0)
• throw new ErreurAgeException(« vous devez saisir un chiffre i<0);
• Else
• This.age=a;
Page 158
• class Program
• {
TP3
• {
• try
• {
• personne p = new personne();
• p.Age = -3;
• }
• catch (ErreurAgeException e)
• {
• Console.WriteLine(e.Message);
• }
• try
• {
• personne p = new personne(-3);
• }
• catch (ErreurAgeException e)
• {
• Powerpoint Templates
Console.WriteLine(e.Message);
Page 159
• }
Les collections
Page 160
Définition
• Une collection définit un groupe d’objets, sur lequel des

opérations d’insertion, suppression, recherche et
déplacement peuvent être effectuées.
• Au lieu d'écrire un code distinct pour gérer chaque objet,

vous pouvez utiliser le même code pour traiter tous les
éléments d'une collection.
• Les classes de collection sont définies dans le cadre de

l'espace de noms System.Collections ou
System.Collections.Generic.
Page 161
• Tableaux statiques : Array
• Tableaux dynamique : ArrayList
• Dictionnaire : Hashtable
• Dictionnaire trié : SortedList
• Liste : list<T>
Page 162
Classe Array
• La classe Array fournit des méthodes pour la

création, la manipulation, la recherche ainsi que le
tri des tableaux et sert de classe de base pour tous
les tableaux.
Page 163
Méthode ou propriétés Description
Length nombre d'éléments du tableau
BinarySearch() Permet d’effectuer une recherche de

l’élément dans un tableau trié
Copy() copie length éléments de sourceArray
dans destinationArray - destinationArray
est créé pour l'occasion
Sort() trie le tableau array - celui doit contenir un
type de données ayant une fonction
d'ordre par défaut (chaînes, nombres).
Page 164
• using System;
• public class tab1
• { Exemple 1
• public static void Main(string[] args)
• {
• int[] array1 = new int[3];
• array1[0] = 5; array1[1] = 10; array1[2] = 15;
• int[] array2 = new int[3] { 23, 5, 9 };

• Console.WriteLine("tableau initial array1");
• for (int i = 0; i < array1.Length; i++)

• { Console.WriteLine(array1[i]); }
• Console.WriteLine("tableau initial array2");

• {
• Console.WriteLine(array2[i]);
Page 165
• //méthode copy
• Array.Copy(array1, array2, 2);
• Console.WriteLine("tableau array2 après la copie");

• {
• }
• //méthode sort
• Array.Sort(array2);
• Console.WriteLine("tableau array2 après le tri");

• {
• } Page 166
Classe Array-List
• C'est un tableau dynamique d’objets auquel on peut

rajouter ou insérer des éléments, en supprimer.
• Il faut utiliser le namespace System.Collections
Page 167
Méthode ou propriétés
Capcity Nombre d’éléments que le tableau peut contenir
count Nombre d’éléments actuellement dans le tableau
Add(object value) ajoute l'objet value à la fin du tableau

Remove(object obj) enlève l'objet obj s'il existe dans le tableau
Insert(int,object) Insère un élément à l’indice fourni
Clear() Vide le tableau
Contains (object) Renvoie un booléen vrai si l’objet fourni est présent
dans le tableau
Sort() trie le tableau.
BinarySearch(object rend la position de l'objet value dans le tableau ou -

value) 1 s'il ne s'y trouve pas
Page 168
• using System.Collections;
• class program
• { Exemple 2
• {
• //Créer et initialiser arrayList
• ArrayList al = new ArrayList();
• al.Add(1) ;
• al.Add(45) ;
• al.Add(87) ;
• Console.writeline(« la liste initiale »);

• for (int i = 0; i < al.Count; i++)
• {
• Console.WriteLine(al[i]);
• }
• //supprimer un élément de array List

• al.Remove(1) ;
• Powerpoint Templates
Page 169
//trier array List
al.sort() ;
Console.writeline(« le tri : »);

for (int i = 0; i < al.Count; i++)
{
Console.WriteLine(al[i]);
}
//insérer un élément à l’indice donné

al.insert(2, »element ») ;
Console.writeline(« insertion: »);

for (int i = 0; i < al.Count; i++)
{
Console.WriteLine(al[i]);
}
• //nombre d’élements
• console.writeline(« nombre d’éléments est : », al.count);
•
Page 170
Classe hashtable
• La classe Hashtable permet d'implémenter un

dictionnaire. On peut voir un dictionnaire comme un
tableau à deux colonnes :
Clé (hashcode) valeur

clé1 valeur1
clé2 valeur2
Page 171
Méthodes ou propriétés Description
Count nombre d'éléments du dictionnaire
Keys collection des clés du dictionnaire
Add(object key, object value) ajoute une ligne (key,value) dans le

dictionnaire où key et value sont des
références d'objets.
Remove(object key) élimine du dictionnaire la ligne de clé=key
Clear() vide le dictionnaire

ContainsKey(object key); rend vrai (true) si la clé key appartient au
dictionnaire.
ContainsValue(object value); rend vrai (true) si la valeur value appartient au
dictionnaire.
Page 172
Exemple 3
• class program
• {
• {
• // Instanciation d'un objet Hashtable

• Hashtable dict = new Hashtable();
• //méthode Add
• dict.Add(1,"fakri") ;
• dict.Add(2, "hiba");
• dict.Add(3, "sara");
• for(int i=0;i<=dict.Count;i++)
• {
• Console.WriteLine(dict[i]);
Page 173
• //Nombre d'éléments du dictionnaire
• console.writeline(« nombre d’éléments : »+ dict.Count);
• // Sélectionner un élément
• variable = dict[1]
• console.writeline(variable);
• // méthode remove()
• Console.WriteLine("-----------------------------");
• dict.Remove(3);
• for (int i = 0; i <=dict.Count; i++)

• { Console.WriteLine(dict[i]); }
• // méthode clear()
• dict.Clear();
Page 174
Classe SortedList
• SortedList est un dictionnaire qui garantit que les clés

sont rangées de façon ascendante.
Page 175
Méthodes ou propriétés Description
Count nombre d'éléments actuellement dans
la liste
Keys Collection des clés de la liste triée
Values Collection des valeurs ( objets ) de la
liste
Add(object key, object value) Ajoute un élément à la liste ( paire clé-

valeur )
Remove(object key) Enlève un élément e la liste dont la
valeur correspond à la clé
RemoveAt(int) Enlève un élément à l'indice fourni
Clear() Vide la liste

ContainsKey(object key) Renvoie un booléen vrai si la clé
fournie est présent dans la liste
ContainsValue(object value) Renvoie un booléen vrai si la valeur

fournie est présent dans la liste
Page 176
• class program Exemple 4

• {
• {
• // Instanciation d'un objet sortedList
• SortedList sl = new SortedList();
•
• //méthode Add
• sl.Add(32, "Java");
• sl.Add(21, "C#");
• sl.Add(7, "VB.Net");
• sl.Add(49, "C++");
• // afficher les éléments

• for (int i = 0; i < sl.Count; i++)
• {
• Console.WriteLine(sl.GetKey(i)+" " + sl.GetByIndex(i));
Page 177
La classe générique
List<T>
• La classe System.Collections.Generic.List<T> permet

d'implémenter des collections d'objets de type T dont la
taille varie au cours de l'exécution du programme.
• Un objet de type List<T> se manipule presque comme

un tableau. Ainsi l'élément i d'une liste l est-il noté l[i].
• Pour un objet List<T> ou T est une classe, la liste stocke

là encore les références des objets de type T
Page 178
Count nombre d'éléments de la liste
Capacity nombre d'éléments que la liste peut contenir
avant d'être redimensionnée. Ce
redimensionnement se fait automatiquement
Add(T item) ajoute item à la liste
BinarySearch<T>(T item) rend la position de item dans la liste s'il s'y
trouve sinon un nombre <0
Clear() supprime tous les éléments de la liste

public bool Contains(T item) rend True si item est dans la liste, False sinon
void Insert(T item, int index) insère item à la position index de la liste
bool Remove(T item) supprime item de la liste. Rend True si
l'opération réussit, False sinon.
Page 179
• Exemple
• List<stagiaire> liste = new List<stagiaire>();
• Stagiaire S1 = new stagiaire("Moi","mm", 95);

• Stagiaire S2 =new stagiaire("Toi","tt", 90));
• Stagiaire S3 =new stagiaire("Elle","elle", 18)
• liste.Add(S3)
• liste.Add(S2)
• liste.Add(S3);
• stagiaire p = liste[0];
• // afficher la liste des stagiaire
• foreach (stagiaire s in liste)
• {
• Console.WriteLine("le stagiaire est" + s.Nom + s.Prénom + s.Note);
• }
Page 180
Exercice 1
Page 181
• Définir une classe Patient dont les caractéristiques sont :
Code patient (affecté de façon incrémentale par rapport au
nombre de patients), Nom, Prénom.
1. Ecrire un constructeur à deux paramètres : Nom et prénom.
1. Ecrire les accesseurs des champs et la méthode Afficher()

qui affiche les informations d’un patient.
Page 182
1. Définir une classe CabinetMedical dont les caractéristiques
sont : une liste des patients
2. Ajouter une méthode ajouterPatient qui ajoute un patient à
l’ensemble des patients du cabinet .
3. Ajouter une méthode rechercherPatient ayant comme

paramètre le code et qui retourne « vrai » si le patient existe
et « faux » sinon.
4. Ajouter une méthode supprimerPatient qui permet de

supprimer le patient dont le code est fourni en paramètre.
5. Ajouter une méthode listePatient qui affiche la liste des

patients
Page 183
• Dans la classe programme :
• Instancier trois patients.
• Instancier un cabinet médical CM1.
• Ajouter les trois patients à la liste des patients.
• Afficher la liste des patients de l’objet CM1
• Rechercher le patient dont le code est 3
• Supprimer le patient dont le code est 2
• Afficher la liste des patients de l’objet CM1
Page 184
Exercice 2
Page 185
Extrait de l’épreuve pratique V2 - 2012
• Définir une classe Pilote dont les caractéristiques sont :

Matricule, Nom, Prénom.
• Ecrire un constructeur avec tous les paramètres.
• Ecrire les accesseurs des champs et la méthode

toString() qui renverra tous les champs séparés par
tabulation.
Page 186
– Définir une classe Vol dont les caractéristiques sont :
• Numéro vol : le numéro du 1er vol crée est 1 et à chaque création

d’un nouveau vol, ce numéro doit etre automatiquement
incrémenté de 1. Faire le nécessaire (données + code) pour y
arriver.
• Vpilote : c’est le pilote qui a assuré le vol courant.
• Nombre de voyageurs : nombre des personnes qui ont pris ce vol.
• Prix billet : prix payé par chaque voyageur de ce vol (le même prix
pour tous).
Page 187
– Ecrire un constructeur sans aucun paramètre permettant de définir la
valeur du numéro du vol et d’affecter la date système à Date vol.
– Ecrire un constructeur permettant de définir les valeurs des autres

champs. Ce constructeur doit faire d’abord appel au constructeur
précédent.
– Ecrire les accesseurs des champs.
– Ecrire la méthode toString() qui renverra le numéro du vol, le nom et

le prénom du pilote et recette du vol, tous séparés par tabulation.
• La recette du vol = Nombre de voyageurs * Prix du billet du vol en cours.

Page 188
• Programme principal
– Définir une liste de pilotes et une liste des vols.
– Ajouter une méthode rechercherPilote() qui recherche un pilote

par son matricule. Si trouvé, elle retourne le pilote correspondant
dans la liste des pilotes. Sinon, elle retourne la valeur null.
– Ajouter une méthode rechercherVol() qui recherche un vol par

son numéro. Si trouvé, elle retourne l’indice correspondant dans
la liste des vols. Sinon, elle retourne la valeur -1.
– Ajouter par code(en mode conception) trois pilotes à la liste des

pilotes.
– Ajouter par code deux vols à la liste des vols. Utiliser certains
Powerpoint
constructeurs et certaines Templates
méthodes déjà conçus. Page 189
– Concevoir le menu suivant :
( en prenant en compte les indications ci-dessous)
1. Ajouter avion.
2. Ajouter vol.
3. Lister tous les vols
4. Fin
Page 190
Classe String
• La classe string est développé sous la plate forme .net

pour mieux manipuler les chaines de caractères. Cette
classe offre plusieurs méthodes utiles lors de la
programmation.
Page 191
Length Nombre de caractère dans la chaine
public int IndexOf(string rend la première position dans la chaîne de la

value, int startIndex) chaîne value - la recherche commence à partir du
caractère n° startIndex
public string Insert(int insère la chaîne value dans chaîne en position
startIndex, string value) startIndex
public string Replace(char rend une chaîne copie de la chaîne courante où
oldChar, char newChar) le caractère oldChar a été remplacé par le
caractère newChar
public string Substring(int sous-chaîne de la chaîne courante commençant à
startIndex, int length) la position startIndex et ayant length caractères
public string ToLower() rend la chaîne courant en minuscules
public string ToUpper() rend la chaîne courante en majuscules
Page 192
• using System;
• public class string1
Exemple 5
• {

• {
• string uneChaine="l'oiseau vole au-dessus des nuages";
• Console.writeline("uneChaine= " + uneChaine);

• Console.writeline("uneChaine.Length="+ uneChaine.Length);
• Console.writeline("uneChaine.IndexOf(\"vole\")="+ uneChaine.IndexOf("vole"));
• Console.writeline("uneChaine.Substring(4,7)="+ uneChaine.Substring(4,7));
• Console.writeline("uneChaine.ToUpper()=" + uneChaine.ToUpper());
• Console.writeline("uneChaine.ToLower()="+ uneChaine.ToLower());
• }
• }
Page 193
Classe Regex
• La classe Regex permet l'utilisation d'expression

régulières. Celles-ci permettent de tester le format d'une
chaîne de caractères.
• Ainsi on peut vérifier qu'une chaîne représentant une
date est bien au format jj/mm/aa. On utilise pour cela un
modèle et on compare la chaîne à ce modèle.
• Ainsi dans cet exemple, j m et a doivent être des

chiffres. Le modèle d'un format de date valide est alors
"\d\d/\d\d/\d\d" où le symbole \d désigne un chiffre.
Les symboles utilisables dans un modèle sont les
suivants Powerpoint Templates
Page 194
Caractère Description
\ Marque le caractère suivant comme caractère spécial ou littéral. Par
exemple, "n" correspond au caractère "n". "\n" correspond à un
caractère de nouvelle ligne. La séquence "\\" correspond à "\",
tandis que "\(" correspond à "(".
\n Correspond à un caractère de nouvelle ligne.
\d Correspond à un caractère représentant un chiffre. Équivaut à [0-9].
\s Correspond à tout espace blanc, y compris l'espace, la tabulation, le
saut de page, etc. Équivaut à "[ \f\n\r\t\v]".
{n} n est un nombre entier non négatif. Correspond exactement à n fois le
caractère. Par exemple, "o{2} » ne correspond pas à "o" dans "Bob,"
mais aux deux premiers "o" dans "fooooot".
{n,m} m et n sont des entiers non négatifs. Correspond à au moins n et à au
plus m fois le caractère. Par exemple, "o{1,3}" correspond aux trois
premiers "o" dans "foooooot" et "o{0,1}" équivaut à "o?".
[a-z] Plage de caractères. Correspond à tout caractère dans la série
spécifiée. Par exemple, "[a-z]" correspond à tout caractère alphabétique
minuscule compris entre "a" et "z"
{n,} n est un entier non négatif. Correspond à au moins n fois le caractère.
Par exemple, "o{2,}" ne correspond pas à "o" dans "Bob", mais à tous
Powerpoint
les "o" dans "fooooot". Templates
"o{1,}" équivaut à "o+" et "o{0,}" équivaut àPage
"o*". 195
Un élément dans un modèle peut être présent en 1 ou
plusieurs exemplaires. Considérons quelques exemples
autour du symbole \d qui représente 1 chiffre :
Page 196
Page 197
Vérifier qu'une chaîne correspond à un
modèle donné
• 1- construire l'expression régulière modèle.
• 2 - construire un objet de type Regex.
• 3 - créer l'exemplaire à comparer
• 4- comparer l’exemplaire au modèle en

utilisant avec la méthode IsMatch()
Page 198
• using System.Text.RegularExpressions;

• {
• // 1 - créer une expression régulière modèle
• La syntaxe @"texte" demande que texte soit pris exactement comme il est écrit
• string model = @"a{5}\@b{3}\.c{3}";

• // string model = @" \d{2}/\d{2}/\d{4}";
• // 2 – construire un objet de type regex
• Regex r1= new Regex(model);
• // 3 - créer l'exemplaire à comparer

• string exemplaire1="aaaaa@bbb.cc";
• // 4 - comparer l’emplaire au modèle avec la méthode IsMatch()

• if(r1.IsMatch(exemplaire1))
• Console.WriteLine("L'exemplaire correspond au modèle");
• else
• Console.WriteLine("L'exemplaire correspond au modèle"); Page 199
• // 5 - créer un autre exemplaire à comparer
• string exemplaire2="aaaaa";
// 6 - comparer l’emplaire au modèle avec la méthode IsMatch()
• if(r1.IsMatch(exemplaire2))
• else
Page 200
Les fichiers
Page 201
classe StreamReader
• La classe StreamReader permet de lire le contenu

d'un fichier.
• On utilise : using System.IO;
• Voici quelques-unes de ses propriétés et méthodes :
Page 202
// constructeur
public StreamReader(string path) ouvre un flux à partir du fichier path.
Une exception est lancée si celui-ci
n'existe pas
// méthodes ferme le flux

public virtual void Close()
public virtual string ReadLine() lit une ligne du flux ouvert
public virtual string ReadToEnd() lit le reste du flux depuis la position

courante
Page 203
• using System;
• using System.IO; TP 1
• class Program
• {
• {
• string ligne=null;
• StreamReader flux=null;
• // lecture contenu du fichier
• flux=new StreamReader("infos.txt");
• ligne=fluxInfos.ReadLine();
• while (ligne != null)

• {
• System.Console.Out.WriteLine(ligne);
• ligne=fluxInfos.ReadLine();
• }
• flux.Close();
• Console.ReadLine();
• } } Page 204
classe StreamWriter
• La classe StreamWriter permet d'écrire dans un

fichier. Voici quelques-unes de ses propriétés et
méthodes :
Page 205
// constructeur
public StreamWriter(string path) ouvre un flux d'écriture dans le fichier
path. Une exception est lancée si
celui-ci ne peut être créé.
// méthodes
public virtual void Close() ferme le flux
public virtual string WriteLine(string écrit value dans le flux ouvert suivi
value) d'un saut de ligne
public virtual string Write(string value) idem mais sans le saut de ligne
Page 206
• using System;
• using System.IO; TP 2
• class Program
• {
• {
• string ligne=null; // une ligne de texte
• StreamWriter flux=null; // le fichier texte
• // création du fichier texte

• flux=new StreamWriter("infos.txt");
• // lecture ligne tapée au clavier

• Console.Out.Write("Tapez une ligne : ");
• ligne=Console.In.ReadLine().Trim();
Page 207
• // boucle tant que la ligne saisie est non vide TP 2
• while (ligne != "")

• {
• // écriture ligne dans fichier texte
• flux.WriteLine(ligne);
• // lecture nouvelle ligne au clavier

• Console.Out.Write("Tapez une ligne : ");
•
• ligne=Console.In.ReadLine().Trim();
• }
• // fermeture fichier
• flux.Close();
• }
• }
• }
Page 208
TP 3
• // méthode qui enregistrer le contenu d’une liste dans un fichier
• public void EnregistrerRDV()

• {
• StreamWriter flux = new StreamWriter("Liste.txt");
• foreach (RendezVous rdv in listeRDV)

• {
• flux.WriteLine(rdv.CodePatient);
• flux.WriteLine(rdv.DateRDV);
• flux.WriteLine(rdv.HeureRDV);
• flux.WriteLine(rdv.Observation);
• }
• Flux.close();
• }
Page 209
La sérialisation
Page 210
• La sérialisation (en anglais serialization) est un procédé
qui consiste à sauver l'état d'un objet sur le disque ou le
réseau plutôt que de le garder en mémoire.
• On peut dire que l'objet est "aplatit" pour pouvoir le

convertir en un flux de données, que l'on peut
transmettre à un autre objet via la désérialisation
• La sérialisation et la désérialisation se fait via des fichier

(binaire, XML, ou SOAP).
Page 211
Sérialisation et
Désérialisation XML
• Cette technique permet de générer un flux

XML ; et du coup on stock les objets dans
un fichier XML
Page 212
Exemple
• On crée la classe personne , pour pouvoir

stocker l’objet dans un fichier il faut que
celui-ci soit sérializable.
Page 213
• using System;
• using System.Collections.Generic;
• using System.Linq;
• using System.Text;
• namespace sérialisation
• {
• [Serializable]
• public class Personne

• {
• public Personne() { }
• string nom;
• public string Nom

• {
• get { return nom; }
• set { nom = value; }
Page 214
• string prenom;
• public string Prenom

• {
• get { return prenom; }
• set { prenom = value; }
• }
• string telephone;
• public string Telephone

• {
• get { return telephone; }
• set { telephone = value; }
• }
• }
• }
Page 215
• On crée la classe Carnet c’est une liste de
personne.
• La liste doit être de type liste générique .
Page 216
• using System;
• using System.Collections.Generic;
• using System.Linq;
• using System.Text;
• using System.IO;
• using System.Xml.Serialization;
• namespace sérialisation
• {
• [Serializable]
• public class Carnet : List<Personne>
• {
• int capacité;
• public Carnet(int cap)
• {
• this.capacité = cap;
• }
Page 217
• public Carnet()
• {
• }
• public void Sauvegarder(string filename)
• {
• FileStream file = File.Open(filename, FileMode.OpenOrCreate);
• XmlSerializer serializer = new XmlSerializer(typeof(Carnet));
• serializer.Serialize(file, this);
• file.Close();
• }
• public Carnet Charger(string filename)

• {
• FileStream file = File.Open(filename, FileMode.Open);
• XmlSerializer serializer = new XmlSerializer(typeof(Carnet));
• Carnet unCarnet = (Carnet)serializer.Deserialize(file);
• file.Close();
• return unCarnet;
Page 218
• class Program
• {
• {
• Personne p = new Personne();
• p.Nom = "TATA";
• p.Prenom = "TITI";
• p.Telephone = "06584796";
• Carnet c = new Carnet(3);

• c.Add(p);
• c.Sauvegarder("TEST");
• Carnet t=new Carnet(3);

• t = c.Charger("TEST");
• foreach (Personne s in t)
• {System.Console.WriteLine(s.Nom + " " + s.Prenom + " " +s.Telephone);}
• }
Page 219
Fin
Page 220

Formation Francais

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Formation Francais

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Orientée Objet

• Formatrice : TOUFELLA Kenza

• Dans la programmation traditionnelle un programme

• Le principe était de trouver l’algorithme puis ensuite de

• De plus la réutilisation du code de certaines fonctions

• Dans la programmation objet chaque paquets de

• Les différents traitements à réaliser sur ces données

champs : Capitaine, type, couleur, position, vitesse,…

Fonctions ou méthodes : marche, stop, plus_vite…..

• La découpe du problème en classes et donc en objets

• Une classe peut hériter d’une autre classe ce qui permet

• Les données de la classes sont protégées de l’extérieur :

• Grâce à la P.O.O., on gagne en rapidité de fabrication du

• Cahier des charges

• Une personne est décrite par deux informations :

• Une personne est capable de s’identifier, en

void Presente(struct Personne P)

• Les informations qui concernent une personne

• En effet, tout utilisateur du type composé

• Une classe est un ensemble de données et de fonctions

• Les fonctions qui opèrent sur les données sont appelées

• Une classe se compose de :

• Les données et méthodes sont pourvues d’attributs

• Une classe décrit la structure des objets.

• Ces conventions ne sont pas normalisées et peuvent

• Les noms de fichiersConvention d’écriture:

• Exemple pour la classe Fraction : Fraction.cs

• L’objet possède les mêmes attributs et les mêmes

• Les attributs prennent des valeurs distincts dans

• Les données d’un objet sont ses variables d’instance.

• privé : Un champ privé (private) n'est accessible que

• Public : Un champ public (public) est accessible par

• protégé : Un champ protégé (protected) n'est accessible

• les données d'une classe sont déclarées privées alors

• Cela signifie que l'utilisateur d'un objet (le programmeur)

- n'aura pas accès directement aux données privées de

• Le concepteur de la classe X :est celui qui définit X.

• Un utilisateur de la classe X :est aussi un

• L’instanciation est l’opération qui consiste

• Personne p1=new Personne();

• Cela a pour effet de créer un objet de type Personne non

namespace Chap2 Classe : Personne

Personne p2 = new Personne();

• Un salarie est décrit par ses données membres :

1 - Codage de la classe Salarie

• Soit la classe module qui modélise un module et qui comportera les

• Soit la classe formateur qui modélise un formateur et qui comportera

• C'est une méthode qui peut accepter des arguments mais

• Si une classe X n'a aucun constructeur, elle en a un par

• Tous les constructeurs ont le même nom mais se

• Lorsqu'une classe X a un ou plusieurs constructeurs,

• A partir du moment où il existe un constructeur

• Le constructeur par défaut initialise les champs type

Personne P1=new Personne() ;

• Ce constructeur permet de procéder à une instanciation

• Il peut exister plusieurs constructeurs d’initialisation avec

• Pour la classe Client, ce constructeur est déclaré

Cela va permettre d'instancier la classe Personne de

Personne p2 = new Personne("Jean", "Dupont", 30);

Personne p1 = new Personne("Jean", "Dupont", 30);

• Soit la classe produit caractérisé par son nom (string),

3- en utilisant le constructeur d’initialisation créer l’objet

• Un élève peut s’inscrire dans une association scolaire.

• L’encapsulation n’autorise pas l’accès aux attributs