Introduction à la programmation orientée...

Introduction à la programmation orientée objet

Classes, objets et encapsulation

1

Principes des langages procédurauxOn sépare les données des traitements opérant sur ces données.Un programme est composé de plusieurs procédures (ou fonctions) :

qui effectuent un traitement sur des données (procédure) qui retournent une valeur après leur invocation (fonction)

Exemples de langages procéduraux : Pascal, algol, C, …

2

Fonction 1 Fonction 2Donnée 1

opère sur (valeur de retour)

Influence (arguments)

Donnée 2

Influence (arguments)

Programme procédural

3

public class Test10 {public static void main(String []args) {

double largeur1 = 4.0;double hauteur1 = 3.0;double largeur2= 10.0;double hauteur2 = 6.0;System.out.println(surface(largeur1, hauteur1));System.out.println(surface(largeur2, hauteur2));

}static double surface(double largeur, double hauteur) {

return largeur * hauteur;}

}

Pas de lien sémantique entre les données et pas de lien entre les données et traitements qui sont « dispersés »

Or, il s’agit de la hauteur, de largeur et de la surface d’un « Rectangle »

double largeur = 4.0;double hauteur = 3.0;double surface(…)

Un objet « Rectangle »

double largeur = 10.0;double hauteur = 6.0;double surface(…)

Un autre objet « Rectangle »

Faiblesses des langages procéduraux

• Les programmes sont :– Peu évolutifs

– Peu robustes

– Difficiles à structurer

– Peu réutilisables

– Difficiles à maintenir

– ....

• Les langages procéduraux sont inadaptés à la gestionde la complexité du logiciel, en particulier, à cause dela perte d’unité entre données et traitements demêmes entités

4

Bonnes propriétés d’un logiciel

• Un logiciel est « correct » s'il est conforme à sesspécifications.

• Mais aussi , il doit être apte au changement :

– Un logiciel est robuste s'il agit de façon appropriée à desévénements imprévus

– Un logiciel est extensible s'il s'adapte facilement auxchangements de spécifications

– Un logiciel est réutilisable s'il peut servir pour construiredes applications différentes de celles pour laquelle il estprévu

• L’objectif principal de la Programmation Orientée Objet estd’organiser des programmes afin qu’ils soient robustes,extensibles et réutilisables

5

Principe d’encapsulation

• Regrouper dans une même une même entité, l’objet, lesdonnées et les traitements qui lui sont spécifiques

– attributs / champs : les données correspondant auxpropriétés de l’objet

• L’ensemble de ces données définit l’état de l’objet

– méthodes / opérations : traitements l’objet peut faire

• L’ensemble de ces traitements définit lecomportement de l’objet

• L’interface est définie par les méthodes accessiblesde l’extérieur : les méthodes de l’interfacecorrespondent aux messages que les objets sontsusceptibles de traiter

• L’encapsulation va donc donner une « unité logique demanipulation » des données et des traitements

6

Principe d’abstraction et classe

• L’abstraction consiste à identifier pour un ensembled’éléments :– des caractéristiques et comportements communs qui

leur sont applicables, afin d’obtenir une descriptiongénérique de l’ensemble. L’abstraction va donc donnerune « unité sémantique » aux objets.

• Une classe regroupe les objets qui ont les mêmescaractéristiques, c’est donc une abstraction (modèle)d’un ensemble d’objets en leur conférant à la fois une« unité sémantique » et une « unité de manipulation ».– En POO, une classe est un type à part entière qui sert à

définir des objets qui sont aussi appelés des instances dela classe

– La classe sert de modèle pour fabriquer des objets

7

Exemple d’objets : état, identité, ...

maVoiture

- couleur = rose- vitesse = 100

point1

- x = 10- y = 4- visible = true

identité

identité

état}

état}

Comportement :+ accélérer

Comportement :+ translater

8

Exemple d’objets : message et changement d’état

maVoiture


point1


accélérer(10)

translater(3, 2)

maVoiture


point1


moi

unDessinateur

L’état change, mais ni l’identiténi le comportement

9

Exemple de classes et d’objets

maVoiture

- puissance = 90- couleur = rose- vitesse = 100

point1


Voiture

-puissance : entier-vitesse : réel-couleur : chaîne

+accélère(réel) : rien+quelleVitesse() : réel

taVoiture

- puissance = 110- couleur = jaune- vitesse = 0

Point

-x : réel-y : réel-visible : booléen

+translate(réel, réel) : rien+estVisible() : booléen

point2

- x = 0- y = 1- visible = false

instanciation

Classes Objets 10

Programmation orientée objet

D

D

DD

D

F F

FF

F

Un programme objet = un ensemble d'objets en interaction

En Programmation Orientée Objet, on décrit desclasses et l’application en elle-même va êtreconstituée des objets instanciés à partir de cesclasses, qui vont communiquer et agir les uns surles autres par envoi de message.

Java est un langage orienté objet, comme C++, Smalltalk, Eiffel, Simula , ...

11

Encapsulation suite …

• Dissimulation :

– Seul le concepteur de la classe a besoin de connaître lesdétails d’implémentation : Niveau interne

• Assure la cohérence des objets

– L'accès aux champs (attributs) est généralement privé,seules ses méthodes (opérations) peuvent les manipuler

• Interface :

– L’utilisateur manipule des objets de la classe aux traversde l’interface de la classe (il n’a pas à connaître lesdétails d’implémentation) : Niveau externe

– L’objet est manipulé au travers de ses méthodespubliques qui constituent l’ensemble des messages qu’ilest apte à traiter, appelée interface

12

Synthèse autour de l’encapsulation / abstraction

13

Concepteur de classe (vision interne) :• Regrouper tout ce qui caractérise les objets de la classe les données (attributs) et traitements (méthodes)• Isoler et dissimuler des détails d’implémentation• Assurer la cohérence interne

Utilisateur de classe (vision externe) :• Utiliser les classes comme des types• Manipuler les objets au travers de leur interface • Concevoir le programme par assemblage d’objets

class Point {double x, y;boolean visible;void translate(double dx, double dy){…}boolean estVisible(){ …}

}

Point p1 = …;p1.translate(2, 3);Point p2 = …;System.out.println(p2.estVisible());

Encapsulation / dissimulation

14

Attributs Méthodes

Interface(partie visible)

Implémentation(partie cachée)

définitiontranslate(double dx, double dy){

x +=dx;y +=dx;

}

définitiondouble x, y;

boolean visible;

spécificationtranslate(double, double)

Mise en œuvre de la POO en Java

Classes, objets et encapsulation

15

Ce qu’il faut mettre en œuvre en Java

• En Programmation Orientée Objet :

– Le résultat des processus d’encapsulation (dissimulation) etd’abstraction s’appelle une classe

– Une classe définit un type, une réalisation particulière d’uneclasse s’appelle une instance (un objet)

16

Classe (UML) Objets (UML)

Instanciation

Définition d’une classe en Java

• Une classe Java se définit (hors héritage) :

[Modificateur] class MaClasse

{

définition des champs et des méthodes : membres

}

• MaClasse est le nom de la classe : identificateur licite du langage

– par convention, la première lettre est majuscule

• Modificateur : public, rien ou private

– public : les membres publics sont accessibles par tous. La partie publiqueest appelée interface. Il n’y a qu’une classe publique par fichier

– rien (friendly) : tous les membres publics sont accessibles dans le package

– private : les membres privés ne sont accessibles que par les méthodes(fonctions membres) de la classe. La partie privée est aussi appeléeimplémentation ou réalisation. Une classe (non interne) ne peut pas êtreprivée.

• Une classe, une fois définie, devient un type à part entière17

Définition des membres - 1

• Les membres (champs ou méthodes)

– Leur ordre dans une classe n'a pas d'importance

– Leur définition est précédée du modificateur qui a la mêmesémantique que pour les classes (ne peut être que plusrestrictif)

• Les champs (attributs, données membres) :

– sont nuls par défaut (à l’opposé des variables locales)

– sont en général privés

– caractérisent l’état de l’objet

– sont manipulables par les méthodes de leur classe, même s’ilssont privés (portée classe)

18

Définition des membres - 2

• Les méthodes (fonctions membres) :

– sont en général publiques (elles constituent l’interface)

– celles qui modifient l’état d’un objet sont dites de modification(altérateurs ou mutateurs ou encore modificateurs)

– celles qui donnent une information sur l’état d’un objet sontdites d’accès (accesseurs ou observateurs)

– la surcharge d'une méthode permet de définir plusieurs foisune même méthode avec des arguments différents

• Les méthodes peuvent manipuler tous les champs de leur classe,même privés :

– On ne passe jamais en argument à une méthode les champsde sa propre classe

19

Instanciation d’un objet

• Déclaration– Pour manipuler un objet, on déclare une référence (variable

permettant d’identifier l’objet) de type classe de cet objet• MaClasse unObjet;

• Construction (ou initialisation)– Pour créer l’objet, on instancie sa classe en appliquant

l'opérateur new– Une nouvelle instance de cette classe est alors allouée en

mémoire– Initialisation : valeur par défaut, initialisation à la déclaration,

par les constructeurs (voir suite)• unObjet = new MaClasse(…);

• Principe de suppression des objets– La suppression des objets est réalisée par le garbage collector

(GC) qui détruit les objets pour lesquels il n'existe plus deréférence

– Les destructions sont asynchrones. Aucune garantie n'estapportée quant à la destruction effective d'un objet

20

Exemple de synthèse

21

class Point {private int x, y;public void init(int nx, int ny){x = nx;y = ny;

}public void translate(int dx, int dy){x += dx;y += dy;

}}

Point p1 = new Point();p1.init(0, 0);Point p2 = new Point();p2.translate(5, 8);Point p3 = new Point();p3.init(10, 20);

Point est un type

p1 est une variable

Création d’uneinstance de Point

Définition des champs x et yIls sont privés

Définition de la méthode translateElle est publique

translate peut manipuler les champ x et y

p3 référence un objet point

p2 appelle La méthode translate

Définition de la classe

Constructeur• Un constructeur est une méthode d'initialisation qui est appelée lors

de la création d’un objet (par exemple lorsque la valeur initiale d'unchamp est demandée dynamiquement à l'utilisateur).

• Le constructeur est une méthode :– de même nom que la classe

– sans type de retour (implicitement, il correspond à la classe)

– qui ne peut pas être appelée directement

• Toute classe possède au moins un constructeur.

• Si le programmeur ne le définit pas, il en existe un par défaut, quiinitialise les champs :– entiers 0

– réels 0.0

– boolean false

– Objets (dont tableau) null

• Pour une même classe, il peut y avoir plusieurs constructeurs, designatures différentes (surcharge).

22


23

class Point {private int x, y;public Point(int nx, int ny){x = nx;y = ny;

}public Point(){x = y = 0;

}}

Point p1, p2;p1 = new Point();p2 = new Point(10, 20);

Déclaration de deuxvariables de type PointDéfinition du constructeur

« int, int »

Définition du constructeursans argument

Création et initialisation d’un Point

Appel du constructeur « int, int »

Appel du constructeur sans argument

Autres possibilités d’initialisation des champs

• Les champs peuvent être directement initialisés à la déclaration

• Les champs peuvent être initialisés dans des blocs d’initialisation

24

class Point {private int x = 0, y = 0;…}

class Point {private int x , y ;{x = y = 0;

}…}

Initialisation à la déclaration

Initialisation via unbloc d’initialisation

Il faut privilégier les constructeurs pour les champs non constants

Si les trois modes sont utilisés, l’ordre est le suivant :1. Initialisation à la déclaration2. Exécution des blocs d’initialisation3. Exécution des constructeurs

Distinction entre objet et référence

25


}public void translate(int dx, int dy){x += dx;y += dy;

}}

Point p1 = new Point(2, 1);Point p2 = p1;p1.translate(1, 1);

Le point référencé par p1 est modifié, mais ce point est aussi référencé par p2

p1

p2

2 3

1 2

Pour que deux références d’objet manipulent deux objets distincts quipossèdent à un moment donné les mêmes contenus, on peut utiliser unconstructeur de recopie ou une méthode de clonage

Champs constants

• Un champ peut être déclaré comme constant :– modificateur final

• Il peut être initialisé de plusieurs manières :– à la déclaration

– dans le corps de chaque constructeur (initialisationtardive)

• Dans tous les cas, une initialisation doit être réalisée,l'initialisation par défaut est illicite.

• Si la valeur de cette constante est commune à tous lesobjets, c’est certainement qu’il s’agit d’une constantestatique (voir suite).

26


27

class Point {private int x, y;private final int MAX = 100;public Point(int nx, int ny){if(nx > MAX || ny > MAX) return;x = nx;y = ny;

}public Point(){x = y = 0;

}}

Déclaration d’un champ constant non initialisé

Définition d’un champ constant initialisé à la déclaration

class Point {private int x, y;private final int MAX ;public Point(int nx, int ny){MAX = 100;if(nx > MAX || ny > MAX)

return;x = nx;y = ny;

}public Point(){MAX = 100;x = y = 0;

}}

Initialisation du champ constant dans chaque

constructeur

Comparaison d'objets

• Les objets étant manipulés au travers de leurréférence, la comparaison de deux objets ne peutpas s'effectuer directement.– La comparaison directe (==) ne fait que comparer les

références

• Par convention, il peut être défini (redéfini)– une méthode equals qui, par convention, retourne

true si les champs de l’objet courant et l’objet passésont égaux, ou false sinon

– une méthode compareTo qui retourne une valeur detype int (retourner le signe de la soustraction virtuelleentre l’objet courant et l’objet passé)

– On peut donner à la référence d’un objet la valeurnulle : null• unObjet = null;


29


}public boolean equals(Point p) {

return x == p.x && y == p.y;}}

false car p1 et p2 ont des valeurs (de références) distinctes

Définition de la méthode decomparaison equals

Point p1, p2;boolean test;p1 = new Point(1, 2);p2 = new Point(1, 2);test = (p1 == p2);test = p1.equals(p2);p2 = p1;test = (p1 == p2);test = p1.equals(p2);

true car p1 et p2 ont des champs de valeurs identiques

true car p1 et p2 ont les mêmes valeurs (de références)

true car p1 et p2 ont des champs de valeurs identiques

Remarques ...

• Lorsqu'un objet est passé en paramètre, ce n'est pas l'objetlui-même qui est passé mais une référence de l'objet :

– Pour transmettre des arguments par référence à uneméthode, il faut les encapsuler dans un objet qui prévoitles méthodes nécessaires pour les mises à jour.

• Un objet ne doit être manipulé qu'au moyen de son interface(principe d'encapsulation) :

– Constructeur (même nom que la classe)

– Accesseur ou observateur (getNomChamp ouisNomChamp)

– Altérateur ou mutateur (setNomChamp)

– Les méthodes utilitaires et les champs membres doiventêtre privées

30

Champs statiques

• Il peut s'avérer nécessaire de définir un champ dont lavaleur soit partagée par toutes les instances d'une classe :– On les qualifie de variables de classe que l'on oppose aux

variables d'instance

• Ces variables sont, de plus, créées une seule fois, ellesexistent même si aucune instance n'est préalablementcréée.

• Pour la déclaration, le mot-clé static

• Accès :– depuis toute méthode de la classe, comme pour tout autre champ

– via une instance de la classe (si accessible)

– à l'aide du nom de la classe (si accessible)

31

Méthodes statiques• Il peut être nécessaire de disposer d'une méthode qui

puisse être appelée sans instance de la classe pourmanipuler des variables de classe. C'est une méthode declasse qui se déclare avec le modificateur static.

• Elles ont quelques particularités :– Puisqu'une méthode de classe peut être appelée sans même

qu'il existe d'instance

– Une méthode de classe ne peut pas accéder aux champs nonstatiques

– Elle ne peut accéder qu'à ses propres variables (locales) etaux champs statiques (variables de classe) et elle ne peutappeler que les méthodes statiques de sa classe

• Un bloc d‘initialisation peut être défini comme static pourréaliser des initialisations des champs statiques quis'exécutent une fois au lancement du programme

32

Construction des champs statiques des classes

• La partie statique d’une classe est toujours initialisée :

– Dès que l’on fait référence à un champ statique de cetteclasse ou à une méthode statique (sans même avoir créé unseul objet)

– Dès que l’on créé avec l’opérateur new le premier objet decette classe

• Cette initialisation a lieu une unique fois, avant celledes champs non statiques

33


34

class Point {private int x, y;private static int nb = 0;public Point(int nx, int ny){x = nx;y = ny;nb ++;

}public static int getNb() {

return nb;}}

Appel d’une méthode statiquebien qu’aucun Point n’ait été créé

Définition d’un champ statique (variable de classe)

int n;n = Point.getNb();Point p1, p2;p1 = new Point(10, 20);n = p1.getNb();p2 = new Point(0, 0);n = Point.getNb();

Définition d’une méthode statiquemanipulant le champ statique nb

Appel d’une méthode statiquedans un contexte d’instance

Appel d’une méthode statiquedans un contexte statique

Autres intérêts

• Les variables statiques peuvent être utilisées pourdéfinir des constantes dont la valeur est identiquepour tous les objets d’une classe particulière ; ellesjouent le rôle des constantes globales utilisées dansd'autres langages :

– final static double PI = 3.141;

• Les méthodes statiques jouent le rôle de servicesindépendants d'une classe particulière (même si cesfonctions sont logiquement regroupées dans uneclasse) :

– static double cos(…

35

Le mot clé this

• this correspond à la référence de l'objet courant.• Il est implicitement utilisé lorsqu'au sein d'une classe

une méthode de la classe est appelée ou qu'un champest utilisé.

• Il peut être utilisé pour :– appeler un constructeur dans un autre (this doit être

la première instruction)• Il est conseillé de définir un constructeur qui effectue tous

les traitements d’initialisation et de le faire appeler par lesautres constructeurs

– pour lever des ambiguïtés entre des noms de champet de variables locales

– pour retourner l’objet– this ne peut pas être utilisé dans une méthode

statique36


37

class Point {private int x, y;public Point(int x, int y){this.x = x;this.y = y;

}public Point(){this(0, 0);

}public Point raz() {

x = y = 0;return this;

}}

Levée d’ambigüitéx désigne le paramètre xthis.x désigne le champ x

Appel du constructeur « int, int »

Retourne la référence de l’objet courant

Ecriture à éviter

Diagramme de classes et classes en UML• Utilisation d'un langage pour modéliser les classes : diagramme de classes

d’UML (Unified Modeling Language).

• Il permet d’avoir une représentation synthétique des classes : on conçoit unmodèle de son application avant de coder …

Une classe est représentée par un rectangle (appelé un classeur) constitué de trois parties :

• le premier compartiment contient le nom de la classe

• le second contient les attributs de la classe

• le dernier contient les opérations de la classe

Généralement,, on nedéfinit pas deconstructeur dans uneclasse UML

38

De la conception au codage

• Traduction quasi-systématique d'un diagramme declasses UML vers du code Java

39

class Point {private int x, y;private static int nombre;private final int XMAX = 100;public Point(int nx, int ny){

}public int getX() {

}public int getY() {

}public void setX(int nx) {

}public void setX(int ny) {

}public boolean equals(Point p) {

}}

Il ne reste plus qu‘à coder le corps des méthodes …

Associations• Une association est une relation structurelle entre les objets du

système étudié. Elle peut-être caractérisée par :

– La multiplicité d’une classe qui spécifie le nombre d‘objetscibles pouvant être reliés avec une seul objet source de larelation. Elle est notée du côté cible de l'association :

40

La multiplicité 1.. * indique qu’une Télécommande

envoie des ordres de un à plusieurs LecteurDVDémetteur est le rôle

de la Télécommandedans l’association Le nom de la relation

indique sa sémantique, > en précise le sens de

lecture

La multiplicité 1 indique qu’un LecteurDVD reçoit

des ordres d’une et d’une seule télécommande

Les positions des multiplicités en UML sont inversées par rapport aux cardinalités présentes dans les modèles entité association (cours SYSI)

Type énuméré (Version simplifiée)

• enum qui permet de définir un ensemble de valeurs correspond à un nombreprédéfini et fixe d’instances d’une classes :

enum Parcours {

SPL, SCM, MSC, MPS;

}

• Référence d’une énumération :

Parcours p = Parcours.MIM;

• Le switch (particulier)

Parcours p = Parcours.SPL;

switch(p) {

case SPL :

case SCM : System.out.println(p + " super !");break;

default : System.out.println(p + " bof ! ");

}

• Les énumérations possèdent encore d’autres caractéristiques ...41

Tableau d’objets

• Un tableau d’objets est un tableau dont la valeur dechaque élément est la référence d’un objet.

42

Point []tp;tp = new Point[10];

for(int i = 0; i < tp.length; i ++){tp[i] = new Point(i, i+1);

}tp[1].print();

tp est la référence d’untableau de Points

Création d’un tableau contenant 10 références de Point

Affectation de chaque élément du tableau avec la référence d’un Point créé dynamiquement

Accès à l’élément 1du tableau de Points

Conseils de conception• Respecter le principe d’encapsulation

– Privatiser les champs (données), les champs doivent êtremanipulés par les méthodes publiques de la classe (interface)

• Initialiser les champs :

– Privilégier les constructeurs pour les initialisations (éviter lesinitialisations par défaut)

• Subdiviser et représenter les classes

– Permet d’avoir des classes compréhensibles et maintenablesqui doivent avoir un sens pour le problème traité (ellesdoivent être faiblement couplés et fortement cohésives)

– Nommer explicitement : classes, variables et méthodes

43

Conclusions

• L'approche objet est basée sur la description d’une familled’objets ayant une même structure et un mêmecomportement : la classe qui sert de moule à objets.

• Chaque classe est un modèle qui permet de construire desobjets par instanciation new.

• Chaque classe possède (au moins) un constructeur quipermet de l'initialiser et qui est appelé lors de l'instanciation.

• Il faut respecter le principe d'encapsulation :– les données et les fonctions qui les manipulent sont

regroupées dans une même entité, l'objet– Les détails d'implémentation sont cachés, l'accès aux champs

(attributs) n'est réalisée que par l'intermédiaire d'un ensemblede méthodes (opérations). Les méthodes publiquesconstituent l'interface de l'objet (en particulier, lesmodificateurs).

44

Quatrième série d’exercices début ...

?

45

Associations particulières: Composition• La composition (association avec un losange plein coté

composite) est une relation de contenance qui exprime unecomposition physique et qui est stable dans le temps et ne peutêtre partagée.

46

Une chaise est composée de pieds, la suppression de la

chaise provoque celle de ses pieds. Un pied appartient à une

seule chaise.

Agrégation• Relation de contenance qui exprime un couplage de type ensemble -

éléments et qui a une durée de vie limitée dans le temps :

• La suppression de « l’agrégeant » n’implique pas la suppressionde « l’agrégé »

• L'élément agrégé peut être partagé ou peut exister sans l’agrégeant

47

La suppression de la promotion n’entraine pas celle des

étudiants qui la compose.

Notation pour les attributs• Syntaxe des attributs :

– [visibilité] nom : type['['<multiplicité>'] '] [{contrainte}] [=valeur initial]

• Un attribut de classe est souligné

• Visibilité :

– -: Champ privé

– + : Champ publique

– ~ ou rien : package

– # : Champ protégé

• Contrainte :– frozen

– unique

– ...

• Exemples :

– - x : int

– + PI : double {frozen} = 3.1416

– ~ tz : float[10] 48

Notation pour les opérations• Syntaxe des opérations :

– [visibilité] nom [(liste des paramètres)] [: type de la valeur de retour] [{propriété}]

• Syntaxe pour les paramètres :– [direction] [nom] : type['['<multiplicité>'] '] [=valeur par défaut]

• direction :– in : lecture

– out : écriture

– inout : lecture et écriture

• Une opération de classe est soulignée

• Visibilité :– idem attributs

• Contrainte :– abstract

– isQuery

– ...

• Exemples :– + setX(in nx : int) : void

– + copie(out tx[10] : double) : int

– + setXY(int, int) void

– + getX() : int {isQuery} 49

Introduction à la programmation orientée...

Documents

Transcript of Introduction à la programmation orientée...