JavaBBSG2 02

La programmation orientee objets
et le langage Java
Master BBSG 2
Laurent Tichit
Departement Informatique et Interactions, Faculte des Sciences de Luminy
Cours 2: Lencapsulation
L.
c Tichit, 2015-2016 POO et Java 1/1
Lencapsulation
Concepts apparus à partir des annees 60

premiers langages : Simula (simulation), Smalltalk (IA, IHM, etc.)
L.
Lencapsulation

convergence de deux courants de recherche
courant genie logiciel :
lutter contre la complexite des gros programmes
problematique : correction, robustesse, reutilisabilite, etc.
L.
Lencapsulation

courant representation des connaissances :
problematique : representer
les concepts : cette table est une Table ,
labstraction : toute table est une sorte de meuble
L.
Lencapsulation

courant representation des connaissances :
problematique : representer
les concepts : cette table est une Table ,
labstraction : toute table est une sorte de meuble
principales notions
encapsulation
h
eritage
polymorphisme, redefinition des methodes, exceptions, genericite, etc.
L.
Lencapsulation
Encapsulation : objets et messages
Un programme est un ensemble dobjets opaques, autonomes, interagissant entre

eux par envoi de messages.
L.
Lencapsulation

Chaque objet a un etat prive, cache `
a linterieur, et un comportement public,
lensemble des messages auxquels lobjet reagit.
L.
Lencapsulation

sePlacer(a,b)
distance(p)
x()
toString()
y()
L.
Lencapsulation

Tout message a un destinataire. Le message dit quoi faire, mais non comment :
cest au destinataire de connatre les details pratiques de laction que le message
provoque chez lui.
L.
Lencapsulation

provoque chez lui.
Par exemple : distance(p,q) devient p.distance(q) .
L.
Lencapsulation

provoque chez lui.
Consequence : au lieu dune (unique) definition de distance, chaque classe
dobjets peut avoir la sienne.
L.
Lencapsulation

provoque chez lui.
Consequence : au lieu dune (unique) definition de distance, chaque classe
dobjets peut avoir la sienne.
Les objets sont reutilisables
composition : un objet est compose dautres objets
heritage : un objet est defini comme specialisation dun autre
L.
Lencapsulation
Attributs : variables et methodes

Un objet est fait de
une certaine quantite de memoire, organisee en champs, variables dinstance,
donnees membres, etc.
un certain nombre de fonctions, appelee methodes, fonctions membres, etc.,
quon ne peut appeler quen sadressant à cet objet.
L.
Lencapsulation

Variables et methodes sont les attributs des objets. Ils peuvent etre
publics, cest-` a-dire utilisables dans nimporte quel endroit du programme,
prives, cest-`
a-dire accessible uniquement dans lobjet auquel ils appartiennent.
L.
Lencapsulation

prives, cest-`
Encapsulation : dans lideal
seules sont publiques certaines methodes, robustes et documentees, qui
constituent linterface de lobjet ;
les variables et les autres methodes sont privees ; elles constituent
limplementation de lobjet et sont inutilisables depuis lexterieur.
L.
Lencapsulation

prives, cest-`
Encapsulation : dans lideal
seules sont publiques certaines methodes, robustes et documentees, qui
constituent linterface de lobjet ;
les variables et les autres methodes sont privees ; elles constituent
limplementation de lobjet et sont inutilisables depuis lexterieur.
Benefices majeurs :
correction : on peut garantir que letat dun objet est toujours coherent,
independance : on peut changer limplementation (details internes) dun objet
sans invalider les programmes qui lemploient.
L.
Lencapsulation
Objets et messages en Java
Comment cela se presente en Java ?

objets : des structures contenant des variables et du code
L.
Lencapsulation

etat : des variables, appelees champs ou variables dinstance
L.
Lencapsulation

comportement : des fonctions, appelees methodes (dinstance)
L.
Lencapsulation

envoi de message : appel de methode, sous la forme
p.distance(q) ou p.toString()
destinataire message arguments
L.
Lencapsulation

au lieu de : distance(p, q) ou toString(p)
L.
Lencapsulation

au lieu de : distance(p, q) ou toString(p)

Exemple : une classe Point pour representer les points du plan
L.
Lencapsulation
La classe Point
Fichier Point.java
class Point {
int x, y;
L.
Lencapsulation
La classe Point
Fichier Point.java
class Point {
int x, y;
void sePlacer(int a, int b) {
validation de a et b
x = a;
y = b;
}
L.
Lencapsulation
La classe Point
Fichier Point.java
class Point {
int x, y;
x = a;
y = b;
}
double module() {
return Math.sqrt(x * x + y * y);
}
L.
Lencapsulation
La classe Point
Fichier Point.java
class Point {
int x, y;
x = a;
y = b;
}
double module() {
}
double distance(Point p) {
int dx = x - p.x;
int dy = y - p.y;
return Math.sqrt(dx * dx + dy * dy);
}
L.
Lencapsulation
La classe Point
Fichier Point.java
class Point {
int x, y;
x = a;
y = b;
}
double module() {
}
int dx = x - p.x;
int dy = y - p.y;
}
public String toString() {
return "(" + x + ", " + y + ")";
}
...
}
L.
Lencapsulation
La classe Point
Fichier Point.java
class Point {
int x, y;
void sePlacer(int a, int b) { sePlacer(a,b) distance(p)
x = a; x
y = b; y
} module() toString()
double module() {
}
int dx = x - p.x;
int dy = y - p.y;
}
public String toString() {
return "(" + x + ", " + y + ")";
}
...
}
L.
Lencapsulation
La classe Point
Fichier Point.java
class Point {
int x, y;
void sePlacer(int a, int b) { sePlacer(a,b) distance(p)
x = a; x
y = b; y
} module() toString()
double module() {
}
int dx = x - p.x;
int dy = y - p.y;
}
public String toString() { Noter que le qualifieur static
return "(" + x + ", " + y + ")"; a disparu.
}
...
}
L.
Lencapsulation
Test de la classe Point
Fichier TestPoint.java
class TestPoint {
public static void main(String[] args) {
Point a, b;
L.
Lencapsulation
class TestPoint {
Point a, b;
a = new Point();
b = new Point();
L.
Lencapsulation
class TestPoint {
Point a, b;
a = new Point();
b = new Point();
a.sePlacer(10, 0);
b.sePlacer(13, 4);
L.
Lencapsulation
class TestPoint {
Point a, b;
a = new Point();
b = new Point();
a.sePlacer(10, 0);
b.sePlacer(13, 4);
System.out.println(a.module());
System.out.println(a.distance(b));
System.out.println(a.toString());
System.out.println(b);
}
}
L.
Lencapsulation
class TestPoint {
public static void main(String[] args) { a
Point a, b;
10
a = new Point(); 0
b = new Point();
a.sePlacer(10, 0);
b.sePlacer(13, 4); b
System.out.println(a.module()); 13
System.out.println(a.distance(b)); 4
}
}
L.
Lencapsulation
class TestPoint {
public static void main(String[] args) { a
Point a, b;
10
a = new Point(); 0
b = new Point();
a.sePlacer(10, 0);
b.sePlacer(13, 4); b
System.out.println(a.module()); 13
System.out.println(a.distance(b)); 4
}
}
Ex
ecution :
10.0
5.0
(10, 0)
(13, 4)
L.
Lencapsulation
Faut-il dire objet ou bien classe ?
class Point {
int x, y;
void sePlacer(int a, int b) {...}
double longueur() {...}
... la classe
}
... des objets
Point a = new Point();
Point b = new Point();
...
L.
Lencapsulation
class Point {
int x, y;
... la classe
}
... des objets
...
classe : aspect descriptif, statique, unique

objet : aspect existentiel, dynamique, multiple
L.
Lencapsulation
class Point {
int x, y;
... la classe
}
... des objets
...

le bien parler :
[la valeur de] a est un [objet] Point
L.
Lencapsulation
class Point {
int x, y;
... la classe
}
... des objets
...

le bien parler :
[la valeur de] a est une instance de la classe Point
L.
Lencapsulation
class Point {
int x, y;
... la classe
}
... des objets
...

le bien parler :
[la valeur de] a est une instance de la classe Point
new est loperation dinstanciation ( = creation dun objet)
L.
Lencapsulation
Accès à un membre dinstance, notation
Pour acc
eder `
a un membre dinstance on doit mentionner linstance vis
ee :
unObjet.unMembre
L.
c Tichit, 2015-2016 POO et Java 10 / 1
Lencapsulation
Pour acc
eder `
ee :
unObjet.unMembre
Appel de m
ethode : la version Java du concept envoi de message :
a.module() envoi du message module à lobjet a
L.
Lencapsulation
Pour acc
eder `
ee :
unObjet.unMembre
Appel de m
`
a lint
erieur dune m
ethode, lobjet destinataire du message est implicite :
class Point {
int x, y;
...
double module() {
}
}
qui sont ces x et y qui apparaissent dans la m
ethode module ?
L.
Lencapsulation
Pour acc
eder `
ee :
unObjet.unMembre
Appel de m
`
a lint
erieur dune m
class Point {
int x, y;
...
double module() {
}
}
qui sont ces x et y qui apparaissent dans la m ethode module ?
r
eponse : les variables x et y de lobjet `
a travers lequel on aura appel
e la m
ethode
L.
Lencapsulation
Pour acc
eder `
ee :
unObjet.unMembre
Appel de m
`
a lint
erieur dune m
class Point {
int x, y;
...
double module() {
}
}
qui sont ces x et y qui apparaissent dans la m ethode module ?
r
eponse : les variables x et y de lobjet `
a travers lequel on aura appel
e la m
ethode
Si on a
...
double r = a.module();
alors le corps de la fonction
equivaut `
a
return Math.sqrt(a.x * a.x + a.y * a.y);
L.
Lencapsulation
Membres dinstance et membres de classe
membres : les variables (ou champs) et les methodes
L.
Lencapsulation

les membres dinstance sont attaches aux instances :
variable dinstance : chaque objet possède son propre exemplaire
(creer un objet cest allouer ces variables ; new fait cela)
L.
Lencapsulation

methode dinstance : on doit lappeler ` a travers un objet
(le destinataire de lenvoi de message) : a.module()
L.
Lencapsulation

les membres de classe ne sont pas attaches aux instances :
ils nappartiennent qu`
a la classe :
ils sont signales par le qualifieur static
L.
Lencapsulation

a la classe :
variable de classe : il y en a un exemplaire unique, accessible par
tous les objets de la classe
L.
Lencapsulation

a la classe :
variable de classe : il y en a un exemplaire unique, accessible par
tous les objets de la classe
methode de classe : on peut lappeler seule, comme une fonction C
(mais il faudra preciser la classe)
L.
Lencapsulation
Un exercice de style
Fichier Point.java
class Point {
int x, y;
...
double distance(Point p) { // m
ethode dinstance
int dx = x - p.x;
int dy = y - p.y;
}
static double distance(Point u, Point v) { // m
ethode de classe
int dx = u.x - v.x;
int dy = u.y - v.y;
}
}
L.
Lencapsulation
Un exercice de style
Fichier Point.java
class Point {
int x, y;
...
double distance(Point p) { // m
ethode dinstance
int dx = x - p.x;
int dy = y - p.y;
}
static double distance(Point u, Point v) { // m
ethode de classe
int dx = u.x - v.x;
int dy = u.y - v.y;
}
}
Emploi (dans une autre classe) :

Point a, b;
...
r = a.distance(b); // appel de la m
ethode dinstance
r = Point.distance(a, b); // appel de la m
ethode de classe
L.
Lencapsulation
Accès à ses propres membres, accès à soi-meme
dans une m ethode dinstance, lobjet `

a travers lequel on appelle la m
ethode est d
esign
e
implicitement :
int dx = x - p.x;
int dy = y - p.y;
}
L.
Lencapsulation

ethode est d
esign
e
implicitement :
int dx = x - p.x;
int dy = y - p.y;
}
il existe aussi une d

esignation explicite : this
int dx = this.x - p.x;
int dy = this.y - p.y;
}
L.
Lencapsulation

ethode est d
esign
e
implicitement :
int dx = x - p.x;
int dy = y - p.y;
}
il existe aussi une d

esignation explicite : this
int dx = this.x - p.x;
int dy = this.y - p.y;
}
dans un appel tel que a.distance(b) on aura this a (et p b)
L.
Lencapsulation

Exercice de style 2. Ecrire la m
ethode de classe en utilisant la m
ethode dinstance :
int dx = x - p.x;
int dy = y - p.y;
}
static double distance(Point p, Point q) {
return p.distance(q);
}
L.
Lencapsulation

ethode de classe en utilisant la m
ethode dinstance :
int dx = x - p.x;
int dy = y - p.y;
}
return p.distance(q);
}

ethode dinstance en utilisant la m
ethode de classe :

int dx = p.x - q.x;
int dy = p.y - q.y;
}
return distance(this, p);
}
L.
Lencapsulation
Constructeurs
Constructeurs : m
ethodes ayant
m
eme nom que la classe
pas de type de retour ni dinstruction return expression
L.
Lencapsulation
Constructeurs
Constructeurs : m
ethodes ayant
m
leur r
ole : initialiser lespace qui vient d
etre allou
e pour lobjet
class Point {
int x, y;
Point(int a, int b) {
x = a;
y = b;
}
...
}
L.
Lencapsulation
Constructeurs
Constructeurs : m
ethodes ayant
m
leur r
etre allou
e pour lobjet
class Point {
int x, y;
x = a;
y = b;
}
...
}
emploi (p
etant une variable de type Point) :
p = new Point(10, 20);
L.
Lencapsulation
Constructeurs
Constructeurs : m
ethodes ayant
m
leur r
etre allou
e pour lobjet
class Point {
int x, y;
x = a;
y = b;
}
...
}
emploi (p
etant une variable de type Point) :
semploie souvent associ
eà une d
eclaration :
Point p = new Point(10, 20);
L.
Lencapsulation
Surcharge des constructeurs
Fichier Point.java
class Point {
int x, y;
x = a;
y = b;
}
Point(int a) {
validation de a
x = a;
y = 0;
}
Point() {
x = 0;
y = 0;
}
...
}
L.
Lencapsulation
Fichier Point.java
class Point {
Emplois respectifs :
int x, y;
Point p = new Point(u, v);
...
x = a;
Point q = new Point(w);
y = b;
...
}
Point r = new Point();
Point(int a) {
validation de a
x = a;
y = 0;
}
Point() {
x = 0;
y = 0;
}
...
}
L.
Lencapsulation
Fichier Point.java
class Point {
Emplois respectifs :
int x, y;
Point p = new Point(u, v);
...
x = a;
Point q = new Point(w);
y = b;
...
}
Point r = new Point();
Point(int a) {
validation de a
x = a;
y = 0;
A retenir : la cr
eation dun objet
}
se fait toujours
Point() {
x = 0; par lop
erateur new
y = 0; associ
eà lappel dun constructeur
}
...
}
L.
Lencapsulation
Ramener un constructeur à un autre
Fichier Point.java
class Point { Emplois respectifs :
int x, y;
Point(int a, int b) { Point p = new Point(u, v);
validation de a et b ...
x = a; Point q = new Point(w);
y = b; ...
} Point r = new Point();
Point(int a) {
this(a, 0);
}
Point() { Attention :
this(0, 0); this(arguments); doit etre la
} premi`
ere instruction dun constructeur
...
}
L.
Lencapsulation
Le constructeur offert par la maison
la construction dun objet implique toujours lappel dun constructeur

pourtant notre première classe fonctionnait. Comment ?
L.
Lencapsulation

si le programmeur na ecrit aucun constructeur alors le compilateur
fournit un constructeur
sans arguments
entièrement fait dinitialisations par defaut
L.
Lencapsulation

sans arguments
par exemple :
la classe equivaut `
a la classe
public class Point { public class Point {
int x, y; int x, y;
} Point() {
x = y = 0;
}
}
L.
Lencapsulation

sans arguments
par exemple :
la classe equivaut `
a la classe
public class Point { public class Point {
int x, y; int x, y;
} Point() {
x = y = 0;
}
}
ce cadeau cesse dès quun constructeur quelconque est explicite
L.
Lencapsulation
Initialisation des variables dinstance : recapitulation
Fichier Recipient.java
class Recipient {
float hauteur;
float largeur = 40;
float niveau;
...
Recipient(float niveau) {
this.niveau = niveau;
}
...
}
Emploi : rec
0 hauteur
Recipient rec 40 largeur
= new Recipient(25); 25 niveau
L.
Lencapsulation
Objets contenant dautres objets
Les objets peuvent avoir (ont souvent) pour membres

dautres objets
L.
Lencapsulation
(a,b)
dautres objets
Exemple : un objet Rectangle est d
efini par deux
objets Point
(c,d)
L.
Lencapsulation
(a,b)
dautres objets
efini par deux
objets Point
(c,d)
Bonne nouvelle : il ny a pas de probl`
eme particulier pour linitialisation :
Fichier Rectangle.java
class Rectangle {
Point coinNO, coinSE;
L.
Lencapsulation
(a,b)
dautres objets
efini par deux
objets Point
(c,d)
Bonne nouvelle : il ny a pas de probl`
eme particulier pour linitialisation :
class Rectangle {
Rectangle(int a, int b, int c, int d) {

coinNO = new Point(a, b);
coinSE = new Point(c, d);
}
...
}
L.
Lencapsulation
(à propos...)
Mise en garde sur une erreur grave que le compilateur ne peut pas d
eceler
class Rectangle {

Point coinNO = new Point(a, b);
Point coinSE = new Point(c, d);
}
...
L.
Lencapsulation
(à propos...)
eceler
class Rectangle {

}
...
Rectangle r = new Rectangle(1, 2, 3, 4);
System.out.println(r.coinNO + ":" + r.coinSE);
}
}
L.
Lencapsulation
(à propos...)
eceler
class Rectangle {

}
...
}
}
On obtient invariablement (0,0):(0,0)
L.
Lencapsulation
(à propos...)
eceler
class Rectangle {

}
...
}
}
On obtient invariablement (0,0):(0,0)
L.
Lencapsulation
Initialisation des variables de classe
cr
e
ees lors de la cr
eation des objets (new), les variables dinstance peuvent
etre initialis
ees
dans les constructeurs
L.
Lencapsulation
cr
e
ees lors de la cr
etre initialis
ees
les variables de classe sont cr
e
ees au lancement du programme ; comment les initialiser ?
L.
Lencapsulation
cr
e
ees lors de la cr
etre initialis
ees
e
autant que possible, utiliser des affectations
public class Recipient {

static int n = 64;
static String[] jours = { "lundi", "mardi", ... "dimanche" };
...
L.
Lencapsulation
cr
e
ees lors de la cr
etre initialis
ees
e
autant que possible, utiliser des affectations

static int n = 64;
...
mais comment faire ceci ?
static long[] puis2 =
{ 1, 2, 4, 8, 16, 32, 64, 128, ... 18446744073709551616};
... (il y a n valeurs, n d
efini plus haut)
L.
Lencapsulation
bloc statique : morceau de code `

a ex
ecuter lors du chargement de la classe

static int n = 64;
...
static long[] puis2 = new long[n];

static {
puis2[0] = 1;
for (int i = 1; i < n; i++)
puis2[i] = 2 * puis2[i - 1];
}
...
}
L.
Lencapsulation
Droits daccès aux membres des classes
Question : quels membres dun objet a-t-on le droit de mentionner ?
L.
Lencapsulation

il sagit dun droit relatif : la question se pose lors de lecriture dune methode, il
faut savoir dans quelle classe cela se fait
L.
Lencapsulation

un membre (variable ou methode, dinstance ou de classe) peut etre qualifie
ils est alors accessible
private depuis les methodes de la meme classe...
L.
Lencapsulation

(rien) ...et les methodes des classes du meme paquet...
L.
Lencapsulation

protected ...et les methodes des sous-classes (cf. cours 3)...
L.
Lencapsulation

public ...et les methodes de toutes les classes
L.
Lencapsulation

cela na rien `
a voir
avec la notation : le membre x de lobjet p secrit p.x
quon ait ou non le droit dy acceder
L.
Lencapsulation

cela na rien `
a voir
avec la notation : le membre x de lobjet p secrit p.x
quon ait ou non le droit dy acceder
avec la directive import
(qui ne concerne que la manière de nommer les classes)
L.
Lencapsulation
Droits daccès, exemple
Fichier Point.java
class Point {
private int x, y;
L.
Lencapsulation
Fichier Point.java
class Point {
private int x, y;
public void placer(int x, int y) {

validation de x et y
this.x = x;
this.y = y;
}
L.
Lencapsulation
Fichier Point.java
class Point {
private int x, y;

this.x = x;
this.y = y;
}
public Point(int x, int y) {
placer(x, y);
}
L.
Lencapsulation
Fichier Point.java
class Point {
private int x, y;

this.x = x;
this.y = y;
}
placer(x, y);
}
public int getX() {
return x;
}
public int getY() {
return y;
}
...
}
L.
Lencapsulation
Fichier Point.java
class Point {
private int x, y;
public void placer(int x, int y) { B

en
efice retir
e
un point ne peut etre
this.x = x;
construit que par
this.y = y;
} new Point(a,b)
placer(x, y);
}
public int getX() {
return x;
}
public int getY() {
return y;
}
...
}
L.
Lencapsulation
Fichier Point.java
class Point {
private int x, y;

en
efice retir
e
this.x = x;
construit que par
this.y = y;
} new Point(a,b)
public Point(int x, int y) { il ne peut
etre modifi
e que
placer(x, y);
}
par p.placer(a,b)
public int getX() {
return x;
}
public int getY() {
return y;
}
...
}
L.
Lencapsulation
Fichier Point.java
class Point {
private int x, y;

en
efice retir
e
this.x = x;
construit que par
this.y = y;
} new Point(a,b)
public Point(int x, int y) { il ne peut
etre modifi
e que
placer(x, y);
}
par p.placer(a,b)
public int getX() { donc on peut garantir que
return x; tout point est
}
public int getY() { constamment valide
return y;
}
...
}
L.
Lencapsulation
A propos daccesseurs
En quoi la configuration est-elle meilleure que
Fichier Point.java Fichier Point.java

class Point { class Point {
private int x, y; public int x, y;
public int getX() {

return x; ...
}
public int getY() {
return y;
} }
...
}
L.
Lencapsulation
A propos daccesseurs
En quoi la configuration est-elle meilleure que
Fichier Point.java Fichier Point.java

class Point { class Point {
private int x, y; public int x, y;
public int getX() {

return x; ...
}
public int getY() {
return y;
} }
...
}
la consultation de x et y depuis lext

erieur de la classe Point est rendue
possible dans les deux cas
dans le premier cas la modification de x ou y est impossible
L.
Lencapsulation
La vue publique dune classe
Ce que les utilisateurs ont besoin de savoir (ailleurs on dit interface )
Linterface (au sens de face publique) de la classe Point :

class Point {
/* creation dun point de coordonn
ees x et y */
public Point(int x, int y);
/* modification des coordonn
ees dun point */
public void placer(int x, int y);
/* abscisse du point */
public int getX();
/* ordonn
ee du point */
public int getY();
...
}
L.
Lencapsulation

class Point {
ees x et y */
ees dun point */
public int getX();
/* ordonn
ee du point */
public int getY();
...
}
Encapsuler : cacher les d

etails internes, pour
garantir la correction des objets
L.
Lencapsulation

class Point {
ees x et y */
ees dun point */
public int getX();
/* ordonn
ee du point */
public int getY();
...
}
Encapsuler : cacher les d

etails internes, pour
garantir la correction des objets
garantir quaucune application ne sappuie sur ces details
qui peuvent donc etre changes sans provoquer derreur
L.
Lencapsulation
Encapsulation
Un gros b
en
efice : ind
ependance de limpl
ementation
Fichier Point.java
class Point {
private int r, t;
public void placer(int x, int y) { P

r = Math.sqrt(x * x + y * y);
t = Math.atan2(y, x); r
} y
public Point(int x, int y) { t
placer(x, y);
} x
public int getX() {
return r * Math.cos(t);
}
public int getY() {
return r * Math.sin(t);
}
...
}
L.
Lencapsulation
Encapsulation
Un gros b
en
efice : ind
ependance de limpl
ementation
Fichier Point.java
class Point {
private int r, t;
public void placer(int x, int y) { P

r = Math.sqrt(x * x + y * y);
t = Math.atan2(y, x); r
} y
public Point(int x, int y) { t
placer(x, y);
} x
public int getX() {
return r * Math.cos(t);
} Aucune application utilisant
public int getY() { la pr
ec
edente version de
return r * Math.sin(t); Point nest devenue obsolète
}
...
}
L.
Lencapsulation
Classes publiques et par defaut
les classes avec visibilite par defaut (i.e. non qualifiees public) sont accessibles
uniquement depuis les classes de leur propre paquetage
package mesAffaires.outils;
class Machin {
...
}
L.
Lencapsulation
class Machin {
...
}
les classes qualifiees public sont accessibles depuis les classes de tous les
paquetages
public class Truc {
...
}
L.
Lencapsulation
class Machin {
...
}
les classes qualifiees public sont accessibles depuis les classes de tous les
paquetages
public class Truc {
...
}
les classes public imposent le chemin du fichier qui les contient :

la classe Truc doit se trouver dans un fichier nomme Truc.java
place dans le dossier ./mesAffaires/outils
L.
Lencapsulation
Variables finales
Une variable (dinstance ou de classe) qualifiee final ne doit pas changer de valeur
variable dinstance : recoit une valeur `
a la construction et nen change plus
variable de classe : se comporte comme les constantes des autres langages
L.
Lencapsulation
Variables finales
Fichier Point.java
public class Point {
private int x, y;
L.
Lencapsulation
Variables finales
Fichier Point.java
private int x, y;
private static int nombreDePoints = 0;
L.
Lencapsulation
Variables finales
Fichier Point.java
private int x, y;
private final int rang;
L.
Lencapsulation
Variables finales
Fichier Point.java
private int x, y;
private static final int MAX POINTS = 1000;
L.
Lencapsulation
Variables finales
Fichier Point.java
private int x, y;
private static final int MAX POINTS = 1000;

if (nombreDePoints > MAX POINTS)
signaler une erreur trop de points
this.x = x;
this.y = y;
rang = nombreDePoints;
nombreDePoints++;
}
...
}
L.
Lencapsulation
Accès par reference aux objets
Les objets sont toujours designes par reference

la declaration dune variable de type objet ne donne quun pointeur null :
Point p;
p
null
L.
Lencapsulation
Les objets sont toujours designes par reference

la declaration dune variable de type objet ne donne quun pointeur null :
Point p;
p
null
lobjet nexiste qu`

a partir de loperation new qui le cree :
p
2 3
x y
L.
Lencapsulation
Consequence sur la duplication des objets

...
Point q = p;
par la suite, p et q se revèlent etrangement lies.
L.
Lencapsulation

...
Point q = p;
par la suite, p et q se revèlent etrangement lies. La raison :
p q
2 3
L.
Lencapsulation

...
Point q = p;
par la suite, p et q se revèlent etrangement lies. La raison :
p q
2 3
pour dupliquer effectivement un objet :

q = (Point) p.clone();
p q
2 3 2 3
L.
Lencapsulation
Consequence sur la comparaison des objets

Point q = new Point(2, 3);
...
if ( p == q )
System.out.println("egaux");
...
le test se revèle faux.
L.
Lencapsulation

...
if ( p == q )
...
le test se revèle faux. La raison :
p q
2 3 2 3
L.
Lencapsulation

...
if ( p == q )
...
le test se revèle faux. La raison :
p q
2 3 2 3
la bonne comparaison
if ( p.equals(q) )
...
L.
Lencapsulation
A propos d oriente objets

Programmation traditionnelle (ou orientee actions ) :

debut de la reflexion, les actions : quest-ce quon va faire
plus tard apparaissent les donnees : sur quoi ces actions portent ?
les objets sont ` a linterieur des actions
(ils en sont les paramètres, les resultats, etc.)
L.
Lencapsulation


La programmation orientee objets inverse les termes :
le debut de la reflexion concerne les objets
les actions apparaissent comme attributs (le comportement) des objets
les actions sont ` a linterieur des objets
L.
Lencapsulation


La programmation orientee objets inverse les termes :
le debut de la reflexion concerne les objets
les actions apparaissent comme attributs (le comportement) des objets
les actions sont ` a linterieur des objets
très adaptee aux problèmes avec de nombreuses structures de donnees (exemple :
les interfaces graphiques)
tous les problème ne tirent pas forcement profit de la POO
(exemple : deguiser de purs algorithmes en objets est un peu futile)
L.

JavaBBSG2 02

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

JavaBBSG2 02

Transféré par

Droits d'auteur :

Formats disponibles

La programmation orientee objets

La programmation orientee objets

Concepts apparus `a partir des annees 60

La programmation orientee objets

Concepts apparus `a partir des annees 60

La programmation orientee objets

Concepts apparus `a partir des annees 60

La programmation orientee objets

Concepts apparus `a partir des annees 60

Encapsulation : objets et messages

Un programme est un ensemble dobjets opaques, autonomes, interagissant entre

Encapsulation : objets et messages

Un programme est un ensemble dobjets opaques, autonomes, interagissant entre

Encapsulation : objets et messages

Un programme est un ensemble dobjets opaques, autonomes, interagissant entre

Encapsulation : objets et messages

Un programme est un ensemble dobjets opaques, autonomes, interagissant entre

Encapsulation : objets et messages

Un programme est un ensemble dobjets opaques, autonomes, interagissant entre

Encapsulation : objets et messages

Un programme est un ensemble dobjets opaques, autonomes, interagissant entre

Encapsulation : objets et messages

Un programme est un ensemble dobjets opaques, autonomes, interagissant entre

Attributs : variables et methodes

Attributs : variables et methodes

Attributs : variables et methodes

Attributs : variables et methodes

Objets et messages en Java

Comment cela se presente en Java ?

Objets et messages en Java

Comment cela se presente en Java ?

Objets et messages en Java

Comment cela se presente en Java ?

Objets et messages en Java

Comment cela se presente en Java ?

destinataire message arguments

Objets et messages en Java

Comment cela se presente en Java ?

destinataire message arguments

au lieu de : distance(p, q) ou toString(p)

Objets et messages en Java

Comment cela se presente en Java ?

destinataire message arguments

au lieu de : distance(p, q) ou toString(p)

Test de la classe Point

Test de la classe Point

Test de la classe Point

Test de la classe Point

Test de la classe Point

Test de la classe Point

Faut-il dire objet ou bien classe ?

Faut-il dire objet ou bien classe ?

classe : aspect descriptif, statique, unique

Faut-il dire objet ou bien classe ?

classe : aspect descriptif, statique, unique

Faut-il dire objet ou bien classe ?

classe : aspect descriptif, statique, unique

Faut-il dire objet ou bien classe ?

classe : aspect descriptif, statique, unique

Acc`es `a un membre dinstance, notation

Acc`es `a un membre dinstance, notation

Acc`es `a un membre dinstance, notation

Acc`es `a un membre dinstance, notation

Accès à ses propres membres, accès à soi-meme

Accès à ses propres membres, accès à soi-meme

Accès à ses propres membres, accès à soi-meme

Accès à ses propres membres, accès à soi-meme

Accès à ses propres membres, accès à soi-meme

la construction dun objet implique toujours lappel dun constructeur

la construction dun objet implique toujours lappel dun constructeur

la construction dun objet implique toujours lappel dun constructeur

la construction dun objet implique toujours lappel dun constructeur

bloc statique : morceau de code `