POO Cours

Programmation Orientée Objets(C#) ISTA OULED TEIMA - TDI 1 è m e Anné e 2016/2017
Programmation orientée objet en c#

1. Notion de classe :
 Une classe c’est un plan ou un modèle sur lequel on va baser pour créer (instancier) des objets. Définir
une classe c’est créer un nouveau type, ou ajouter un type personnalisé au jargon des types.
 Il faudra énumérer toutes les propriétés de cet objet et toutes les méthodes qui vont permettre de définir
son comportement.
 La déclaration d’un nouveau type de données et les méthodes qui permettent de gérer les objets
associés, constitue une classe de l’objet.
 Les propriétés de l’objet seront implantées sous la forme de données membres de la classe.
 Les différentes fonctions ou méthodes seront implémentées sous la forme de méthodes membres
de la classe.
 De façon courante, données membres et méthodes membres, sont considérées respectivement
comme synonymes de propriétés et méthodes de la classe.
Exemple :
2. Déclaration d’une classe d’objet en C# :

Une classe en C# se déclare par le mot clé Class suivi d’un identificateur (Nom) de classe choisie par le
programmeur de la façon suivante :
public class Nom_Classe{

//Déclaration des attributs
//Déclaration des méthodes
}
Le fichier contenant le code source portera le nom Nom_Classe.cs.
3. Déclaration des propriétés (attributs) :

Les propriétés d’un objet sont déclarées comme des variables à l’intérieur du bloc {} contrôlé par le mot clé
class.
public class nom_classe{

Type_de_propriete nom_propriete ;
//Declaration des methodes de l’objet
}
Une propriété peut être initialisée lors de sa déclaration :
Type_propriete nom_propriete = valeur_initiale ;
www.elbahihassan.com 1/22 Pr. : El Bahi Hassan

4. Déclaration des propriétés (attributs) :

Les méthodes d’une classe sont implémentées à l’intérieur du bloc {} contrôlé par le mot clé class.
Public class Rectangle {

//Declaration des attributs
int largeur ;
int longueur ;
//Implémentation des methodes

int Calcule_surface( ){
Return (largeur*longueur) ;
}
}
 Les identifiants des méthodes commencent par majuscule.

 Une méthodes peut être procédure donc elle aura comme type de retour void, ou fonction qui
retourne une valeur compatible avec son type de retour grâce à l’instruction return .
 La méthode Main (fonction), est la fonction principale de l’application.
5. Le mot-clé this
Le mot-clé this désigne, dans une classe, l'instance courante de la classe elle-même.
6. L’instanciation
Pour qu’un objet ait une existence, il faut qu’il soit instancié. Une même classe peut être instanciée plusieurs
fois, chaque instance (objet) a des propriétés spécifiques.
En C# il n’existe qu’une seule manière de créer une instance d’une classe. Cette création d’instance peut se
faire en deux temps :
 Déclaration d’une variable de type de la classe d’objet.

 Instanciation de cette variable par l’instruction new.
class Program {
public static void Main(string[]args){
Client cl;//déclaration
Cl = new Client( ) ; //instanciation
Client C2 = new Client() ; //déclaration et instanciation
}
}
7. Constructeurs
Le mot-clé this désigne, dans une classe, l'instance courante de la classe elle-même.
Un constructeur d’une classe donnée intervient au moment de l’instanciation d’un objet de type cette classe.
Le constructeur initialise les attributs (propriétés) de cet objet pour qu’il soit cohérent. Le constructeur est
une méthode de la classe, mais particulière :
 Il possède le même nom que l’identificateur de la classe.

 Il n’a pas de type de retour, même le type void.
public Client( ){

Surcharge des constructeurs :

Pour une classe donnée, on peut définir plusieurs constructeurs, tous ces constructeurs partagent le même
nom (le nom de la classe), mais se distinguent par le nombre et les types d’arguments, cette distinction
s’appelle en orientée objet surcharge.
- Le constructeur d’initialisation (ou le constructeur avec paramètres) : Ce constructeur initialise les

propriétés de l’objet au moment de l’instanciation, par les valeurs passées en paramètre
Exemple :
public class Client {

//Déclaration des attributs
private int num ;

private string nom ;
private double chiffre_affaire ;
//Implémentation d’un constructeur d’initialisation
public Client(int num, string nom, double ca){

this.num=num ;
this.nom=nom;
this.chiffre_affaire=ca;
}
Cela va permettre d’instancier la classe Client de la façon suivante :

class Program {
public static void main(String[]args){
Client cli=new Client(2, "Ali", 10000);
}
}
- Le constructeur par défaut : Un constructeur par défaut est un constructeur qui peut être appelé sans
paramètre. À noter qu'il peut s'agir d'un constructeur sans paramètres, ou d'un constructeur dont les
paramètres ont des valeurs par défaut.
Exemple :
//Déclaration d’attributs
// ....
//constructeur d’initialisation
// ....
//constructeur par defaut
public Client ( ){
}
}
Instanciation du constructeur par défaut se fait de la façon suivante :

class Program {
public static void main(String[]args){
Client cli=new Client();
}
}
- Constructeur de recopie : Le constructeur de recopie permet de copier les propriétés d’un objet existant
dans la nouvelle instance.
Exemple :
//Déclaration d’attributs
// ....
//constructeur d’initialisation
// ....
//constructeur par defaut

// ...
public Client (Client c){

this.num=c.num ;
this.nom=c.nom ;
this.chiffre_affaire=c.chiffre_affaire;
}
}
Programme principal :
class Program {
Client clt1=new Client( ); //C. par défaut
Client clt2=new Client(22, "Mohamed", 20000) ; //C. d’initialisation
Client clt3=new Client(clt2) ; //Constructeur de recopie
}
}
8. Déclaration des propriétés (méthodes) :
a) Protection des propriétés :
En programmation orientée objet, on évite d’accéder directement aux propriétés par l’opérateur « . » en effet
cette possibilité ne correspond pas au principe de l’encapsulation. Certains langages interdisent carrément cet
accès direct à la propriété et méthodes. En C# c’est le programmeur qui choisit si une propriété ou méthode
membre est accessible directement ou pas.
Par défaut en C # toutes les propriétés et méthodes ne sont pas accessibles directement. Il faut donc préciser
explicitement le mode d’accès à chaque propriété et chaque méthode. Pour cela il existe trois mots clés
 public : après ce mot clé toutes les propriétés et méthodes sont accessibles directement à l’extérieur de la
classe.
 private : après ce mot clé toutes les propriétés et méthodes sont verrouillées, inaccessibles directement à
l’extérieur de la classe, elles sont accessibles qu’à partir des méthodes public membres de la classe.

 protected : après ce mot clé toutes les propriétés et méthodes membres de la classe sont verrouillées,
néanmoins elles sont accessibles dans les classes filles, ou à partir des méthodes public de la classe.
La distinction entre private et protected, n’est visible que dans le cas de déclaration de nouvelles classes par
héritage. Ce concept sera abordé ultérieurement dans ce cours.
Afin d’appliquer correctement le principe d’Encapsulation, il convient de verrouiller l’accès aux propriétés
en les déclarant private, tout en autorisant l’accès aux méthodes en les déclarant public.
Exemple :

//Declaration des attributs
private int num ;

private double chiffre_affaire ;
//Implementation des methodes
public void modifierNom(string n){

nom=n ;
}
}
L'attribut nom n'est pas accessible directement. Elle est accessible qu’à partir de la méthode
modifierNom(string n) .
b) Les méthodes d’accès aux propriétés :
Si les propriétés sont verrouillées (déclarées private) on ne peut plus y accéder de l’extérieur de la classe. Il
faut donc créer des méthodes dédiées à l’accès des propriétés pour chacune d’elle, ces méthodes doivent
permettre un accès dans les deux sens :
 Pour connaitre la valeur de la propriété (un accesseur ou un getter).

 Pour modifier la valeur de la propriété (un mutateur ou un setter).
Les accesseurs (getters) :

Ces méthodes sont appelées des méthodes de type Get, cette méthode ne prend pas de paramètre et retourne
la valeur de l’attribut associé. Par exemple pour l’attribut num de type int, la fonction Get serait déclaré
comme suit :
public int GetNum(){
Return this.num ;
}
Cette fonction pourra être utilisée dans la fonction main comme suit :
Client c = new Client() ;
int numero = c.num ; // faux , car l’attribut num est private
int numero = c.GetNum() ;// OK

Les mutateurs (setters):
Ces méthodes sont appelées méthodes Set. Cette méthode ne retourne aucune réponse. Par contre un paramètre
de même type que la propriété doit lui être indiqué.
Toujours pour la propriété num de type int, le Setter associé sera implémenté comme suit :
public void SetNum(int numero){

this.num=numero;
}
Cette fonction pourra être utilisée dans la fonction main comme suit :
Client c = new Client() ;
c.num=5 ; // faux, car l’attribut num est private
c.SetNum(5); // OK
9. Les propriétés statique (static):

Jusqu’à présent, les propriétés déclarées sont que 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.
En C #, chaque classe peut avoir un compteur d’instance qui a comme valeur le nombre d’instances en cours,
instanciées à partir de cette classe à un moment donnée.
Ce compteur d’instance n’est qu’une propriété de classe, sa valeur est la même pour toutes les instances,
pour déclarer cette propriété on utilise le mot static.
La propriété de la classe doit être initialisée par 0 lors de sa déclaration, et incrémentée de 1 dans tous les
constructeurs de la classe.
Exemple :
Public class Client {
//propriété d’insttance
private int num ;
private double chiffre_affaire;
//propriété de classe
private static int compteur=0 ;
//constructeur par défaut

public Client(){
compteur+=1 ;
}
//Constructeur d’initialisation
public Client(int num, string nom, double ca){
compteur+=1 ;
This.num=num ;
This.nom=nom ;
This.ca=ca ;
}
}

10. Les méthodes statiques :

Une méthode statique est une méthode qui peut être appelée même sans avoir instancié la classe. Une
méthode statique ne peut accéder qu'à des attributs et méthodes statiques.
Méthode GetCompteur associée à la propriété compteur de classe client.
public static int GetCompteur(){

return compteur ;
}
L’appel d’une méthode de statique est sensiblement différent à l’appel des autres méthodes. En effet, il ne
faut pas utiliser l’instance de la classe, il faut utiliser la classe elle-même.
Client cli=new Client(5,"Said" , 21000);
int a= cli.GetCompteur(); //Faux GetCompteur est une méthode statique

int a=Client.GetCompteur() ;//OK
}
11. L’héritage :
a) Concept :
Le concept de l’héritage est l’un des trois principaux fondements de la programmation orientée objet, le
premier étant l’encapsulation, est le dernier est le polymorphisme qui sera abordé plus tard dans ce
document.
L’héritage consiste à la créer une nouvelle classe dite classe drivée ou classe fille à partir d’une classe
existante dite classe de base ou classe parente ou classe mère.
L’héritage permet de :
 Récupérer le comportement standard d’une classe objet (classe parente) à partir de propriétés et de
méthodes définies dans celle-ci.
 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 d’objet (classe parente), en surchargeant certaines
méthodes de la classe parente dans la classe dérivée.
La classe de base :
class ClassA {
//propriété de la classe
public int DataA ;
//Méthode de la classe
public int FonctionA1(){
//code de la fonction fonctionA1
}
public virtual int FonctionA2() //surchargeable
{
//code de la méthode fonctionA2
}
}

La classe fille :
class ClassB : ClassA{
//propriétés de la classe ClassB
public int DataB ;
//Méthodes de la classe ClassB
public override int FonctionA2(){
//code de la méthode FonctionA2
}
public int FonctionB1(){
//code de la méthode FonctionB1
}
}
Dans cet exemple :
 ClasseA est la classe parente (classe mère).

 ClasseB est une classe dérivée (classe fille) de la classe ClasseA.
 dataA est une propriété de la classe ClasseA. Par héritage dataA est aussi une propriété de la classe
ClasseB.
 dataB est une propriété de la classe ClasseB (mais pas de la classe ClasseA)
 FonctionA1 est une méthode de la classe ClasseA. Par héritage FonctionA1 est aussi une méthode
de la classe ClasseB .
 FonctionB1 est une méthode de la classe ClasseB (mais de la classe ClasseA).
 FonctionA2 est une méthode des classes ClasseA et ClasseB.
o Dans la classe ClasseA, FonctionA2() est déclarée virtual car elle est surchargeable dans
la classe ClasseB
o Dans la classe ClasseB, FonctionA2() est déclarée override car elle remplace la méthode de
la classe ClasseA.
b) Protection des propriétés et des méthodes :

En plus des mots clés publics et private décrits dans les chapitres précédents, il est possible d’utiliser un
niveau de protection intermédiaire de propriétés et de méthodes par le mot clé protected. Les exemples ci-
dessous permettent d’illustrer les différents niveaux de protection.
public class ClasseA {

//Propriétés de la classe ClasseA
private int dataA1 ;
protected int dataA2;
public int dataA3 ;
//Méthodes de la classe ClasseA
public int FonctionA(){
DataA1=3 ;
DataA2=5 ;
DataA3=8 ;
DataB=9 ;//Faux propriété de la classe fille est inaccessible
dans la classe mére.
}
}

public class ClasseB : ClasseA{

//propriété de la classe ClasseB
public int DataB ;
//méthodes de la classe ClasseB
public int FonctionB(){
DataA1=6 ;//faux ,propriété private de la classe ClasseA inaccessible.
DataA2=7 ;//OK, propriété protected de la classe mére
DataA3=10 ;//OK, propriété public de la classe mére
DataB=90 ;//OK, propriété de la classe B
}
}
Dans cet exemple :
 DataA1, DataA2 et DataA3 sont des propriétés de la classe ClasseA respectivement private, protected
et public.
 FonctionA est une méthode de ClasseA, et FonctionB est une méthode de ClasseB.
 DatA1, DataA2 et DataA3 sont des propriétés de ClasseA. Elles sont donc directement accessibles
dans toutes les méthodes ClasseA, donc dans FonctionA.
 DataB est propriété de ClasseB (classe dérivée de ClasseA). Une propriété d’une classe dérivée est
inaccessible dans la classe de base.
 DataA1 est déclarée private dans la classe ClasseA. Elle est accessible uniquement pour toutes les
fonctions de la classe ClasseA.
 DataA2 est déclarée protected dans la classe ClasseA. Elle est accessible uniquement pour toutes les
fonctions des classes ClasseA et ClasseB.
 DataA3 est déclarée public dans la classe ClasseA. Elle est donc directement accessible dans toutes
les instances.
c) Compatibilité et affectation :
Lors des affectations (opérateur =), il est possible de mélanger des instances de classes différentes. Cependant,
il y a quelques règles à observer :
ClasseA ObjA ;
ClasseB ObjB ;
 ClasseA est une classe de base.

 ClasseB est une classe dérivée de ClasseA.
 ObjA est une instance de la classe ClasseA.
 ObjB est une instance de la classe ClasseB.
 L’instruction ObjA = ObjB ; est légale. Elle affecte à ObjA l’objet référencé par ObjB. Ceci est
possible car une instance de ClasseB est aussi une instance de ClasseA. Une variable de classe de
base est compatible avec les variables de toutes ses classes dérivées.
 L’instruction ObjB = ObjA ; génère une erreur de compilation.
d) Constructeur et héritage
Chaque constructeur d'une classe dérivée doit obligatoirement appeler le constructeur équivalent de
la classe de base. Cela se fait de la façon suivante en utilisant le mot-clé base :

public class ClasseA {

//Propriétés de la classe ClasseA
private int dataA1 ;
protected string dataA2;
public double dataA3 ;
// Constructeur par défaut
public ClasseA (){
}
// Constructeur avec arguments
public ClasseA (int d1, string d2, double d3 ){
this.dataA1=d1;
this.dataA2=d2;
this.dataA3=d3;
}
//Méthodes de la classe ClasseA
...
}
public class ClasseB : ClasseA {

//propriété de la classe ClasseB
public int DataB ;
// Constructeur par défaut
public ClasseB () : base(){
}
// Constructeur avec arguments
public ClasseB (int d1, string d2, double d3, int d4 ) : base(d1,d2,d3)
{
this.DataB=d4;
}
//Méthodes de la classe ClasseB
...
}
12. La méthode ToString() :

La méthode ToString() en C# permet de donner un aperçut d'un objet instancié. C'est à dire que cette
méthode va retourner une chaine de caractère représentant un objet avec l’affichage des valeurs des
propriétés par exemple.
Exemple :
class Rectangle {
private int largeur ;
private int longueur ;
public Rectangle(){ }
public Rectangle(int largeur , int longueur){
this.largeur=largeur ;
this.longueur=longueur ;
}
//...
}

Rectangle r=new Rectangle(3,4) ;
Console.WriteLine("r= "+ r); /* faux, impossible d’afficher l’objet
r, parce qu’on a pas surcharger la function ToString dans la classe
Rectangle */
}

Pour remédier à ce problème on doit surcharger la fonction ToString dans la classe Rectangle. On va la
surcharger (redéfinir), et on ne va pas la définir parce que c’est une méthode virtual héritée de la super class
Object.
La classe Rectangle après modification :

class Rectangle {
}
//...
public override String ToString(){

return "("+ this.largeur + "," + this.longueur + ")";
}

Rectangle r=new Rectangle(3,4) ;
Console.WriteLine("r= "+ r); // c’est OK, et ça va afficher (3,4)
}
13. La méthode Equals :

Cette méthode doit répondre VRAI si deux instances sont rigoureusement égales. Deux conditions sont à
vérifier :
 Il faut que les deux objets soient de la même classe.

 Il faut qu'une règle d'égalité soit appliquée : par exemple deux objets client sont égaux si leurs numéros
sont égaux.
class Rectangle {
}
public Rectangle(Rectangle r){
this.largeur= r.largeur ;
this.longueur= r.longueur ;
}
//...
}
Rectangle r1=new Rectangle(3,4) ;

Rectangle r2=new Rectangle(r1) ;
Bool a= (r1==r2); /*ça va générer erreur parce qu’on peut pas
comparer deux objets en utilisant l’opérateur « == » */
}

Pour remédier à ce problème on doit surcharger la méthode Equals dans la classe Rectangle, une fois surchargé
la méthode Equal sera implicitement (par défaut), à chaque fois on veut comparer deux objets de type
Rectangle en utilise l’opérateur « == »
public class Rectangle {

//Le constructeur par defaut
...
//le constructeur avec paramitres
...
//le constructeur de recopie
...
//la method Equals
public Boolean Equals (Rectangle rec){

return ((this.largeur == rec.largeur) && (this.longueur ==
rec.longueur));
}
//...
}

Rectangle r1=new Rectangle(3,4) ;
Rectangle r2=new Rectangle(r1) ;
Rectangle r3=new Rectangle( ) ;
bool a= (r1==r2); // c’est OK, a vaut Vrai
bool b= (r1==r3); // c’est OK, a vaut Faux
}
Les tableaux contiennent des éléments, chacun d’eux étant repéré par son indice. En C#, il existe une manière
très simple de créer des tableaux « classiques », sans faire référence aux classes Collections.
14. Les classes et méthodes Abstract:

Une classe abstraite est une classe incomplète. Elle regroupe un ensemble de variables et de méthodes mais
certaines de ses méthodes ne contiennent pas d'instructions, elles devront être définies dans les classe héritant
de cette classe abstraite.
Une méthode déclarée abstract ne peut pas être exécutée. En fait, elle n'a pas d'existence réelle. Sa déclaration
indique simplement que les classes dérivées doivent la redéfinir.
Une classe qui contient une méthode abstract doit être déclarée abstract elle-même.
Exemple
abstract class Animal

{
//Attributs, constrecteurs, méthodes
...
public abstract string crie();
}

class Canari : Animal

{
...
public override string crie()
{
return "Cui-cui !";
}
}
class Chat : Animal

{
...
public override string crie()
{
return "miaou-miaou !";
}
}
15. Tableaux statiques :

Les tableaux contiennent des éléments, chacun d’eux étant repéré par son indice. En C#, il existe une
manière très simple de créer des tableaux « classiques », sans faire référence aux classes Collections
//Déclaration et initialisation d’un tableau statique de type int et de

dimension 20
int[] aTab=new int[20] ;
for(int i=0 ; i<20 ; i++){

aTab[i]=i+55;
}
//Déclaration et initialisation d’un tableau statique de type string et

de dimension 5
string[] aStr=new string[3] ;
aStr[0]= "Ahmed";
aStr[1]= "Farid";
aStr[2]= "Ali";
aStr[3]= "Ibrahim";
aStr[4]= "Mohamed";
//Déclaration d’un tableau statique de type Salarie et de dimension 5
Salarie[] sal=new Salarie[5] ;
Salarie[0]=new Salarie(16,4,2, "toto",18765) ;

Salarie[1]=new Salarie(8,5,2, "Ali ",6543) ;
Salarie[2]=new Salarie(32,4,2, "Farid ",20765) ;
Salarie[3]=new Salarie(20,5,20, "Ahmed ",21765) ;
Salarie[4]=new Salarie(9,65,2, "Mohamed ",30765) ;

Exemple :
Le problème de ce type de tableau réside en deux points :
 Tous les éléments du tableau ont le même type.

 Le nombre des éléments du tableau est connu au moment de la déclaration.
Programme qui affiche tous les éléments d’un tableau statique nommé aTab :
foreach (int Val in aTab){
Console.WriteLine(Val) ;
}
Ce programme stocke à chaque fois la valeur d’un élément du tableau aTab dans la variable intVal , puis
affiche cette dernière.
16. Les tableaux dynamique (ArrayList) :

La classe ArrayList est un tableau dynamique auquel on peut rajouter ou insérer des éléments et en supprimer.
Il faut utiliser le namespace System.Collections
Using System.Collections ;
ArrayList al=new ArrayList() ; //declaration d’un tableau dynamique
Al.add(1) ; //ajouter un élément dans le tableau al en appelant la

méthode add(), de la classe ArrayList
Al.add(80) ;
Al.remove(1) ;//supprimer un élément du tableau al en appelant la méthode

remove() de la classe ArrayList
La classe ArrayList est un tableau dynamique auquel on peut rajouter ou insérer des éléments et en supprimer.
Il faut utiliser le namespace System.Collections
Quelques méthodes de la classe ArrayList :
Méthode ou propriétés But

Capacity Détermine le nombre d’éléments que le tableau peut contenir
Count Donne le nombre d’éléments actuellement dans le tableau
Add(object) Ajoute un élément au tableau
Remove(object) Enlève un élément du tableau
RemoveAt(int) Enlève un élément à l’indice fourni
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
al[index] Fournit l’objet situé à la valeur de l’index

Programme qui affiche tous les éléments de tableau Al :
foreach (int val in al){

Console.WriteLine(val);
}
Accès à un élément :
Console.WriteLine("deuxiéme element "+ al[1]);
17. La classe Hashtable :

Un objet de type Hashtable c’est aussi un tableau dynamique, mais c’est un tableau associatif c’est plutôt un
dictionnaire, ou tableau de deux dimensions de deux colonnes, une colonne pour le hashcode (l’identifiant ou
la clé primaire de chaque élément), et la deuxième colonne contient la valeur stockée dans cet élément.
Exemple :
//Instancier un objet de type Hashtable

Hashtable dict=new Hashtable() ;
//Insérer un élément par add()

dict.add(1, "toto") ;
dict.add(2, "titi");
//Nombre d’élément du dictionnaire

int nbr=dict.Count ;
//Supprimer un élément en fonction de sa clé (hashcode)

dict.Remove(clé) ;
//vider le dictionnaire par Clear()

dict.Clear() ;
//Parcourir le dictionnaire
foreach (int i in dict.Keys){

Console.WriteLine(d[k]);
}
Remarque:
Le dictionnaire Hashtable ne trie pas les éléments, et pour avoir un dictionnaire trié dans l’ordre croissant en
fonction de la clé de ses éléments, on doit utiliser la classe SortedList ou lieu de la classe Hashtable.
18. La classe SortedList:

SortedList est un dictionnaire qui garantit que les clés soient rangées de façon ascendante (dans l’ordre
croissant).

Exemple :
static void Main(){
//Instancier un objet de type SotedList

SortedList sl=new SortedList() ;
//Ajouter des elements dans le dico sl

sl.add(32,"Java");
sl.add(21,"C#");
sl.add(7,"PHP");
sl.add(49,"C++");
//afficher le dico sl
for(int i=0 ; i<sl.count ; i++){

Console.WriteLine("clé ="+ sl.GetKey(i) + " , valeur= "+ sl.GetByIndex(i));
}
}
Quelques méthodes qui permet de manipuler un dictionnaire de type SortedList :
Méthode ou propriétés But

Keys Collection des clés de la liste trièe
Values Collection des valeur (objets) de la lsite
Count Donne le nombre d’éléments actuellement dans la liste
Add(Object key, Object value) Ajouter un élément à la liste (pair clé-valeur)
Remove(object key) Enlève un élément de la liste dont la valeur correspond à la clé
RemoveAt(int) Enlève un élément à l’indice fourni
Clear() Vide le tableau
ContainsKey(object Key) Renvoie un booléen vrai si la clé fourni est présente dans la liste
ContainsValue(object value) Renvoie un booléen vrai si la valeur fourni est présente dans la liste
GetKey(int index) Renvoie la clé correspondant à l’indice spécifié
GetByIndex(int index) Renvoie la valeur correspondant à l’indice spécifié
IndexOfKey(Object Key) Renvoie l’indice correspondant à une clé
IndexOfValue(Object value) Renvoie l’indice correspondant à une valeur

19. Les collections génériques :

 List<T>
 HashSet<T>
 SortedList <TKey,TValue>
- La classe 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 Liste est-il
noté Liste[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.
Exemple : List<T>
using System.Collections;
…
public static void Main(string[] args)
{
// creer 3 personnes
personne p1 = new personne("nom1", "prenom1", 23, "Ville1");
personne p3 = new personne("nom3", "prenom3", 25, "Ville3") ;
// creer la liste
List<personne> list = new List<personne>();
// remplir la liste
list.Add(p1);
list.Add(p2);
list.Add(p3);
// parcourir la liste 2eme méthode
foreach (personne p in list)
{
Console.WriteLine(p.ToString());
}
}
Exemple : HashSet<T>
...
// creer la liste
HashSet <personne> list = new Hashset <personne>();
// remplir la liste
list.Add(p1);
list.Add(p2);
list.Add(p3);
// parcourir la liste 2eme méthode
foreach (personne p in list)
{
}
...

Exemple : SortedList <TKey,TValue>
using System.Collections;
…
public static void Main(string[] args)
{
// creer le SortedList
SortedList<string, personne> dic = new SortedList<string, personne> ();
// remplir le dictionnaire
dic.Add(p1.getNom(), p1);
// pour afficher les clés
foreach (String s in dic.Keys)
{
Console.WriteLine("la clé est : " +s) ;
}
// pour afficher les valeurs
foreach (personne p in dic.Values)
{
}
}
20. La Classe String:

String est une classe fondamentale de .NET. Elle est exclusivement conçue pour stocker des chaînes de
caractères et met à disposition du programmeur un grand nombre d'opérations de traitement des chaînes.
String s = new String("chaine");

// Equivaut à
string s = "chaine";
- La concaténation :
string msg1 = "Hello";

string msg2 = " World";
msg2 = String.Concat(msg1, msg2);
//équivaut à
msg2 += msg1;
- Taille d’une chaine :
string str = "MaChaine"

Console.Write(str.length); // Affiche 8

- Remplacer une chaine :
string str = "MaChaine";

Console.Write(str.Replace("Ma", "Ta")); // affiche TaChain
- Taille d’une chaine :
string s1 = "hello";
string s2 = "hello";
bool c1 = s1.Equals(s2);
//équivaut à
bool c1 = (s1 == s2);
Méthodes de String:
public int IndexOf(string value, int startIndex);
Retourner la première position dans la chaine de la chaîne value. La recherche commence à partir du
caractère numéro : startIndex.
public string Insert(int startIndex, string value);
Insère la chaîne value dans la chaîne en position startIndex.
public static string Join(string separator, string[] value);
Méthode de classe, qui retourne une chaîne créée par la jonction de plusieurs sous-chaînes contenues
dans le tableau value qui sont séparée par separator.
public string[] Split(char [] separator);
Divise une chaîne en sous-chaînes en fonction des caractères contenus dans le tableau separator.

Exemple :
public class Test{

// une classe de démonstration
public static void Main(){
string uneChaine="l'oiseau vole au-dessus des nuages";
affiche("uneChaine="+uneChaine);
affiche("uneChaine.Length="+uneChaine.Length);
affiche("chaine[10]="+uneChaine[10]);
affiche("uneChaine.IndexOf(\"vole\")="+uneChaine.IndexOf("vole"));
affiche("uneChaine.IndexOf(\"x\")="+uneChaine.IndexOf("x"));
affiche("uneChaine.ToUpper()="+uneChaine.ToUpper());
affiche("uneChaine.ToLower()="+uneChaine.ToLower());
affiche("uneChaine.Replace('a','A')="+uneChaine.Replace('a','A'));
string[] champs=uneChaine.Split(null);
for (int i=0;i<champs.Length;i++){
affiche("champs["+i+"]=["+champs[i]+"]");
}
affiche("Join(\":\",champs)="+System.String.Join(":",champs));
affiche("(\" abc \").Trim() =["+" abc ".Trim()+"]");
}
public static void affiche(String msg){
// affiche msg
Console.WriteLine(msg);
}
}
// Affichage
----------------------------------
uneChaine=l'oiseau vole au-dessus des nuages
uneChaine.Length=34
chaine[10]=o
uneChaine.IndexOf("vole")=9
uneChaine.IndexOf("x")=-1
uneChaine.ToUpper()=L'OISEAU VOLE AU-DESSUS DES NUAGES
uneChaine.ToLower()=l'oiseau vole au-dessus des nuages
uneChaine.Replace('a','A')=l'oiseAu vole Au-dessus des nuAges
champs[0]=[l'oiseau]
champs[1]=[vole]
champs[2]=[au-dessus]
champs[3]=[des]
champs[4]=[nuages]
Join(":",champs)=l'oiseau:vole:au-dessus:des:nuages
(" abc ").Trim()=[abc]
21. Les exceptions :

Une exception est un signal qui se déclenche en cas de problème. Les exceptions permettent de gérer les cas
d'erreur et de rétablir une situation stable (ce qui veut dire, dans certains cas, quitter l'application
proprement). La gestion des exceptions se décompose en deux phases :
 La levée d'exceptions,
 Le traitement d'exceptions.
En C# Toutes les exceptions dérivent de la classe Exception.

Exemples des exceptions : affecter une valeur int à un string, un nombre divisé par zéro, ou entrée
inattendue (un utilisateur sélectionne un fichier inexistant).
a. Bloc Try ... Catch … Finally

Lorsque nous voulons exécuter un code susceptible d'être source d'erreurs, on utilise le bloc try. Ensuite
nous pouvons intercepter l'exception avec un (ou plusieurs) bloc(s) catch. Enfin, nous pouvons utiliser le
bloc finally pour effectuer systématiquement une opération après la tentative d'exécution.
Exemple :
try
{
Console.Write("Entrez un nombre : ");
int n = int.Parse(Console.ReadLine());
Console.WriteLine( "100/nombre = {0}", 100/n);
}
catch (DivideByZeroException dbzEx)
{
Console.WriteLine("Erreur : division par zéro.");
}
catch (Exception ex)
{
Console.WriteLine("Une autre exception a eu lieu : {0}.",
ex.Message);
}
finally
{
Console.WriteLine("Quel que soit le résultat, ceci est affiché.");
}
b. Créer une classe d'exception

Lancer une exception signale une erreur particulière. Si aucune classe d'exception ne convient ou n'est
suffisamment précise, ou si l'exception doit comporter des informations supplémentaires, il est possible de
créer une nouvelle classe d'exception.
Pour cela, il faut dériver la classe Exception ou l'une de ses sous-classes. Par convention, toutes ces sous-
classes ont un nom se terminant par Exception.
Exemple :
public class MaException : Exception

{
public MyException() : base("Message par défaut de l'exception.")
{
}
public MyException(string message) : base(message)
{
}
}

Ensuite, cette classe peut être utilisée comme n'importe quelle autre classe d'exception. Donc dans le cas
d'erreur dans une méthode d'un programme (arguments invalides, ...), il est possible de lancer une notre
propre exception en utilisant le mot clé throw.
// Méthode 1
if ( arg==null )
throw new MyException();
// Méthode 2
if ( arg==null )
throw new MyException("Msg");

POO Cours

Transféré par

Informations du document

Titre original

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

POO Cours

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Orientée Objets(C#) ISTA OULED TEIMA - TDI 1 è m e Anné e 2016/2017

Programmation orientée objet en c#

2. Déclaration d’une classe d’objet en C# :

public class Nom_Classe{

Le fichier contenant le code source portera le nom Nom_Classe.cs.

3. Déclaration des propriétés (attributs) :

public class nom_classe{

Une propriété peut être initialisée lors de sa déclaration :

Type_propriete nom_propriete = valeur_initiale ;

www.elbahihassan.com 1/22 Pr. : El Bahi Hassan

4. Déclaration des propriétés (attributs) :

Public class Rectangle {

//Implémentation des methodes

 Les identifiants des méthodes commencent par majuscule.

 Déclaration d’une variable de type de la classe d’objet.

 Il possède le même nom que l’identificateur de la classe.

www.elbahihassan.com 2/22 Pr. : El Bahi Hassan

Surcharge des constructeurs :

- Le constructeur d’initialisation (ou le constructeur avec paramètres) : Ce constructeur initialise les

public class Client {

private int num ;

//Implémentation d’un constructeur d’initialisation

public Client(int num, string nom, double ca){

Cela va permettre d’instancier la classe Client de la façon suivante :

Instanciation du constructeur par défaut se fait de la façon suivante :

www.elbahihassan.com 3/22 Pr. : El Bahi Hassan

//constructeur par defaut

public Client (Client c){

8. Déclaration des propriétés (méthodes) :

a) Protection des propriétés :

www.elbahihassan.com 4/22 Pr. : El Bahi Hassan

public class Client {

private int num ;

//Implementation des methodes

public void modifierNom(string n){

b) Les méthodes d’accès aux propriétés :

 Pour connaitre la valeur de la propriété (un accesseur ou un getter).

Les accesseurs (getters) :

Client c = new Client() ;

int numero = c.num ; // faux , car l’attribut num est private

int numero = c.GetNum() ;// OK

www.elbahihassan.com 5/22 Pr. : El Bahi Hassan

Les mutateurs (setters):

public void SetNum(int numero){

Client c = new Client() ;

c.num=5 ; // faux, car l’attribut num est private

9. Les propriétés statique (static):

//constructeur par défaut

www.elbahihassan.com 6/22 Pr. : El Bahi Hassan

10. Les méthodes statiques :

public static int GetCompteur(){

public static void Main(string[]args){

Client cli=new Client(5,"Said" , 21000);

int a= cli.GetCompteur(); //Faux GetCompteur est une méthode statique

www.elbahihassan.com 7/22 Pr. : El Bahi Hassan

Dans cet exemple :

 ClasseA est la classe parente (classe mère).

b) Protection des propriétés et des méthodes :

public class ClasseA {

www.elbahihassan.com 8/22 Pr. : El Bahi Hassan

public class ClasseB : ClasseA{

Dans cet exemple :

 ClasseA est une classe de base.