02/10/2023

Microsoft .Net - C#
La Programmation
Orientée Objet

Meriem BENHADDI

FSTG Marrakech

La programmation procédurale
Approche intuitive : La découpe fonctionnelle d'un
problème informatique en blocs indépendants : la
création de fonctions qui admettent des arguments et
renvoient des valeurs. Exemple : C, Pascal...

Exemple : Application de gestion de bibliothèque

Fonctions à développer :

- Achat de nouveau document (livre) : données sur le

document, le fournisseur, le prix,…
- Prêt de document : données sur le document,
l’emprunteur, la durée du prêt, l’état du document avant et
après le prêt, l’employé ayant réalisé l’opération de prêt,…
-……….

1
 02/10/2023

La programmation procédurale
Avantages : La réutilisabilité du code
La découpage d’un problème en blocs indépendants (fonctions
et procédures) va permettre aux programmeurs de réutiliser
les fonctions déjà développées : concept d'appel procédural .
Ce qui favorisera davantage la productivité.

Inconvénients : maintenance complexe en cas

d'évolution
Avec l’augmentation de la taille des programmes, la
programmation procédurale atteint ses limites : les fonctions
deviennent interdépendantes : une simple mise à jour du
logiciel à un point donné peut impacter en cascade une
multitude d'autres fonctions.

La programmation procédurale

Exemple de situations embarrassantes :

Evolution majeure de logiciel : passage de la gestion d'une
bibliothèque à celle d'une médiathèque.
De nouvelles données à gérer (DVD, cassettes)
les traitements évoluent : l’affichage sera différent selon le
type (livre, CD, DVD …), la durée d’emprunt par un étudiant va
différer, etc.

Faire évoluer l’application de gestion de bibliothèque pour

gérer une médiathèque, afin de prendre en compte de
nouveaux types d'ouvrages (cassettes vidéo, CD-ROM, etc...),
nécessite d'adapter les traitements, qui ne manipulaient à
l'origine qu'un seul type de document (des livres) modifier
toutes les portions de code pour gérer les données et les
actions propres aux différents types de documents.

2
 02/10/2023

La programmation procédurale

Amélioration :
Afin d’éviter l’augmentation de l’effort d’évolution des
applications, on peut :
- rassembler les valeurs qui caractérisent un type, dans
le type
- centraliser les traitements associés à un type, auprès
du type

Ainsi, si la médiathèque devait gérer un nouveau type

d'ouvrage, il suffirait de modifier une seule structure de
données, pour assurer la prise en compte de ce nouveau type
de document. Plus besoin de fouiller partout dans le code...

La programmation procédurale

Nouvelle structure de données :

Document
Code document
Nom document
Type document
Calculer date
rappel

Centraliser les données d'un type et les traitements

associés, dans une même unité physique, permet de
limiter les points de maintenance dans le code et
facilite l'accès à l'information en cas d'évolution du
logiciel.

3
 02/10/2023

Le concept d’objet :

L’objet constitue l’évolution de la structure de données.

Un objet constitue le concept fondateur de l'approche orientée

objet.

L'approche objet a été inventée pour faciliter l'évolution

d'applications complexes.

Un objet est une entité qui possède une identité (un nom).
Un ensemble d'attributs caractérise l'état de l'objet.
Un ensemble d'opérations (méthodes) en définissent le
comportement.
Un objet est une instance de classe (une occurrence d'un type
abstrait).
Une classe est un type de données abstrait, caractérisé par des
propriétés (attributs et méthodes) communes à des objets et
permettant de créer des objets possédant ces propriétés.

Document
Code document : int
Nom document : String
Type document : String
Calculer date rappel() : Date

4
 02/10/2023

C’est quoi la programmation

orientée objet ?
Concept de classe : C’est un type. C’est la description d’un
ensemble d’objets ayant une structure de données commune
et disposant des mêmes méthodes.
Concept d’objet : c’est une donnée dont le type est une
classe. On parle aussi d’instance d’une classe. un
programme est l’ensemble de différents objets (données +
méthodes).
Concept d’attribut: c’est une donnée définie dans la classe
Concept de méthode: c’est une fonctionnalité décrite dans la
classe.
Concept d’encapsulation : impossible d’agir directement
sur les données d’un objet, il faut passer par les méthodes.
Intérêt : vu de l’extérieur, l’objet est caractérisé uniquement
par les spécification de ses méthodes.
Concept d’héritage : permet de définir une classe à partir
d’une classe existante, à laquelle on ajoute de nouvelles
9
données et de nouvelles méthodes.

La programmation Orientée Objet

L'idée de base de la programmation

orientée objet est de rassembler dans
une même entité appelée objet les
données et les traitements qui s'y
appliquent.

10

5
 02/10/2023

Le concept de classe
Une classe est un ensemble d’attributs et de méthodes
regroupées dans une même entité. C’est une description
abstraite d'un objet.

C# est un langage orienté objet : tout appartient à une classe.

Une classe comporte sa déclaration, des variables et la

définition de ses méthodes.

Pour accéder à une classe il faut en déclarer une instance de

classe ou un objet.

Instancier une classe consiste à créer un objet sur son modèle.

Entre classe et objet il y a, en quelque sorte, le même rapport
qu'entre type et variable.
11

Création de la première classe C#

Bouton droit sur le projet – Ajouter – Nouvel
élément

12

6
 02/10/2023

Le concept de classe
Voici le code initial de la classe Rational:

Namespace POO
{
class Rational
{
public int numerator; //un attribut de la classe
public int denominator; //un autreattribut de la classe
// une méthode permettant de transformer notre objet en une chaine de
caractères
public override string ToString()
{
return "[" + this.numerator + "/" + this.denominator + "]";
}

}
}

13

Comment utiliser cette classe ?

Les objets

14

7
 02/10/2023

Les objets

Un objet est une instance d'une classe.

La classe est la description d'un objet.

Les objets contiennent des attributs et des

méthodes.
Pour chaque instance d'une classe, le code est le
même, seules les valeurs des attributs sont
différentes dans chaque objet.

15

La création d'un objet : instancier une classe

Il est nécessaire de définir la déclaration d'une

variable ayant le type de l'objet désiré :
nom_de_classe nom_de_variable

Exemple :
String chaine;

Rational r;

Nom de la classe Nom de la variable

16

8
 02/10/2023

La création d'un objet : instancier une classe

L'opérateur new se charge de créer une instance de

la classe et de l'associer à la variable

Exemple :

m = new Rational();

17

La création d'un objet : instancier une classe

Il est possible de tout réunir en une seule

déclaration

Exemple :

Rational r = new Rational();

18

9
 02/10/2023

La création d'un objet : instancier une classe

Analysons l’instruction :
Rational r = new Rational();

1. Chaque instance d'une classe nécessite sa propre variable.

2. Les variables de type objet que l'on déclare ne contiennent pas

un objet mais une référence vers cet objet.

La variable m contient une référence sur l'objet instancié, c’est à

dire l'adresse de l'objet qu'elle désigne.

19

Voici un code d’utilisation de notre classe Rational:

Namespace POO
{
class Program
{
static void main(string[] args)
{
Rational r1 = new Rational();
r1.numerator = 1;
r1.denominator = 2;
Console.WriteLine(r1.ToString());
Console.WriteLine(r1); //Appel implicite à ToString
}

}
}
20

10
 02/10/2023

Pour cacher l’état interne des attributs et les encapsuler, on

doit changer leur visibilité et créer des propriétés:

private int denominator; // L’attribut

public int Denominator // La propriété
{
get
{
return this.denominator;
}

set
{
if (value == 0)
throw new Exception ("Denominator cannot be 0");
this.denominator = value;
}
}

21

Pour utiliser une propriété, on procède comme pour un attribut

de classe:
Les appels au get et au set seront implicites

22

11
 02/10/2023

Les constructeurs

23

Règles à respecter
1- Constructeur d’instance:
Un constructeur doit utiliser le nom de la classe
Un constructeur ne doit pas retourner de valeur de retour. Il ne
doit même pas y avoir la présence du mot clé void
Les constructeurs acceptent la surcharge

2- Constructeur de classe
Il doit être static
Il ne sera invoqué qu’une unique fois au chargement de la
classe
Il ne prend pas de paramètre.

24

12
 02/10/2023

Voici un code pour définir un constructeur acceptant 2

paramètres avec des valeurs par défaut, pour définir l’état
initial de vos objets:

class Rational
{
private int numerator;
private int denominator;

public Rational(int num=0, int den=1)

{
this.Numerator = num;
This.Denominator = den;
}
// la suite de la classe
}
25

Destructeur d’objet
Cette méthode détruit l’objet et libère l’espace mémoire pour
être utilisé
Le destructeur de classe doit avoir le même nom que la classe
préfixée du caractère ~

class Rational
{
~Rational()
{
Console.WriteLine(“Objet détruit”);
}

26

13
 02/10/2023

Définition d’opérateurs
C# permet de définir des opérateurs sur vos classes.
Par exemple, la classe String redéfinit l’opérateur + pour
réaliser des concaténations de caractères
De même, vous pouvez ajouter des opérateurs arithmétiques
et de comparaison à votre classe Rational

class Rational
{
// Début de la classe
public static Rational operator+(Rational r1, Rational r2)
{
return new Rational(
r1.numerator*r2.denominator +
r1.denominator*r2.numerator, r1.denominator*r2.denominator
);
}
27
// suite de la classe

Exemple d’utilisation de notre nouvel opérateur:

28

14
 02/10/2023

Les arguments d’une méthode

29

Les arguments d’une méthode

Vous pouvez définir des méthodes avec des arguments par
défaut:
static int power(int value=0, int power=1) {……}

Dans ce cas et en l’absence de valeurs lors de l’appel de la

méthode, c’est la valeur par défaut qui sera utilisée.
int result = power(); // value:0 et power:1
int result = power(2); // value:2 et power:1

Vous pouvez aussi choisir l’ordre de passage des

paramètres:
int result = power(power:8, value:2); // value:2 et
power:8

30

15
 02/10/2023

Les arguments d’une méthode

Par défaut, les arguments de type primitif (int, float, double,
…) sont passés par copie
Vous pouvez définir des paramètres passés par référence
static void swap(ref int first, ref int second)
{
int temp=first;
first=second;
second=temp
}
static void main(string [] args)
{
int a=3;
int b=7;
swap(ref a, ref b);
}

31

Les arguments d’une méthode

Arguments muets ou effectifs :

Les arguments figurant dans l’en-tête de la
définition d’une méthode se nomment arguments
muets.
Les arguments fournis lors de l’appel de la
méthode portent le nom d’arguments effectifs

32

16
 02/10/2023

Les arguments d’une méthode

Conversion d’arguments:
Jusqu’ici, nous avons appelé les méthodes en utilisant des
arguments effectifs d’un type identique à celui de
l’argument muet.
Cependant, C#nous permet d’utiliser un type différent. Il
faut simplement que la conversion dans le type attendu soit
une conversion implicite légale : qu’elle respecte la
hiérarchie :

byte short int long float double

char int long float double

33

Les arguments d’une méthode

Conversion d’arguments:
Exemple :
class Point {
void deplace (int dx , int dy) { …….. }
………………..
}
Point p = new Point(…) ;
int n1 , n2 ; byte b ; long q;
p.deplace (n1 , n2) ; //ok, appel normal ;
p.deplace (b+3 , n1) ;
//ok, b+3 est de type int
p.deplace (b , n1) ;
//ok, b de type byte sera converti en int
p.deplace (n1 , q) ;
//erreur, q de type long, ne peut être converti en int
p.deplace (n1 , (int)q) ;
//ok
34

17
 02/10/2023

La surcharge (surdéfinition) des

méthodes

35

Méthodes : La surcharge des

méthodes
On parle de surféfinition (surcharge) lorsqu’un
même symbole possède plusieurs significations
différentes entre lesquelles on choisit en fonction du
contexte.

En C#, plusieurs méthodes peuvent porter le même

nom, le nombre et le type des arguments étant
différents permettant au compilateur de choisir.

36

18
 02/10/2023

Méthodes : La surcharge des

méthodes
Class Point
Exemple introductif { public Point (int abs, int ord)
{x=abs; y=ord;
On dote la classe Point de trois }
méthodes : public void deplace1(int dx, int dy)
Deplace1 : avec 2 arguments { x+=dx; y+=dy;
de type int }
Deplace2 : avec un seul public void deplace2(int dx)
argument de type int { x+=dx;
Deplace3 : avec un seul }
argument de type short
public void deplace3(short dx)
{ x+=dx;
}
Private int x,y;
}

37

Méthodes : La surcharge des méthodes

Définition :
La surcharge d'une méthode permet de
définir plusieurs fois une même méthode
avec des arguments différents en se basant
sur des signatures différentes.

38

19
 02/10/2023

Méthodes : La surcharge des méthodes

On appelle signature d'une méthode la donnée de :

• son nom
• le nombre de ses paramètres
• les types des paramètres.

Java permet de donner le même nom à deux

méthodes différentes à condition que les signatures
de ces deux méthodes soient différentes.

Le compilateur choisi la méthode qui doit être

appelée en fonction du nombre et du type des
arguments.
39

Méthodes : La surcharge des méthodes

Class Point Public class surdef

{ public Point (int abs, int ord) {
{x=abs; y=ord; public static void main (String arg[])
} {
public void deplace(int dx, int dy) Point a = new Point();
{ x+=dx; y+=dy; a.deplace(1,3); //appelle deplace(int,int)
} a.deplace(2); //appelle deplace(int)
public void deplace(int dx) short p =3 ;
{ x+=dx; a.deplace(p); //appelle deplace(short)
} byte b=2;
public void deplace(short dx) a.deplace(b); //appelle deplace(short) après
{ x+=dx; conversion de b en short
} }
Private int x,y; }
}

40

20
 02/10/2023

Méthodes : La surcharge des méthodes

Attention !
Il n'est pas possible d'avoir deux méthodes
de même nom dont tous les paramètres sont
identiques et dont seul le type retourné
diffère : le type de retour d’une méthode
n’intervient pas dans le choix d’une méthode
surdéfinie.

41

Méthodes : La surcharge des méthodes

Exemple : class Affiche{

public float convert(int i){
return((float) i);
}
public double convert(int i){
return((double) i);
}
}
Résultat à la compilation :
Error(s):
Type ’Affiche' already defines a member called
'convert' with the same parameter types

42

21
 02/10/2023

Méthodes : La surcharge des méthodes

Cas d’ambiguité : Public class surdef

Class Point {
{ public Point (int abs, int ord) public static void main (String arg[])
{x=abs; y=ord; {
} Point a = new Point();
public void deplace(int dx, byte dy) int n ; byte b ;
{ x+=dx; y+=dy; a.deplace(n,b); //Ok,appel deplace(int,byte)
} a.deplace(b,n); //Ok,appel deplace(byte,int)
public void deplace(byte dx, int dy) a.deplace(b,b); //erreur : ambiguité
{ x+=dx; //Error(s):The call is ambiguous between the
} following methods or properties:
Private int x,y; 'Point.deplace(int, byte)' and
'Point.deplace(byte, int)'
}
}
}
Pour le dernier appel, il existe deux possibilités :
soit convertir le premier argument en int et utiliser deplace(int,byte)
soit convertir le deuxième argument en int et utiliser deplace(byte,int)

43

Méthodes : La surcharge des méthodes

Choix de la méthode :
A la rencontre d’un appel de méthode, le compilateur recherche
toutes les méthodes acceptables et il choisit la meilleur si elle
existe.
Pour qu’une méthode soit acceptable, il faut :
1- qu’elle dispose du nombre d’arguments voulus
2- que le type de chaque argument effectif soit compatible par
conversion implicite avec le type de l’argument
correspondant
3- Qu’elle soit accessible (une méthode privée sera acceptable
uniquement pour un appel depuis l’intérieur de la classe)

44

22
 02/10/2023

Méthodes : La surcharge des méthodes

• Le choix de la méthode se déroule ainsi :

Si aucune méthode n’est acceptable, il y’a erreur de

compilation
Si une seule méthode est acceptable, elle est utilisée
pour l’appel
Si plusieurs méthodes sont acceptables, on procède par
élimination. Si après élimination, il reste plus d’une
méthode, on obtient une erreur de compilation
mentionnant une ambiguïté

45

Méthodes : La surcharge des méthodes

• Élimination des méthodes :

Pour chaque pair de méthodes M et M’, si tous les arguments

de M sont compatibles avec les argumenst de M’ (les types
des arguments de M peuvent être convertis implicitement
vers les types des argumenst de M’), M’ est éliminée.

Exemple 1:

public void deplace(int n1,int n2)

public void deplace(float x, int n)

public static void main(String args []){

int a=3, b=5;
Deplace(a,b); //Appel de la premiere méthode
46

23
 02/10/2023

Méthodes : La surcharge des méthodes

• Élimination des méthodes (Suite):

Exemple 2:

public void deplace(int n,float x)

public void deplace(float x, int n)

public static void main(String args []){

int a=3, b=5;
Deplace(a,b); //Erreur : ambiguité

47

Méthodes : La surcharge des méthodes

Surdéfinition des constructeurs :

Les constructeurs peuvent être surdéfinis comme n’importe quelle
autre méthode :

class Point
{ public Point()
{ x=0; y=0;
}
public Point(int abs)
{ x=y=abs;
}
public Point(int abs, int ord)
{ x=abs; y=ord;
}
} 48

24
 02/10/2023

Méthodes : La surcharge des méthodes

Surdéfinition et droits d’accès :

Toute méthode, publique ou privée, peut être surdéfinie.

Cependant, les méthodes privées ne sont accessibles qu’à
l’intérieur de la même classe.

Les surdéfinitions privées d’une méthode ne sont pas visibles de

l’extérieur de la classe.

49

Méthodes : La surcharge des méthodes

Exemple :
Public class Surdfac Public class Surdfac
{ public void f(float x) { public static void main(String
{system.out.println(x); argv[])
} {A a=new A();
{ private void f(int n) a.g();
{system.out.println(n); int n=2;float x=2.5f;
} a.f(n); a.f(x);
{ public void g()
}
{ int n=1; float x=1.5f;
}
f(n); f(x);
}
}

Résultats :
n=1
x=1.5
n=2.0
x=2.5 50

25
 02/10/2023

Méthodes : La surcharge des méthodes

Vous pouvez aussi définir des méthodes à nombre

variable de paramètres. ça permet d’éviter
beaucoup de surcharge
int Add(params int[] values)
{
int accumulator=0;
foreach(var param in values) accumulator+=param;
return accumulator;
}

On peut maintenant appeler la méthode avec autant de paramètres

souhaités:
var total = Add(1, 2, 3, 4, 5);

51

Méthode à plusieurs valeurs de retour

La manière la plus simple est de retourner un tableau de

valeurs
Il est aussi possible de retourner un tuple pour faciliter la
récupération des valeurs
Deux syntaxes sont possibles:
Première syntaxe d’utilisation explicite d’un tuple:
static Tuple<string, string> GetData1()
{
return Tuple.Create("Amal", "Ahmed");
}
Utilisation de la méthode:
var data = GetData1();
Console.WriteLine(data.Item1);
Console.WriteLine(data.Item2);
ou bien :
(string name1, string name2)= GetData1(); 52

26
 02/10/2023

Méthode à plusieurs valeurs de retour

Seconde syntaxe d’utilisation d’un tuple:

static (string, string) GetData2()
{
return Tuple.Create("Amal", "Ahmed");
}
Utilisation de la méthode:
var data = GetData2();
Console.WriteLine(data.Item1);
Console.WriteLine(data.Item2);
ou bien :
(string name1, string name2)= GetData2();

53

Méthodes static

54

27
 02/10/2023

Méthode static
En C#, on peut définir des champs, qui au lieu d’exister dans
chacune des instances de la classe, n’existent qu’en un seul
exemplaire pour toutes les instances d’une même classe.

Il s’agit de données globale partagée par toutes les instances

d’une même classe.

Les méthodes static sont celles qui n’ont pas besoin d’un objet
pour être invoquées (elles se rapprochent des méthodes
classiques de C). C’est le cas de la méthode main.

55

Méthode static

Une méthode static est invoquée en lui associant,

non pas un objet, mais la classe à laquelle elle
appartient

Exemple : la méthode sqrt qui calcule la racine

carrée d’un nombre, appartient à la classe Math.
Pour invoquer cette méthode :
Math.sqrt(x)

56

28
 02/10/2023

Utilité de champs ou méthode static :

Compter le nombre d’objets créés
Partager des données: par exemple, dans la
classePoint on introduit deux champs static
destinés à contenir les coordonnées d’une origine
partagée par tous les points.
Fournir des fonctionnalités indépendantes des
objets, exemple : dans la classe Math, on trouve
les méthodes : sqrt, sin, cos.

57

Méthode static

Règles à respecter :

Une méthode static, puisqu’elle ne s’applique pas

sur un objet, ne peut pas accéder aux variables
d’instances, sauf celles passées en paramètres.

Le mot clé this n’a pas de sens dans une méthode

static

58

29