JavaBBSG2 02 PDF

La programmation orientée objets
et le langage Java
Master BBSG 2
Laurent Tichit
Département Informatique et Interactions, Faculté des Sciences de Luminy
Cours 2: L’encapsulation
L.
c Tichit, 2015-2016 POO et Java 1/1
L’encapsulation
Concepts apparus à partir des années 60

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

convergence de deux courants de recherche
courant génie logiciel :
lutter contre la complexité des gros programmes
problématique : correction, robustesse, réutilisabilité, etc.
L.
L’encapsulation

courant représentation des connaissances :
problématique : représenter
– les concepts : cette table est une Table ,
– l’abstraction : toute table est une sorte de meuble
L.
L’encapsulation

courant représentation des connaissances :
problématique : représenter
– les concepts : cette table est une Table ,
– l’abstraction : toute table est une sorte de meuble
principales notions
encapsulation
héritage
polymorphisme, redéfinition des méthodes, exceptions, généricité, etc.
L.
L’encapsulation
Encapsulation : objets et messages
Un programme est un ensemble d’objets opaques, autonomes, interagissant entre

eux par envoi de messages.
L.
L’encapsulation

Chaque objet a un état privé, caché à l’intérieur, et un comportement public,
l’ensemble des messages auxquels l’objet réagit.
L.
L’encapsulation

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

Tout message a un destinataire. Le message dit quoi faire, mais non comment :
c’est au destinataire de connaı̂tre les détails pratiques de l’action que le message
provoque chez lui.
L.
L’encapsulation

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

provoque chez lui.
Conséquence : au lieu d’une (unique) définition de distance, chaque classe
d’objets peut avoir la sienne.
L.
L’encapsulation

provoque chez lui.
Conséquence : au lieu d’une (unique) définition de distance, chaque classe
d’objets peut avoir la sienne.
Les objets sont réutilisables
composition : un objet est composé d’autres objets
héritage : un objet est défini comme spécialisation d’un autre
L.
L’encapsulation
Attributs : variables et méthodes

Un objet est fait de
une certaine quantité de mémoire, organisée en champs, variables d’instance,
données membres, etc.
un certain nombre de fonctions, appelée méthodes, fonctions membres, etc.,
qu’on ne peut appeler qu’en s’adressant à cet objet.
L.
L’encapsulation

Variables et méthodes sont les attributs des objets. Ils peuvent être
publics, c’est-à-dire utilisables dans n’importe quel endroit du programme,
privés, c’est-à-dire accessible uniquement dans l’objet auquel ils appartiennent.
L.
L’encapsulation

Encapsulation : dans l’idéal
seules sont publiques certaines méthodes, robustes et documentées, qui
constituent l’interface de l’objet ;
les variables et les autres méthodes sont privées ; elles constituent
l’implémentation de l’objet et sont inutilisables depuis l’extérieur.
L.
L’encapsulation

Encapsulation : dans l’idéal
seules sont publiques certaines méthodes, robustes et documentées, qui
constituent l’interface de l’objet ;
les variables et les autres méthodes sont privées ; elles constituent
l’implémentation de l’objet et sont inutilisables depuis l’extérieur.
Bénéfices majeurs :
correction : on peut garantir que l’état d’un objet est toujours cohérent,
indépendance : on peut changer l’implémentation (détails internes) d’un objet
sans invalider les programmes qui l’emploient.
L.
L’encapsulation
Objets et messages en Java
Comment cela se présente en Java ?

objets : des structures contenant des variables et du code
L.
L’encapsulation

état : des variables, appelées champs ou variables d’instance
L.
L’encapsulation

comportement : des fonctions, appelées méthodes (d’instance)
L.
L’encapsulation

envoi de message : appel de méthode, sous la forme
p.distance(q) ou p.toString()
destinataire message arguments
L.
L’encapsulation

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

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

Exemple : une classe Point pour représenter les points du plan
L.
L’encapsulation
La classe Point
Fichier Point.java
class Point {
int x, y;
L.
L’encapsulation
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.
L’encapsulation
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.
L’encapsulation
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.
L’encapsulation
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.
L’encapsulation
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.
L’encapsulation
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.
L’encapsulation
Test de la classe Point
Fichier TestPoint.java
class TestPoint {
public static void main(String[] args) {
Point a, b;
L.
L’encapsulation
class TestPoint {
Point a, b;
a = new Point();
b = new Point();
L.
L’encapsulation
class TestPoint {
Point a, b;
a = new Point();
b = new Point();
a.sePlacer(10, 0);
b.sePlacer(13, 4);
L.
L’encapsulation
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.
L’encapsulation
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.
L’encapsulation
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
}
}
Exécution :
10.0
5.0
(10, 0)
(13, 4)
L.
L’encapsulation
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.
L’encapsulation
class Point {
int x, y;
... la classe
}
... des objets
...
classe : aspect descriptif, statique, unique

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

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

le bien parler :
[la valeur de] a est une instance de la classe Point
L.
L’encapsulation
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 l’opération d’instanciation ( = création d’un objet)
L.
L’encapsulation
Accès à un membre d’instance, notation
Pour accéder à un membre d’instance on doit mentionner l’instance visée :

unObjet.unMembre
L.
c Tichit, 2015-2016 POO et Java 10 / 1
L’encapsulation

unObjet.unMembre
Appel de méthode : la version Java du concept envoi de message :

a.module() envoi du message module à l’objet a
L.
L’encapsulation

unObjet.unMembre

à l’intérieur d’une méthode, l’objet destinataire du message est implicite :
class Point {
int x, y;
...
double module() {
}
}
qui sont ces x et y qui apparaissent dans la méthode module ?
L.
L’encapsulation

unObjet.unMembre

class Point {
int x, y;
...
double module() {
}
}
réponse : les variables x et y de l’objet à travers lequel on aura appelé la méthode
L.
L’encapsulation

unObjet.unMembre

class Point {
int x, y;
...
double module() {
}
}
réponse : les variables x et y de l’objet à travers lequel on aura appelé la méthode
Si on a
...
double r = a.module();
alors le corps de la fonction équivaut à
return Math.sqrt(a.x * a.x + a.y * a.y);
L.
L’encapsulation
Membres d’instance et membres de classe
membres : les variables (ou champs) et les méthodes
L.
L’encapsulation

les membres d’instance sont attachés aux instances :
variable d’instance : chaque objet possède son propre exemplaire
(créer un objet c’est allouer ces variables ; new fait cela)
L.
L’encapsulation

méthode d’instance : on doit l’appeler à travers un objet
(le destinataire de l’envoi de message) : a.module()
L.
L’encapsulation

les membres de classe ne sont pas attachés aux instances :
ils n’appartiennent qu’à la classe :
ils sont signalés par le qualifieur static
L.
L’encapsulation

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

variable de classe : il y en a un exemplaire unique, accessible par
tous les objets de la classe
méthode de classe : on peut l’appeler seule, comme une fonction C
(mais il faudra préciser la classe)
L.
L’encapsulation
Un exercice de style
Fichier Point.java
class Point {
int x, y;
...
double distance(Point p) { // méthode d’instance
int dx = x - p.x;
int dy = y - p.y;
}
static double distance(Point u, Point v) { // méthode de classe
int dx = u.x - v.x;
int dy = u.y - v.y;
}
}
L.
L’encapsulation
Un exercice de style
Fichier Point.java
class Point {
int x, y;
...
double distance(Point p) { // méthode d’instance
int dx = x - p.x;
int dy = y - p.y;
}
static double distance(Point u, Point v) { // méthode 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 méthode d’instance
r = Point.distance(a, b); // appel de la méthode de classe
L.
L’encapsulation
Accès à ses propres membres, accès à soi-même
dans une méthode d’instance, l’objet à travers lequel on appelle la méthode est désigné
implicitement :
int dx = x - p.x;
int dy = y - p.y;
}
L.
L’encapsulation
implicitement :
int dx = x - p.x;
int dy = y - p.y;
}
il existe aussi une désignation explicite : this

int dx = this.x - p.x;
int dy = this.y - p.y;
}
L.
L’encapsulation
implicitement :
int dx = x - p.x;
int dy = y - p.y;
}
il existe aussi une désignation 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.
L’encapsulation
Exercice de style 2. Écrire la méthode de classe en utilisant la méthode d’instance :
int dx = x - p.x;
int dy = y - p.y;
}
static double distance(Point p, Point q) {
return p.distance(q);
}
L.
L’encapsulation
Exercice de style 2. Écrire la méthode de classe en utilisant la méthode d’instance :
int dx = x - p.x;
int dy = y - p.y;
}
return p.distance(q);
}
Exercice de style 3. Écrire la méthode d’instance en utilisant la méthode de classe :

int dx = p.x - q.x;
int dy = p.y - q.y;
}
return distance(this, p);
}
L.
L’encapsulation
Constructeurs
Constructeurs : méthodes ayant

même nom que la classe
pas de type de retour ni d’instruction return expression
L.
L’encapsulation
Constructeurs

leur rôle : initialiser l’espace qui vient d’être alloué pour l’objet
class Point {
int x, y;
Point(int a, int b) {
x = a;
y = b;
}
...
}
L.
L’encapsulation
Constructeurs

class Point {
int x, y;
x = a;
y = b;
}
...
}
emploi (p étant une variable de type Point) :
p = new Point(10, 20);
L.
L’encapsulation
Constructeurs

class Point {
int x, y;
x = a;
y = b;
}
...
}
emploi (p étant une variable de type Point) :
s’emploie souvent associé à une déclaration :
Point p = new Point(10, 20);
L.
L’encapsulation
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.
L’encapsulation
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.
L’encapsulation
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 création d’un objet
}
se fait toujours
Point() {
x = 0; par l’opérateur new
y = 0; associé à l’appel d’un constructeur
}
...
}
L.
L’encapsulation
Ramener un constructeur à 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 être la
} première instruction d’un constructeur

...
}
L.
L’encapsulation
Le constructeur offert par la maison
la construction d’un objet implique toujours l’appel d’un constructeur

pourtant notre première classe fonctionnait. Comment ?
L.
L’encapsulation

si le programmeur n’a écrit aucun constructeur alors le compilateur
fournit un constructeur
sans arguments
entièrement fait d’initialisations par défaut
L.
L’encapsulation

sans arguments
par exemple :
la classe équivaut à la classe
public class Point { public class Point {
int x, y; int x, y;
} Point() {
x = y = 0;
}
}
L.
L’encapsulation

sans arguments
par exemple :
la classe équivaut à la classe
public class Point { public class Point {
int x, y; int x, y;
} Point() {
x = y = 0;
}
}
ce cadeau cesse dès qu’un constructeur quelconque est explicité
L.
L’encapsulation
Initialisation des variables d’instance : récapitulation
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.
L’encapsulation
Objets contenant d’autres objets
Les objets peuvent avoir (ont souvent) pour membres

d’autres objets
L.
L’encapsulation
(a,b)
d’autres objets
Exemple : un objet Rectangle est défini par deux
objets Point
(c,d)
L.
L’encapsulation
(a,b)
d’autres objets
objets Point
(c,d)
Bonne nouvelle : il n’y a pas de problème particulier pour l’initialisation :
Fichier Rectangle.java
class Rectangle {
Point coinNO, coinSE;
L.
L’encapsulation
(a,b)
d’autres objets
objets Point
(c,d)
Bonne nouvelle : il n’y a pas de problème particulier pour l’initialisation :
class Rectangle {
Rectangle(int a, int b, int c, int d) {

coinNO = new Point(a, b);
coinSE = new Point(c, d);
}
...
}
L.
L’encapsulation
(à propos...)
Mise en garde sur une erreur grave que le compilateur ne peut pas déceler
class Rectangle {

Point coinNO = new Point(a, b);
Point coinSE = new Point(c, d);
}
...
L.
L’encapsulation
(à propos...)
class Rectangle {

}
...
Rectangle r = new Rectangle(1, 2, 3, 4);
System.out.println(r.coinNO + ":" + r.coinSE);
}
}
L.
L’encapsulation
(à propos...)
class Rectangle {

}
...
}
}
On obtient invariablement (0,0):(0,0)
L.
L’encapsulation
(à propos...)
class Rectangle {

}
...
}
}
On obtient invariablement (0,0):(0,0)
L.
L’encapsulation
Initialisation des variables de classe
créées lors de la création des objets (new), les variables d’instance peuvent être initialisées
dans les constructeurs
L.
L’encapsulation
les variables de classe sont créées au lancement du programme ; comment les initialiser ?
L.
L’encapsulation
autant que possible, utiliser des affectations
public class Recipient {

static int n = 64;
static String[] jours = { "lundi", "mardi", ... "dimanche" };
...
L.
L’encapsulation
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 défini plus haut)
L.
L’encapsulation
bloc statique : morceau de code à exécuter 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.
L’encapsulation
Droits d’accès aux membres des classes
Question : quels membres d’un objet a-t-on le droit de mentionner ?
L.
L’encapsulation

il s’agit d’un droit relatif : la question se pose lors de l’écriture d’une méthode, il
faut savoir dans quelle classe cela se fait
L.
L’encapsulation

un membre (variable ou méthode, d’instance ou de classe) peut être qualifié
ils est alors accessible
private depuis les méthodes de la même classe...
L.
L’encapsulation

(rien) ...et les méthodes des classes du même paquet...
L.
L’encapsulation

protected ...et les méthodes des sous-classes (cf. cours 3)...
L.
L’encapsulation

public ...et les méthodes de toutes les classes
L.
L’encapsulation

cela n’a rien à voir
avec la notation : le membre x de l’objet p s’écrit p.x
qu’on ait ou non le droit d’y accéder
L.
L’encapsulation

cela n’a rien à voir
avec la notation : le membre x de l’objet p s’écrit p.x
qu’on ait ou non le droit d’y accéder
avec la directive import
(qui ne concerne que la manière de nommer les classes)
L.
L’encapsulation
Droits d’accès, exemple
Fichier Point.java
class Point {
private int x, y;
L.
L’encapsulation
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.
L’encapsulation
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.
L’encapsulation
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.
L’encapsulation
Fichier Point.java
class Point {
private int x, y;
public void placer(int x, int y) { Bénéfice retiré

un point ne peut être
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.
L’encapsulation
Fichier Point.java
class Point {
private int x, y;

this.x = x;
construit que par
this.y = y;
} new Point(a,b)
public Point(int x, int y) { il ne peut être modifié que
placer(x, y);
}
par p.placer(a,b)
public int getX() {
return x;
}
public int getY() {
return y;
}
...
}
L.
L’encapsulation
Fichier Point.java
class Point {
private int x, y;

this.x = x;
construit que par
this.y = y;
} new Point(a,b)
public Point(int x, int y) { il ne peut être modifié 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.
L’encapsulation
A propos d’accesseurs
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.
L’encapsulation
A propos d’accesseurs
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 l’extérieur de la classe Point est rendue

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

class Point {
/* creation d’un point de coordonnées x et y */
public Point(int x, int y);
/* modification des coordonnées d’un point */
public void placer(int x, int y);
/* abscisse du point */
public int getX();
/* ordonnée du point */
public int getY();
...
}
L.
L’encapsulation

class Point {
public int getX();
public int getY();
...
}
Encapsuler : cacher les détails internes, pour

garantir la correction des objets
L.
L’encapsulation

class Point {
public int getX();
public int getY();
...
}
Encapsuler : cacher les détails internes, pour

garantir la correction des objets
garantir qu’aucune application ne s’appuie sur ces détails
qui peuvent donc être changés sans provoquer d’erreur
L.
L’encapsulation
Encapsulation
Un gros bénéfice : indépendance de l’implémentation
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.
L’encapsulation
Encapsulation
Un gros bénéfice : indépendance de l’implémentation
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 précédente version de
return r * Math.sin(t); Point n’est devenue obsolète
}
...
}
L.
L’encapsulation
Classes publiques et par défaut
les classes avec visibilité par défaut (i.e. non qualifiées public) sont accessibles
uniquement depuis les classes de leur propre paquetage
package mesAffaires.outils;
class Machin {
...
}
L.
L’encapsulation
class Machin {
...
}
les classes qualifiées public sont accessibles depuis les classes de tous les
paquetages
public class Truc {
...
}
L.
L’encapsulation
class Machin {
...
}
les classes qualifiées 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.
L’encapsulation
Variables finales
Une variable (d’instance ou de classe) qualifiée final ne doit pas changer de valeur
variable d’instance : reçoit une valeur à la construction et n’en change plus
variable de classe : se comporte comme les constantes des autres langages
L.
L’encapsulation
Variables finales
Fichier Point.java
public class Point {
private int x, y;
L.
L’encapsulation
Variables finales
Fichier Point.java
private int x, y;
private static int nombreDePoints = 0;
L.
L’encapsulation
Variables finales
Fichier Point.java
private int x, y;
private final int rang;
L.
L’encapsulation
Variables finales
Fichier Point.java
private int x, y;
private static final int MAX POINTS = 1000;
L.
L’encapsulation
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.
L’encapsulation
Accès par référence aux objets
Les objets sont toujours désignés par référence

la déclaration d’une variable de type objet ne donne qu’un pointeur null :
Point p;
p
null
L.
L’encapsulation
Les objets sont toujours désignés par référence

la déclaration d’une variable de type objet ne donne qu’un pointeur null :
Point p;
p
null
l’objet n’existe qu’à partir de l’opération new qui le crée :

p
2 3
x y
L.
L’encapsulation
Conséquence sur la duplication des objets

...
Point q = p;
par la suite, p et q se révèlent étrangement liés.
L.
L’encapsulation

...
Point q = p;
par la suite, p et q se révèlent étrangement liés. La raison :
p q
2 3
L.
L’encapsulation

...
Point q = p;
par la suite, p et q se révèlent étrangement liés. La raison :
p q
2 3
pour dupliquer effectivement un objet :

q = (Point) p.clone();
p q
2 3 2 3
L.
L’encapsulation
Conséquence sur la comparaison des objets

Point q = new Point(2, 3);
...
if ( p == q )
System.out.println("egaux");
...
le test se révèle faux.
L.
L’encapsulation

...
if ( p == q )
...
le test se révèle faux. La raison :
p q
2 3 2 3
L.
L’encapsulation

...
if ( p == q )
...
le test se révèle faux. La raison :
p q
2 3 2 3
la bonne comparaison
if ( p.equals(q) )
...
L.
L’encapsulation
A propos d’ orienté objets

Programmation traditionnelle (ou orientée actions ) :

début de la réflexion, les actions : qu’est-ce qu’on va faire
plus tard apparaissent les données : sur quoi ces actions portent ?
les objets sont à l’intérieur des actions
(ils en sont les paramètres, les résultats, etc.)
L.
L’encapsulation


La programmation orientée objets inverse les termes :
le début de la réflexion concerne les objets
les actions apparaissent comme attributs (le comportement) des objets
les actions sont à l’intérieur des objets
L.
L’encapsulation


La programmation orientée objets inverse les termes :
le début de la réflexion concerne les objets
les actions apparaissent comme attributs (le comportement) des objets
les actions sont à l’intérieur des objets
très adaptée aux problèmes avec de nombreuses structures de données (exemple :
les interfaces graphiques)
tous les problème ne tirent pas forcément profit de la POO
(exemple : déguiser de purs algorithmes en objets est un peu futile)
L.

JavaBBSG2 02 PDF

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 PDF

Transféré par

Droits d'auteur :

Formats disponibles

La programmation orientée objets

La programmation orientée objets

Concepts apparus à partir des années 60

La programmation orientée objets

Concepts apparus à partir des années 60

La programmation orientée objets

Concepts apparus à partir des années 60

La programmation orientée objets

Concepts apparus à partir des années 60

Encapsulation : objets et messages

Un programme est un ensemble d’objets opaques, autonomes, interagissant entre

Encapsulation : objets et messages

Un programme est un ensemble d’objets opaques, autonomes, interagissant entre

Encapsulation : objets et messages

Un programme est un ensemble d’objets opaques, autonomes, interagissant entre

Encapsulation : objets et messages

Un programme est un ensemble d’objets opaques, autonomes, interagissant entre

Encapsulation : objets et messages

Un programme est un ensemble d’objets opaques, autonomes, interagissant entre

Encapsulation : objets et messages

Un programme est un ensemble d’objets opaques, autonomes, interagissant entre

Encapsulation : objets et messages

Un programme est un ensemble d’objets opaques, autonomes, interagissant entre

Attributs : variables et méthodes

Attributs : variables et méthodes

Attributs : variables et méthodes

Attributs : variables et méthodes

Objets et messages en Java

Comment cela se présente en Java ?

Objets et messages en Java

Comment cela se présente en Java ?

Objets et messages en Java

Comment cela se présente en Java ?

Objets et messages en Java

Comment cela se présente en Java ?

destinataire message arguments

Objets et messages en Java

Comment cela se présente en Java ?

destinataire message arguments

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

Objets et messages en Java

Comment cela se présente 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

Accès à un membre d’instance, notation

Pour accéder à un membre d’instance on doit mentionner l’instance visée :

Accès à un membre d’instance, notation

Pour accéder à un membre d’instance on doit mentionner l’instance visée :

Accès à ses propres membres, accès à soi-même

Accès à ses propres membres, accès à soi-même

Accès à ses propres membres, accès à soi-même

Accès à ses propres membres, accès à soi-même

Accès à ses propres membres, accès à soi-même

la construction d’un objet implique toujours l’appel d’un constructeur

la construction d’un objet implique toujours l’appel d’un constructeur

la construction d’un objet implique toujours l’appel d’un constructeur

la construction d’un objet implique toujours l’appel d’un constructeur