Livre T Java

Initiation la programmation oriente-objet
avec le langage Java

Ple Informatique 2012-2013
158 cours Fauriel
42023 Saint-tienne Cedex 02
Gauthier Picard
gauthier.picard@emse.fr
Institut Henri Fayol, ENSM.SE
Laurent Vercouter
laurent.vercouter@insa-rouen.fr
LITIS, INSA Rouen
Table des matires
1 Introduction au langage Java 1
1.1 Environnement Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.1 Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.2 Interprtation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Programmation oriente-objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.1 Classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.2 Objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 Syntaxe du langage 7
2.1 Types de donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.1 Types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.2 Tableaux et matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.3 Chanes de caractres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2 Oprateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 Structures de contrle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.1 Instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3.2 Instructions itratives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3.3 Instructions break et continue . . . . . . . . . . . . . . . . . . . . . . . . . 11
3 lments de programmation Java 13
3.1 Premiers pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.1.1 Classe HelloWorld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.1.2 Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.2 Variables et mthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2.1 Visibilit des champs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2.2 Variables et mthodes de classe . . . . . . . . . . . . . . . . . . . . . . . . . 16
4 Hritage 19
4.1 Principe de lhritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.1.1 Redfinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.1.2 Polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.2 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.3 Classes abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.4 Classes et mthodes gnriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
5 Gestion des exceptions 27
5.1 Dclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5.2 Interception et traitement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.3 Classes dexception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.4 Classification des erreurs en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
iii
Table des matires
6 Gestion des entres/sorties simples 33
6.1 Flux dentre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
6.1.1 Lecture des entres clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
6.1.2 Lecture partir dun fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
6.1.3 Lecture dobjets enregistrs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
6.2 Flux de sortie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
6.2.1 Ecriture sur la sortie standard cran . . . . . . . . . . . . . . . . . . . . . 37
6.2.2 Ecriture dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
6.2.3 Ecriture dobjets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
A Applications graphiques (package swing) 43
A.1 Le schma Modle-Vue-Contrleur . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
A.2 Composants graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
A.2.1 Composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
A.2.2 Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
A.2.3 Exemple dinterface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
A.3 Contrleurs dvnements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
A.3.1 Evnements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
A.3.2 Interface Listener . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
A.3.3 Exemple de contrleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
B Diagramme de classes UML 55
B.1 Reprsentation des classes et interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . 55
B.1.1 Les classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
B.1.2 Les membres de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
B.1.3 Les classes abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
B.1.4 Les interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
B.2 Les relations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
B.2.1 Lhritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
B.2.2 La ralisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
B.3 Les associations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
B.3.1 Direction des associations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
B.3.2 Agrgation et composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
B.4 Correspondance UML-Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
B.4.1 Classes et membres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
B.4.2 Classes abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
B.4.3 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
B.4.4 Hritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
B.4.5 Ralisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
B.4.6 Associations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
iv
Table des matires
La plupart des programmes donns en exemple dans ce cours sont tlchargeables lURL :
http://www.emse.fr/~picard/cours/1A/java
v
Table des matires
vi
Chapitre 1
Introduction au langage Java
Le langage Java est un langage gnraliste de programmation synthtisant les principaux lan-
gages existants lors de sa cration en 1995 par Sun Microsystems. Il permet une programmation
oriente-objet ( linstar de SmallTalk et, dans une moindre mesure, C++), modulaire (langage
ADA) et reprend une syntaxe trs proche de celle du langage C.
Outre son orientation objet, le langage Java a lavantage dtre modulaire (on peut crire des
portions de code gnriques, c--d utilisables par plusieurs applications), rigoureux (la plupart
des erreurs se produisent la compilation et non lexcution) et portable (un mme programme
compil peut sexcuter sur diffrents environnements). Encontre-partie, les applications Java ont
le dfaut dtre plus lentes lexcution que des applications programmes en C par exemple.
1.1 Environnement Java
Java est un langage interprt, ce qui signifie quun programme compil nest pas directement
excutable par le systme dexploitationmais il doit tre interprt par unautre programme, quon
appelle interprteur. La figure 1.1 illustre ce fonctionnement.
Figure 1.1 Interprtation du langage
Un programmeur Java crit son code source, sous la forme de classes, dans des fichiers dont
lextension est .java. Ce code source est alors compil par le compilateur javac en un langage
appel bytecode et enregistre le rsultat dans un fichier dont lextension est .class. Le bytecode
1
Chapitre 1. Introduction au langage Java
ainsi obtenu nest pas directement utilisable. Il doit tre interprt par la machine virtuelle de Java
qui transforme alors le code compil en code machine comprhensible par le systme dexploita-
tion. Cest la raison pour laquelle Java est un langage portable : le bytecode reste le mme quelque
soit lenvironnement dexcution.
En 2009, Sun Microsystems est rachet par Oracle Corporation qui fournit dornavant les
outils de dveloppement Java SE (Standard Edition) contenus dans le Java Development Kit (JDK).
Au moment o est crit ce livret, la dernire version stable est le JDK 1.7.
1.1.1 Compilation
La compilation seffectue par la commande javac suivie dun ou plusieurs nom de fichiers
contenant le code source de classes Java. Par exemple, javac MyProg.java compile la classe My-
Prog dont le code source est situ dans le fichier MyProg.java. La compilationncessite souvent la
prcisionde certains paramtres pour seffectuer correctement, notamment lorsque le code source
fait rfrence certaines classes situes dans dautres rpertoires que celui du code compil. Il faut
alors ajouter loption -classpath suivie des rpertoires (spars par un ; sous Windows et : sous
Unix) des classes rfrences. Par exemple :
javac -classpath /prog/exos1:/cours MyProg.java
compilera le fichier MyProg.java si celui-ci fait rfrence dautres classes situes dans les r-
pertoires /prog/exos1 et /cours. Le rsultat de cette compilation est un fichier nomm My-
Prog.class contenant le bytecode correspondant ausource compil. Ce fichier est cr par dfaut
dans le rpertoire o la compilation sest produite. Il est cependant fortement souhaitable de ne
pas mlanger les fichiers contenant le code source et ceux contenant le bytecode. Un rpertoire
de destination o sera cr le fichier MyProg.class peut tre prcis par loption -d, par exemple :
javac -d /prog/exos1 -classpath /cours MyProg.java
1.1.2 Interprtation
Le bytecode obtenu par compilation ne peut tre excut qu laide de linterprteur. Lex-
cution seffectue par la commande java suivie du nom de la classe excuter (sans lextension
.class). Comme lors de la compilation, il se peut que des classes dautres rpertoires soient n-
cessaires. Il faut alors utiliser loption -classpath comme dans lexemple qui suit :
java -classpath /prog/exos1:/cours MyProg
1.2 Programmation oriente-objet
Chaque langage de programmation appartient une famille de langages dfinissant une
approche ou une mthodologie gnrale de programmation. Par exemple, le langage C est un
langage de programmation procdurale car il suppose que le programmeur sintresse en prio-
rit aux traitements que son programme devra effectuer. Un programmeur C commencera par
identifier ces traitements pour crire les fonctions qui les ralisent sur des donnes prises comme
paramtres dentre.
La programmation oriente-objet (introduite par le langage SmallTalk) propose une mtho-
dologie centre sur les donnes. Le programmeur Java va dabord identifier un ensemble dobjets,
tel que chaque objet reprsente un lment qui doit tre utilis ou manipul par le programme,
sous la forme densembles de donnes. Ce nest que dans un deuxime temps, que le program-
meur va crire les traitements, en associant chaque traitement un objet donn. Un objet peut
2
1.2. Programmation oriente-objet
tre vu comme une entit regroupant un ensemble de donnes et de mthodes (lquivalent dune
fonction en C) de traitement.
1.2.1 Classe
Un objet est une variable (presque) comme les autres. Il faut notamment quil soit dclar
avec son type. Le type dun objet est un type complexe (par opposition aux types primitifs entier,
caractre, ) quon appelle une classe.
Une classe regroupe un ensemble de donnes (qui peuvent tre des variables primitives ou des
objets) et un ensemble de mthodes de traitement de ces donnes et/ou de donnes extrieures
la classe. On parle dencapsulation pour dsigner le regroupement de donnes dans une classe.
Par exemple, une classe Rectangle utilise pour instancier des objets reprsentant des rec-
tangles, encapsule 4 entiers : la longueur et la largeur du rectangle ainsi que la position en abscisse
et en ordonne de lorigine du rectangle (par exemple, le coin en haut gauche). On peut alors
imaginer que la classe Rectangle implmente une mthode permettant de dplacer le rectangle qui
ncessite en entre deux entiers indiquant la distance de dplacement en abscisse et en ordonne.
Laccs aux positions de lorigine du rectangle se fait directement (i.e. sans passage de paramtre)
lorsque les donnes sont encapsules dans la classe o est dfinie la mthode. Un exemple, crit
en Java, de la classe Rectangle est donn ci-dessous :
class Rectangle {
int longueur;
int largeur;
int origine_x;
int origine_y;
void deplace(int x, int y) {
this.origine_x = this.origine_x + x;
this.origine_y = this.origine_y + y;
}
int surface() {
return this.longueur * this.largeur;
}
}
Pour crire un programme avec un langage orient-objet, le programmeur crit uniquement
des classes correspondant aux objets de son systme. Les traitements effectuer sont programms
dans les mthodes de ces classes qui peuvent faire appel des mthodes dautres classes. En gn-
ral, on dfinit une classe, dite excutable, dont une mthode peut tre appele pour excuter le
programme.
Encapsulation
Lors de la conception dun programme orient-objet, le programmeur doit identifier les objets
et les donnes appartenant chaque objet mais aussi des droits daccs quont les autres objets sur
ces donnes. Lencapsulation de donnes dans un objet permet de cacher ou non leur existence
aux autres objets du programme. Une donne peut tre dclare en accs :
public : les autres objets peuvent accder la valeur de cette donne ainsi que la modifier ;
3
priv : les autres objets nont pas le droit daccder directement la valeur de cette donne
(ni de la modifier). En revanche, ils peuvent le faire indirectement par des mthodes de
lobjet concern (si celles-ci existent en accs public).
Les diffrents droits daccs utilisables en Java sont dtaills dans la section 3.2.1.
Mthode constructeur
Chaque classe doit dfinir une ou plusieurs mthodes particulires appeles des construc-
teurs. Un constructeur est une mthode invoque lors de la cration dun objet. Cette mthode,
qui peut tre vide, effectue les oprations ncessaires linitialisationdunobjet. Chaque construc-
teur doit avoir le mme nomque la classe o il est dfini et na aucune valeur de retour (cest lobjet
cr qui est renvoy). Dans lexemple prcdent de la classe rectangle, le constructeur initialise la
valeur des donnes encapsules :
class Rectangle {
...
Rectangle(int lon, int lar) {
this.longueur = lon;
this.largeur = lar;
this.origine_x = 0;
this.origine_y = 0;
}
...
}
Plusieurs constructeurs peuvent tre dfinis sils acceptent des paramtres dentre diffrents.
1.2.2 Objet
Instanciation
Un objet est une instance (anglicisme signifiant cas ou exemple ) dune classe et est rf-
renc par une variable ayant un tat (ou valeur). Pour crer un objet, il est ncessaire de dclarer
une variable dont le type est la classe instancier, puis de faire appel un constructeur de cette
classe. Lexemple ci-dessous illustre la cration dun objet de classe Cercle en Java :
Cercle mon_rond;
mon_rond = new Cercle();
Lusage de parenthses linitialisation du vecteur, montre quune mthode est appele pour
linstanciation. Cette mthode est un constructeur de la classe Cercle. Si le constructeur appel
ncessite des paramtres dentre, ceux-ci doivent tre prciss entre ces parenthses (comme lors
dun appel classique de mthode). Linstanciation dun objet de la classe Rectangle faisant appel
au constructeur donn en exemple ci-dessous pourra scrire :
Rectangle mon_rectangle = new Rectangle(15,5);
Remarque importante : enJava, la notionde pointeur est transparente pour le programmeur.
Il faut nanmoins savoir que toute variable dsignant un objet est un pointeur. Il sensuit alors
que le passage dobjets comme paramtres dune mthode est toujours un passage par rfrence.
A linverse, le passage de variables primitives comme paramtres est toujours un passage par
valeur.
4
1.2. Programmation oriente-objet
Accs aux variables et aux mthodes
Pour accder une variable associe un objet, il faut prciser lobjet qui la contient. Le sym-
bole . sert sparer lidentificateur de lobjet de lidentificateur de la variable. Une copie de la
longueur dun rectangle dans un entier temp scrit :
int temp = mon_rectangle.longueur;
La mme syntaxe est utilise pour appeler une mthode dun objet. Par exemple :
mon_rectangle.deplace(10,-3);
Pour quun tel appel soit possible, il faut que trois conditions soient remplies :
1. La variable ou la mthode appele existe !
2. Une variable dsignant lobjet vis existe et soit instancie.
3. Lobjet, au sein duquel est fait cet appel, ait le droit daccder la mthode ou la variable
(cf. section 3.2.1).
Pour rfrencer lobjet courant (celui dans lequel se situe la ligne de code), le langage Java
fournit le mot-cl this. Celui-ci na pas besoin dtre instanci et sutilise comme une variable
dsignant lobjet courant. Le mot-cl this est galement utilis pour faire appel un constructeur
de lobjet courant. Ces deux utilisations possibles de this sont illustres dans lexemple suivant :
class Carre {
int cote;
int origine_x;
int origine_y;
Carre(int cote, int x, int y) {
this.cote = cote;
this.origine_x = x;
this.origine_y = y;
}
Carre(int cote) {
this(cote, 0, 0);
}
}
5
6
Chapitre 2
Syntaxe du langage
Le langage C a servi de base pour la syntaxe du langage Java :
le caractre de fin dune instruction est ;
a = c + c;
les commentaires (non traits par le compilateur) se situent entre les symboles /* et */
ou commencent par le symbole // en se terminant la fin de la ligne
int a; // ce commentaire tient sur une ligne
int b;
ou
/*Ce commentaire ncessite
2 lignes*/
int a;
les identificateurs de variables ou de mthodes acceptent les caractres {a..z}, {A..Z}, $, _
ainsi que les caractres {0..9} sils ne sont pas le premier caractre de lidentificateur. Il faut
videmment que lidentificateur ne soit pas un mot rserv du langage (comme int ou for).
Ex : mon_entier et ok4all sont des identificateurs valides mais
mon-entier et 4all ne sont pas valides pour des identificateurs.
2.1 Types de donnes
2.1.1 Types primitifs
Le tableau 2.1 liste lensemble des types primitifs de donnes de Java.
En plus de ces types primitifs, le terme void est utilis pour spcifier le retour vide ou une
absence de paramtres dune mthode. On peut remarquer que chaque type primitif possde une
classe qui encapsule un attribut du type primitif. Par exemple, la classe Integer encapsule un
attribut de type int et permet ainsi deffectuer des oprations de traitement et des manipulations
qui seraient impossibles sur une simple variable de type int.
Alinverse du langage C, Java est un langage trs rigoureux sur le typage des donnes. Il est in-
terdit daffecter une variable la valeur dune variable dun type diffrent
1
si cette seconde variable
nest pas explicitement transforme. Par exemple :
int a;
double b = 5.0;
a = b;
1. exception faite des types associs par une relation dhritage, cf. section 4
7
Chapitre 2. Syntaxe du langage
Table 2.1 Type primitifs de donnes en Java
Type Classe q. Valeurs Porte Dfaut
boolean Boolean true ou false N/A false
byte Byte entier sign {-I28..I28} 0
char Character caractre {u0000..uFFFF} u0000
short Short entier sign {-32768..32767} 0
int Integer entier sign {-2I47483648..2I47483647} 0
long Long entier sign {-2
3I
..2
3I
I} 0
float Float rel sign {-3, 4028234
38
..3, 4028234
38
} 0.0
{-I, 40239846
43
..I, 40239846
43
}
double Double rel sign {-I, 797693I34
308
..I, 797693I34
308
} 0.0
{-4, 94063643
324
..4, 94063643
324
}
est interdit et doit tre crit de la manire suivante :
int a ;
double b = 5.0 ;
a = (int)b ;
2.1.2 Tableaux et matrices
Une variable est dclare comme un tableau ds lors que des crochets sont prsents soit aprs
son type, soit aprs son identificateur. Les deux syntaxes suivantes sont acceptes pour dclarer
un tableau dentiers (mme si la premire, non autorise en C, est plus intuitive) :
int[] mon_tableau;
int mon_tableau2[];
Un tableau a toujours une taille fixe
2
qui doit tre prcise avant laffectation de valeurs ses
indices, de la manire suivante :
int[] mon_tableau = new int[20];
De plus, la taille de ce tableau est disponible dans une variable length appartenant au tableau
et accessible par mon_tableau.length. On peut galement crer des matrices ou des tableaux
plusieurs dimensions en multipliant les crochets (ex : int[][] ma_matrice;). linstar du C,
on accde aux lments dun tableau en prcisant un indice entre crochets (mon_tableau[3] est
le quatrime entier du tableau) et un tableau de taille n stocke ses lments des indices allant de
O n-1.
2.1.3 Chanes de caractres
Les chanes de caractres ne sont pas considres en Java comme un type primitif ou comme
untableau. Onutilise une classe particulire, nomme String, fournie dans le package java.lang.
Les variables de type String ont les caractristiques suivantes :
leur valeur ne peut pas tre modifie
2. pour utiliser des ensembles taille variable, la classe java.util.Vector est trs utile
8
2.2. Oprateurs
on peut utiliser loprateur + pour concatner deux chanes de caractres :
String s1 = "hello";
String s2 = "world";
String s3 = s1 + " " + s2;
//Aprs ces instructions s3 vaut "hello world"
linitialisation dune chane de caractres scrit :
String s = new String(); //pour une chaine vide
String s2 = new String("hello world");
// pour une chane de valeur "hello world"
un ensemble de mthodes de la classe java.lang.String permettent deffectuer des op-
rations ou des tests sur une chane de caractres (voir la documentaion de la classe String).
2.2 Oprateurs
Une liste des oprateurs disponibles en Java est prsente par ordre de priorit dcroissante
dans le tableau 2.2.
2.3 Structures de contrle
Les structures de contrle permettent dexcuter un bloc dinstructions soit plusieurs fois
(instructions itratives) soit selon la valeur dune expression (instructions conditionnelles ou de
choix multiple). Dans tous ces cas, un bloc dinstruction est
soit une instruction unique ;
soit une suite dinstructions commenant par une accolade ouvrante { et se terminant par
une accolade fermante }.
2.3.1 Instructions conditionnelles
Syntaxe :
if (<condition>) <bloc1> [else <bloc2>]
ou
<condition>?<instruction1>:<instruction2>
<condition> doit renvoyer une valeur boolenne. Si celle-ci est vraie cest <bloc1> (resp.
<instruction1>) qui est excut sinon <bloc2> (resp. <instruction2>) est excut. La partie
else <bloc2> est facultative.
Exemple :
if (a == b) {
a = 50;
b = 0;
} else {
a = a - 1;
}
9
Table 2.2 Oprateurs Java
Pr. Oprateur Syntaxe Rsultat Signification
1 ++ ++<ari> <ari> pr incrmentation
<ari>++ <ari> post incrmentation
<ari> <ari> pr dcrmentation
<ari> <ari> post dcrmentation
+ +<ari> <ari> signe positif
- -<ari> <ari> signe ngatif
! !<boo> <boo> complment logique
(type) (type)<val> <val> changement de type
2 * <ari>*<ari> <ari> multiplication
/ <ari>/<ari> <ari> division
% <ari>%<ari> <ari> reste de la division
3 + <ari>+<ari> <ari> addition
- <ari>-<ari> <ari> soustraction
+ <str>+<str> <str> concatnation
4 << <ent> << <ent> <ent> dcalage de bits
gauche
>> <ent> >> <ent> <ent> dcalage de bits
droite
5 < <ari> < <ari> <boo> infrieur
<= <ari> <= <ari> <boo> infrieur ou gal
> <ari> > <ari> <boo> suprieur
>= <ari> >= <ari> <boo> suprieur ou gal
instanceof <val>instanceof<cla> <boo> test de type
6 == <val>==<val> <boo> gal
!= <val>!=<val> <boo> diffrent de
7 & <ent>&<ent> <ent> ET bit bit
<boo>&<boo> <boo> ET boolen
8 <ent><ent> <ent> OU exclusif bit bit
<boo><boo> <boo> OU exclusif boolen
9 | <ent>|<ent> <ent> OU bit bit
<boo>|<boo> <boo> OU boolen
10 && <boo>&&<boo> <boo> ET logique
11 || <boo>||<boo> <boo> OU logique
12 ?: <boo>?<ins>:<ins> <ins> si...alors...sinon
13 = <var>=<val> <val> assignation
Lgende
<ari> valeur arithmtique
<boo> valeur boolenne
<cla> classe
<ent> valeur entire
<ins> instruction
<str> chane de caractres (String)
<val> valeur quelconque
<var> variable
2.3.2 Instructions itratives
Les instruction itratives permettent dexcuter plusieurs fois un bloc dinstructions, et ce,
jusqu ce quune condition donne soit fausse. Les trois types dinstruction itratives sont les
suivantes :
TantQue...Faire... Lexcution de cette instruction suit les tapes suivantes :
1. la condition (qui doit renvoyer une valeur boolenne) est value. Si celle-ci est vraie on
passe ltape 2, sinon on passe ltape 4 ;
2. le bloc est excut ;
3. retour ltape 1 ;
4. la boucle est termine et le programme continue son excution en interprtant les instruc-
tion suivant le bloc.
Syntaxe :
while (<condition>) <bloc>
Exemple :
10
2.3. Structures de contrle
while (a != b) a++;
Faire...TantQue... Lexcution de cette instruction suit les tapes suivantes :
1. le bloc est excut ;
retourne ltape 1, sinon on passe ltape 3 ;
tion suivant le bloc.
Syntaxe :
do <bloc> while (<condition>);
Exemple :
do a++
while (a != b);
Pour...Faire Cette boucle est constitue de trois parties : (i) une initialisation (la dclaration de
variables locales la boucle est autorise dans cette partie) ; (ii) une condition darrt ; (iii) un
ensemble dinstructions excuter aprs chaque itration (chacune de ces instructions est spare
par une virgule). Lexcution de cette instruction suit les tapes suivantes :
1. les initialisations sont effectues ;
passe ltape 2, sinon on passe ltape 6 ;
3. le bloc principal est excut ;
4. les instructions excuter aprs chaque itration sont excutes ;
5. retour ltape 2 ;
tions suivant le bloc principal.
Syntaxe :
for (<init>;<condition>;<instr_post_itration>) <bloc>
Exemple :
for (int i = 0, j = 49; (i < 25) && (j >= 25); i++, j--) {
if (tab[i] > tab[j]) {
int tampon = tab[j];
Question : que se passe-t-il si le break situ aprs le case 'c' est omis ?
2.3.3 Instructions break et continue
Linstruction break est utilise pour sortir immdiatement dun bloc dinstructions (sans trai-
ter les instructions restantes dans ce bloc). Dans le cas dune boucle on peut galement utiliser
linstruction continue avec la diffrence suivante :
break : lexcution se poursuit aprs la boucle (comme si la condition darrt devenait vraie) ;
11
continue : lexcution du bloc est arrte mais pas celle de la boucle. Une nouvelle itration
du bloc commence si la condition darrt est toujours vraie.
Exemple :
for (int i = 0, j = 0; i < 100 ; i++) {
if (i > tab.length) {
break;
}
if (tab[i] == null) {
continue;
}
tab2[j] = tab[i];
j++;
}
12
Chapitre 3
lments de programmation Java
3.1 Premiers pas
Un programme crit en Java consiste en un ensemble de classes reprsentant les lments ma-
nipuls dans le programme et les traitements associs. Lexcution du programme commence par
lexcution dune classe qui doit implmenter une mthode particulire public static void
main(String[] args). Les classes implmentant cette mthode sont appelles classes excu-
tables.
3.1.1 Classe HelloWorld
Une classe Java HelloWorld qui affiche la chane de caractres Hello world scrit :
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world");
}
}
Lexcution (aprs compilation) de cette classe se fait de la manire suivante :
C:\>java HelloWorld
Hello world
C:\>
Remarque : le tableau de chanes de caractres args qui est un paramtre dentre de la m-
thode main contient des valeurs prcises lexcution. Si la classe avait t excute par la ligne
de commande java HelloWorld 4 toto _, ce tableau contiendrait 3 lments dont les va-
leurs seraient respectivement 4, toto et _.
Dans ce premier programme trs simple, une seule classe est utilise. Cependant, la concep-
tion dun programme orient-objet ncessite, pour des problmes plus complexes, de crer plu-
sieurs classes et la classe excutable ne sert souvent qu instancier les premiers objets. La classe
excutable suivante cre un objet en instanciant la classe Rectangle (cf. section 1.2.1) et affiche sa
surface :
13
Chapitre 3. lments de programmation Java
public class RectangleMain {
Rectangle rect = new Rectangle(5, 10);
System.out.println("La surface est " + rect.surface());
}
}
Remarque importante : il est obligatoire dimplmenter chaque classe publique dans un fi-
chier spar et il est indispensable que ce fichier ait le mme nom que celui de la classe. Dans le
cas prcdent, deux fichiers ont ainsi t crs : RectangleMain.java et Rectangle.java.
3.1.2 Packages
Un grand nombre de classes, fournies par Java SE, implmentent des donnes et traitements
gnriques utilisables par un grand nombre dapplications. Ces classes forment lAPI (Application
Programmer Interface) du langage Java. Une documentation en ligne pour lAPI java est disponible
lURL :
http://docs.oracle.com/javase/7/docs/api/
Toutes ces classes sont organises en packages (ou bibliothques) ddis un thme prcis.
Parmi les packages les plus utiliss, on peut citer les suivants :
Package Description
java.awt Classes graphiques et de gestion dinterfaces
java.io Gestion des entres/sorties
java.lang Classes de base (import par dfaut)
java.util Classes utilitaires
javax.swing Autres classes graphiques
Pour accder une classe dun package donn, il faut pralablement importer cette classe ou
son package. Par exemple, la classe Date appartenant au package java.util qui implmente un
ensemble de mthodes de traitement sur une date peut tre importe de deux manires :
une seule classe du package est importe :
import java.util.Date;
toutes les classes du package sont importes (mme les classes non utilises) :
import java.util.*;
Le programme suivant utilise cette classe pour afficher la date actuelle :
public class DateMain {
Date today = new Date();
System.out.println("Nous sommes le " + today.toString());
}
}
14
3.2. Variables et mthodes
Il est possible de crer vos propres packages en prcisant, avant la dclaration dune classe, le
package auquel elle appartient. Pour assigner la classe prcdente un package, nomm fr.emse,
il faut modifier le fichier de cette classe comme suit :
package fr.emse;
public class DateMain {
...
}
Enfin, il faut que le chemin daccs du fichier DateMain.java corresponde au nom de son
package. Celui-ci doit donc tre situ dans un rpertoire fr/emse/DateMain.java accessible
partir des chemins daccs dfinis lors de la compilation ou de lexcution (voir section 1.1.1).
3.2 Variables et mthodes
3.2.1 Visibilit des champs
Dans les exemples prcdents, le mot-cl public apparat parfois au dbut dune dclaration
de classe ou de mthode sans quil ait t expliqu jusquici. Ce mot-cl autorise nimporte quel
objet utiliser la classe ou la mthode dclare comme publique. La porte de cette autorisation
dpend de llment laquelle elle sapplique (voir le tableau 3.1).
Table 3.1 Porte des autorisations
lment Autorisations
Variable Lecture et criture
Mthode Appel de la mthode
Classe Instanciation dobjets de cette classe et
accs aux variables et mthodes de classe
Le mode public nest, bien sr, pas le seul type daccs disponible en Java. Deux autres mot-
cls peuvent tre utiliss en plus du type daccs par dfaut : protected et private. Le tableau
3.2 rcapitule ces diffrents types daccs (la notion de sous-classe est explique dans la section 4).
Table 3.2 Autorisations daccs
public protected dfaut private
Dans la mme classe Oui Oui Oui Oui
Dans une classe du Oui Oui Oui Non
mme package
Dans une sous-classe Oui Oui Non Non
dun autre package
Dans une classe quelcon- Oui Non Non Non
que dun autre package
15
Si aucun mot-cl ne prcise le type daccs, celui par dfaut est appliqu. En gnral, il est
souhaitable que les types daccs soient limits et le type daccs public, qui est utilis systma-
tiquement par les programmeurs dbutants, ne doit tre utilis que sil est indispensable. Cette
restriction permet dviter des erreurs lors daccs des mthodes ou de modifications de va-
riables sans connatre totalement leur rle.
3.2.2 Variables et mthodes de classe
Dans certains cas, il est plus judicieux dattacher une variable ou une mthode une classe
plutt quaux objets instanciant cette classe. Par exemple, la classe java.lang.Integer possde
une variable MAX_VALUE qui reprsente la plus grande valeur qui peut tre affecte un entier.
Or, cette variable tant commune tous les entiers, elle nest pas duplique dans tous les objets
instanciant la classe Integer mais elle est associe directement la classe Integer. Une telle va-
riable est appele variable de classe. De la mme manire, il existe des mthodes de classe qui sont
associes directement une classe. Pour dclarer une variable ou mthode de classe, on utilise le
mot-cl static qui doit tre prcis avant le type de la variable ou le type de retour de la mthode.
La classe java.lang.Math nous fournit un bon exemple de variable et de mthodes de classes.
public final class Math {
...
public static final double PI = 3.14159265358979323846;
...
public static double toRadians(double angdeg) {
return angdeg / 180.0 * PI;
}
...
}
La classe Math fournit un ensemble doutils (variables et mthodes) trs utiles pour des pro-
grammes devant effectuer des opration mathmatiques complexes. Dans la portion de classe
reproduite ci-dessus, on peut notamment y trouver une approximation de la valeur de et une
mthode convertissant la mesure dun angle dune valeur en degrs en une valeur en radians. Dans
le cas de cette classe, il est tout a fait inutile de crer et dinstancier un objet partir de la classe
Math. En effet, la valeur de ou la conversion de degrs en radians ne vont pas varier suivant
lobjet auquel elles sont rattaches. Ce sont des variables et des mthodes de classe qui peuvent
tre invoques partir de toute autre classe (car elles sont dclares en accs public) de la manire
suivante :
public class MathMain {
System.out.println("pi = " + Math.PI);
System.out.println("90 = " + Math.toRadians(90));
}
}
Question : Dans les sections prcdentes, nous avons dj utilis une variable de classe et une
mthode de classe. Pouvez-vous trouver lesquelles ?
16
3.2. Variables et mthodes
Rponse :
la mthode main des classes excutables est une mthode de classe car elle est appele directe-
ment partir dune classe ;
lors de laffichage dune chane de caractres lcran par linstruction
System.out.println(), on fait appel la variable out de la classe java.lang.System qui
est un objet reprsentant la sortie standard (lcran) et sur laquelle on appelle la mthode
println permettant dafficher une chane de caractres.
17
18
Chapitre 4
Hritage
Dans certaines applications, les classes utilises ont en commun certaines variables, mthodes
de traitement ou mme des signatures de mthode. Avec un langage de programmation orient-
objet, on peut dfinir une classe diffrent niveaux dabstraction permettant ainsi de factoriser
certains attributs communs plusieurs classes. Une classe gnrale dfinit alors un ensemble dat-
tributs qui sont partags par dautres classes, dont on dira quelles hritent de cette classe gnrale.
Par exemple, les classes Carre et Rectangle peuvent partager une mthode surface() ren-
voyant le rsultat du calcul de la surface de la figure. Plutt que dcrire deux fois cette mthode,
on peut dfinir une relation dhritage entre les classes Carre et Rectangle. Dans ce cas, seule la
classe Rectangle contient le code de la mthode surface() mais celle-ci est galement utilisable
sur les objets de la classe Carre si elle hrite de Rectangle.
4.1 Principe de lhritage
Lide principale de lhritage est dorganiser les classes de manire hirarchique. La relation
dhritage est unidirectionnelle et, si une classe B hrite dune classe A, on dira que B est une
sous-classe de A. Cette notion de sous-classe signifie que la classe B est un cas particulier de la
classe A et donc que les objets instanciant la classe B instancient galement la classe A.
Prenons comme exemple des classes Carre, Rectangle et Cercle. La figure 4.1 propose une
organisation hirarchique de ces classes telle que Carre hrite de Rectangle qui hrite, ainsi que
Cercle, dune classe Forme.
Carre
Forme
Rectangle Cercle
Figure 4.1 Exemple de relations dhritage
Pour le moment, nous considrerons la classe Forme comme vide (cest--dire sans aucune
variable ni mthode) et nous nous intressons plus particulirement aux classes Rectangle et
19
Chapitre 4. Hritage
Carre. La classe Rectangle hritant dune classe vide, elle ne peut profiter daucun de ses attri-
buts et doit dfinir toutes ses variables et mthodes. Une relation dhritage se dfinit en Java par
le mot-cl extends utilis comme dans lexemple suivant :
public class Rectangle extends Forme {
private int largeur;
private int longueur;
public Rectangle(int x, int y) {
this.largeur = x;
this.longueur = y;
}
public int getLargeur() {
return this.largeur;
}
public int getLongueur() {
return this.longueur;
}
public int surface() {
return this.longueur * this.largeur;
}
public void affiche() {
System.out.println("rectangle " + longueur + "x" + largeur);
}
}
En revanche, la classe Carre peut bnficier de la classe Rectangle et ne ncessite pas la r-
criture de ces mthodes si celles-ci conviennent la sous-classe. Toutes les mthodes et variables
de la classe Rectangle ne sont nanmoins pas accessibles dans la classe Carre. Pour quun attri-
but puisse tre utilis dans une sous-classe, il faut que son type daccs soit public ou protected,
ou, si les deux classes sont situes dans le mme package, quil utilise le type daccs par dfaut.
Dans cet exemple, les variables longueur et largeur ne sont pas accessibles dans la class Carre
qui doit passer par les mthodes getLargeur() et getLongueur(), dclares comme publiques.
4.1.1 Redfinition
Lhritage intgral des attributs de la classe Rectangle pose deux problmes :
1. il faut que chaque carr ait une longueur et une largeur gales ;
2. la mthode affiche crit le mot rectangle en dbut de chane. Il serait souhaitable que
ce soit carr qui saffiche.
De plus, les constructeurs ne sont pas hrits par une sous-classe. Il faut donc crire unconstruc-
teur spcifique pour Carre. Ceci nous permettra de rsoudre le premier problme en crivant un
constructeur qui ne prend quun paramtre qui sera affect la longueur et la largeur. Pour
attribuer une valeur ces variables (qui sont prives), le constructeur de Carre doit faire appel
20
4.1. Principe de lhritage
au constructeur de Rectangle en utilisant le mot-cl super qui fait appel au constructeur de la
classe suprieure comme suit :
public Carre(int cote) {
super(cote,cote);
}
Remarques :
Lappel au constructeur dune classe suprieure doit toujours se situer dans un constructeur
et toujours en tant que premire instruction ;
Si aucun appel un constructeur dune classe suprieure nest fait, le constructeur fait appel
implicitement un constructeur vide de la classe suprieure (comme si la ligne super() tait
prsente). Si aucun constructeur vide nest accessible dans la classe suprieure, une erreur se
produit lors de la compilation.
Le second problme peut tre rsolu par une redfinition de mthode. On dit quune mthode
dune sous-classe redfinit une mthode de sa classe suprieure, si elles ont la mme signature
mais que le traitement effectu est r-crit dans la sous-classe. Voici le code de la classe Carre o
sont rsolus les deux problmes soulevs :
public class Carre extends Rectangle {
public Carre(int cote) {
super(cote, cote);
}
public void affiche() {
System.out.println("carr " + this.getLongueur());
}
}
Lors de la redfinition dune mthode, il est encore possible daccder la mthode redfi-
nie dans la classe suprieure. Cet accs utilise galement le mot-cl super comme prfixe la
mthode. Dans notre cas, il faudrait crire super.affiche() pour effectuer le traitement de la
mthode affiche() de Rectangle.
Enfin, il est possible dinterdire la redfinition dune mthode ou dune variable en introdui-
sant le mot-cl final au dbut dune signature de mthode ou dune dclaration de variable. Il
est aussi possible dinterdire lhritage dune classe en utilisant final au dbut de la dclaration
dune classe (avant le mot-cl class).
4.1.2 Polymorphisme
Le polymorphisme est la facult attribue un objet dtre une instance de plusieurs classes.
Il a une seule classe relle qui est celle dont le constructeur a t appel en premier (cest--dire
la classe figurant aprs le new) mais il peut aussi tre dclar avec une classe suprieure sa classe
relle. Cette proprit est trs utile pour la cration densembles regroupant des objets de classes
diffrentes comme dans lexemple suivant :
21
Chapitre 4. Hritage
Forme[] tableau = new Forme[4];
tableau[0] = new Rectangle(10,20);
tableau[1] = new Cercle(15);
tableau[2] = new Rectangle(5,30);
tableau[3] = new Carre(10);
Loprateur instanceof peut tre utilis pour tester lappartenance une classe comme suit :
for (int i = 0 ; i < tableau.length ; i++) {
if (tableau[i] instanceof Forme)
System.out.println("element " + i + " est une forme");
if (tableau[i] instanceof Cercle)
System.out.println("element " + i + " est un cercle");
if (tableau[i] instanceof Rectangle)
System.out.println("element " + i + " est un rectangle");
if (tableau[i] instanceof Carre)
System.out.println("element " + i + " est un carr");
}
Lexcution de ce code sur le tableau prcdent affiche le texte suivant :
element[0] est une forme
element[0] est un rectangle
element[1] est un cercle
element[3] est un carr
Lensemble des classes Java, y compris celles crites en dehors de lAPI, forme une hirarchie
avec une racine unique. Cette racine est la classe Object dont hrite toute autre classe. En effet, si
vous ne prcisez pas explicitement une relation dhritage lors de lcriture dune classe, celle-ci
hrite par dfaut de la classe Object. Grce cette proprit, des classes gnriques
1
de cration
et de gestion dun ensemble, plus labores que les tableaux, regroupent des objets appartenant
la classe Object (donc de nimporte quelle classe).
Une des proprits induites par le polymorphisme est que linterprteur Java est capable de
trouver le traitement effectuer lors de lappel dune mthode sur un objet. Ainsi, pour plusieurs
objets dclars sous la mme classe (mais nayant pas la mme classe relle), le traitement associ
une mthode donn peut tre diffrent. Si cette mthode est redfinie par la classe relle dun objet
(ou par une classe situe entre la classe relle et la classe de dclaration), le traitement effectu est
celui dfini dans la classe la plus spcifique de lobjet et qui redfinie la mthode.
Dans notre exemple, la mthode affiche() est redfinie dans toutes les sous-classes de Forme
et les traitements effectus sont :
for (int i = 0 ; i < tableau.length ; i++) {
tableau[i].affiche();
}
1. voir par exemple les classes java.util.Vector, java.util.Hashtable,
22
4.2. Interfaces
Rsultat :
rectangle 10x20
cercle 15
rectangle 5x30
carr 10
Dans ltat actuel de nos classes, ce code ne pourra cependant pas tre compil. En effet, la
fonction affiche() est appele sur des objets dont la classe dclare est Forme mais celle-ci ne
contient aucune fonction appele affiche() (elle est seulement dfinie dans ses sous-classes).
Pour compiler ce programme, il faut transformer la classe Forme en une interface ou une classe
abstraite tel que cela est fait dans les sections suivantes.
4.2 Interfaces
Une interface est un type, au mme titre quune classe, mais abstrait et qui donc ne peut tre
instanci (par appel new plus constructeur). Une interface dcrit un ensemble de signatures de
mthodes, sans implmentation, qui doivent tre implmentes dans toutes les classes qui im-
plmentent linterface. Lutilit du concept dinterface rside dans le regroupement de plusieurs
classes, tel que chacune implmente un ensemble commun de mthodes, sous un mme type. Une
interface possde les caractristiques suivantes :
elle contient des signatures de mthodes ;
elle ne peut pas contenir de variables ;
une interface peut hriter dune autre interface (avec le mot-cl extends) ;
une classe (abstraite ou non) peut implmenter plusieurs interfaces. La liste des interfaces
implmentes doit alors figurer aprs le mot-cl implements plac dans la dclaration de
classe, en sparant chaque interface par une virgule.
Dans notre exemple, Forme peut tre une interface dcrivant les mthodes qui doivent tre
implmentes par les classes Rectangle et Cercle, ainsi que par la classe Carre (mme si celle-ci
peut profiter de sonhritage de Rectangle). Linterface Forme scrit alors de la manire suivante :
public interface Forme {
public int surface() ;
public void affiche() ;
}
Pour obliger les classes Rectangle, Cercle et Carre implmenter les mthodes surface()
et affiche(), il faut modifier lhritage de ce qui tait la classe Forme en une implmentation de
linterface dfinie ci-dessus :
public class Rectangle implements Forme {
...
}
et
public class Cercle implements Forme {
...
}
23
Chapitre 4. Hritage
Cette structure de classes nous permet dsormais de pouvoir compiler lexemple donn dans la
section 4.1.2 traitant du polymorphisme. En dclarant un tableau constitu dobjets implmentant
linterface Forme, on peut appeler la mthode affiche() qui existe et est implmente par chaque
objet.
Si une classe implmente une interface mais que le programmeur na pas crit limplmenta-
tion de toutes les mthodes de linterface, une erreur de compilation se produira sauf si la classe
est une classe abstraite.
4.3 Classes abstraites
Le concept de classe abstraite se situe entre celui de classe et celui dinterface. Cest une classe
quon ne peut pas directement instancier car certaines de ses mthodes ne sont pas implmen-
tes. Une classe abstraite peut donc contenir des variables, des mthodes implmentes et des
signatures de mthode implmenter. Une classe abstraite peut implmenter (partiellement ou
totalement) des interfaces et peut hriter dune classe ou dune classe abstraite.
Le mot-cl abstract est utilis devant le mot-cl class pour dclarer une classe abstraite,
ainsi que pour la dclaration de signatures de mthodes implmenter.
Imaginons que lon souhaite attribuer deux variables, origine_x et origine_y, tout objet
reprsentant une forme. Comme une interface ne peut contenir de variables, il faut transformer
Forme en classe abstraite comme suit :
public abstract class Forme {
private int origine_x;
private int origine_y;
public Forme() {
this.origine_x = 0;
this.origine_y = 0;
}
public int getOrigineX() {
return this.origine_x;
}
public int getOrigineY() {
return this.origine_y;
}
public void setOrigineX(int x) {
this.origine_x = x;
}
public void setOrigineY(int y) {
this.origine_y = y;
}
public abstract int surface();
public abstract void affiche();
}
24
4.4. Classes et mthodes gnriques
De plus, il faut rtablir lhritage des classes Rectangle et Cercle vers Forme :
public class Rectangle extends Forme {
...
}
et
public class Cercle extends Forme {
...
}
Lorsquune classe hrite dune classe abstraite, elle doit :
soit implmenter les mthodes abstraites de sa super-classe en les dotant dun corps ;
soit tre elle-mme abstraite si au moins une des mthodes abstraites de sa super-classe
reste abstraite.
4.4 Classes et mthodes gnriques
Il est parfois utile de dfinir des classes paramtres par un type de donnes (ou une classe).
Par exemple, dans le package java.util, de nombreuses classes sont gnriques et notamment
les classes reprsentant des ensembles (Vector, ArrayList, etc.). Ces classes sont gnriques dans
le sens o elles prennent en paramtre un type (classe ou interface) quelconque E. E est en quelque
sorte une variable qui peut prendre comme valeur un type de donn. Ceci se note comme suit, en
prenant lexempe de java.util.ArrayList :
package java.util ;
public class ArrayList<E>
extends AbstractList<E>
implements List<E>, ...
{
...
public E set(int index, E element) {
...
}
public boolean add(E e) {
...
}
...
}
Nous pouvons remarquer que le type pass en paramtre est not entre chevrons (ex : <E>),
et quil peut ensuite tre rutilis dans le corps de la classe, par des mthodes (ex : la mthode set
renvoie un lment de classe E).
Il est possible de dfinir des contraintes sur le type pass en paramtre, comme par exemple
une contrainte de type extends
2
:
2. Ici, on utilise T extends E pour signaler que le type T est un sous type de E, que E soit une classe ou une
interface (on nutilise pas implements).
25
Chapitre 4. Hritage
public class SortedList<T extends Comparable<T {
...
}
Ceci signifie que la classe SortedList (liste ordonne que nous voulons dfinir) est param-
tre par le type T qui doit tre un type driv (par hritage ou interfaage) de Comparable<T>.
En bref, nous dfinissons une liste ordonne dlments comparables entre eux (pour pouvoir les
trier), grce la mthode int compareTo(T o) de linterface Comparable
3
qui permet de com-
parer un Comparable un lment de type T.
3. Voir java.lang.Comparable pour plus dinformation sur cette interface.
26
Chapitre 5
Gestion des exceptions
Lors de lcriture dun programme, la prise en compte derreurs prend une place trs impor-
tante si lon souhaite crire un programme robuste. Par exemple, la simple ouverture dun fichier
peut provoquer beaucoup derreurs telles que linexistence du fichier, un mauvais format, une in-
terdiction daccs, une erreur de connexion au priphrique, Pour que notre programme soit
robuste, il faut que toutes les erreurs possibles soient dtectes et traites.
Certains langages de programmation, dont le langage Java, proposent un mcanisme de prise
en compte des erreurs, fond sur la notion dexception. Une exception est un objet qui peut tre
mis par une mthode si un vnement dordre exceptionnel (les erreurs rentrent dans cette
catgorie) se produit. La mthode en question ne renvoie alors pas de valeur de retour, mais met
une exception expliquant la cause de cette mission. La propagation dune mission se droule
selon les tapes suivantes :
1. Une exception est gnre lintrieur dune mthode ;
2. Si la mthode prvoit un traitement de cette exception, on va au point 4, sinon au point 3 ;
3. Lexception est renvoye la mthode ayant appel la mthode courante, on retourne au
point 2 ;
4. Lexception est traite et le programme reprend son cours aprs le traitement de lexception.
La gestion derreurs par propagation dexception prsente deux atouts majeurs :
Une facilit de programmation et de lisibilit : il est possible de regrouper la gestion der-
reurs un mme niveau. Cela vite des redondances dans lcriture de traitements derreurs
et encombre peu le reste du code avec ces traitements.
Une gestion des erreurs propre et explicite : certains langages de programmation utilisent
la valeur de retour des mthodes pour signaler une erreur la mthode appelante. Etant
donn que ce nest pas le rle de la valeur de retour de dcrire une erreur, il est souvent im-
possible de connatre les causes relles de lerreur. La dissociation de la valeur de retour et de
lexception permet cette dernire de dcrire prcisment la ligne de code ayant provoqu
lerreur et la nature de cette erreur.
5.1 Dclaration
Il est ncessaire de dclarer, pour chaque mthode, les classes dexception quelle est suscep-
tible dmettre. Cette dclaration se fait la fin de la signature dune mthode par le mot-cl
throws la suite duquel les classes dexceptions (spares par une virgule sil en existe plusieurs)
qui peuvent tre gnres sont prcises. La mthode parseInt de la classe Integer est un bon
exemple :
27
Chapitre 5. Gestion des exceptions
public static int parseInt(String s) throws NumberFormatException {
...
}
Cette mthode convertit une chane de caractres, qui doit contenir uniquement des chiffres,
en un entier. Une erreur peut se produire si cette chane de caractres ne contient pas que des
chiffres. Dans ce cas une exception de la classe NumberFormatException est mise.
Une exception peut tre mise dans une mthode de deux manires : (i) par une autre m-
thode appele dans le corps de la premire mthode ; (ii) par la cration dun objet instanciant la
classe Exception (ou la classe Throwable) et la leve explicite de lexception en utilisant le mot-cl
throw.
Lexemple ci-dessous illustre ce second cas :
public class ExempleException {
/*
* Cette mthode renvoie le nom du mois
* correspondant au chiffre donn en paramtre.
* Si celui-ci n'est pas valide une exception de classe
* IndexOutOfBoundsException est leve.
*/
public static String month(int mois)
throws IndexOutOfBoundsException {
if ((mois < 1) || (mois > 12)) {
throw new IndexOutOfBoundsException(
"le numero du mois qui est "
+ mois
+ " doit tre compris entre 1 et 12");
}
if (mois == 1)
return "Janvier";
else if (mois == 2)
return "Fvrier";
...
else if (mois == 11)
return "Novembre";
else
return "Dcembre";
}
}
La signification des exceptions de la classe IndexOutOfBoundsException est quun index
donn dpasse les bornes minimum et maximum quil devrait respecter. Si une mthode de-
mande la chane de caractres correspondant des mois inexistants (infrieur 1 ou suprieur
12) une exception signalera cette erreur. On peut remarquer dans cet exemple que la dtection
et la formulation de lerreur sont codes dans la mthode mais pas son traitement.
28
5.2. Interception et traitement
5.2 Interception et traitement
Avant de coder le traitement de certaines exceptions, il faut prciser lendroit o elles vont
tre interceptes. Si une mthode A appelle une mthode B qui appelle une mthode C qui appelle
une mthode D, et que cette mthode D lve une exception, celle-ci est dabord transmise C qui
peut lintercepter ou la transmettre B, qui peut aussi lintercepter ou la transmettre A.
Linterception dexceptions se fait par une sorte de mise sur coute dune portion de code.
Pour cela on utilise le mot-cl try suivi du bloc surveiller. Si aucune exception ne se produit
dans le bloc correspondant, le programme se droule normalement comme si linstruction try
tait absente. Par contre, si une exception est leve, le traitement de lexception est excut puis
lexcution du programme reprend son cours aprs le bloc test.
Il est galement ncessaire de prciser quelles classes dexception doivent tre interceptes
dans le bloc test. Linterception dune classe dexception scrit grce au mot-cl catch suivi de
la classe concern, dun nom de variable correspondant lobjet exception, puis du traitement.
Si une exception est leve sans quaucune interception ne soit prvue pour sa classe, celle-ci est
propage la mthode prcdente.
Dans lexemple ci-dessous, le programme demande lutilisateur de saisir le numero dun
mois et affiche lcran le nom de ce mois. Les exceptions qui peuvent tre leves par ce pro-
gramme sont traites.
public class ExempleTraitementException {
System.out.print("Entrez le numero d'un mois : ");
try {
BufferedReader input = new BufferedReader(
new InputStreamReader(System.in));
String choix = input.readLine();
int numero = Integer.parseInt(choix);
System.out.println(ExempleException.month(numero));
} catch (IndexOutOfBoundsException e) {
System.err.println("Numero incorrect : "
+ e.getMessage());
} catch (NumberFormatException e) {
System.err.println("Entre incorrecte : "
+ e.getMessage());
} catch (IOException e) {
System.err.println("Erreur d'accs : "
+ e.getMessage());
}
}
}
Trois classes dexception sont ici traites :
IndexOutOfBoundsException (lev par la mthode month) se produit si le numero entr
par lutilisateur est infrieur 1 ou suprieur 12 ;
NumberFormatException (lev par la mthode parseInt) qui se produit si le texte entr
par lutilisateur nest pas convertible en entier ;
IOException (lev par la mthode readLine) qui se produit si il y a eu une erreur daccs
au priphrique dentre.
29
Dans chacun de ces cas, le traitement consiste afficher le message derreur associ lexception.
5.3 Classes dexception
Une classe est considre comme une classe dexception ds lors quelle hrite de la classe
Throwable. Un grand nombre de classes dexception sont proposes dans lAPI pour couvrir les
catgories derreurs les plus frquentes. Les relations dhritage entre ces classes permettent de
lever ou dintercepter des exceptions dcrivant une erreur diffrents niveaux de prcision. Les
classes dexception les plus frquemment utilises sont rcapitules dans le tableau 5.1.
Table 5.1 Classes dexception frquentes
Classe Description
AWTException Les exceptions de cette classe peuvent se
produire lors doprations de type
graphique.
ClassCastException Signale une erreur lors de la conversion
dun objet en une classe incompatible
avec sa vraie classe.
FileNotFoundException Signale une tentative douverture dun
fichier inexistant.
IndexOutOfBoundsException Se produit lorsque lon essaie daccder
un lment inexistant dans un
ensemble.
IOException Les exceptions de cette classe peuvent se
produire lors doprations dentres/
sorties.
NullPointerException Se produit lorsquun pointeur null
est reu par une mthode nacceptant
pas cette valeur, ou lorsque lon
appelle une mthode ou une variable
partir dun pointeur null.
Remarque : Il nest pas indispensable dintercepter les exceptions hritant de la
classe RuntimeException (dans le tableau ci-dessus, les classes qui en hritent sont
ClassCastException, IndexOutOfBoundsException et NullPointerException). Celles-ci
peuvent tre propages jusqu la machine virtuelle et napparatre que pendant lexcution. Ces
exceptions sont appeles exception non vrifies ou unchecked exceptions.
Si aucune des classes dexception ne correspond un type derreur que vous souhaitez ex-
primer, vous pouvez galement crire vos propres classes dexception. Pour cela, il suffit de faire
hriter votre classe de la classe java.lang.Exception.
5.4 Classification des erreurs en Java
On peut finalement distinguer quatre types de situations derreurs en Java :
30
5.4. Classification des erreurs en Java
Erreurs de compilation. Avant mme de pouvoir excuter le programme, notre code source g-
nre des erreur par le compilateur. Il faut alors rviser et corriger le code pour ne plus avoir
derreurs.
Erreurs dexcution. Alors que notre programme est en cours dexcution, la JVM tant mal
configure ou corrompue, le programme sarrte ou se gle. A priori, cest une erreur non
pas due notre programme, mais la configuration ou ltat de lenvironnement dexcu-
tion de notre programme.
Exception non vrifie. Alors que notre programme est en cours dexcution, une trace de la pile
des exceptions est affiche, pointant vers une partie de notre code sans gestion dexception.
Visiblement, nous avons utilis du code qui est capable de lever un exception non vrifie
(comme NullPointerException). Il faut modifier le programme pour que cette situation
ne survienne pas.
Exception vrifie. Alors que notre programme est en cours dexcution, une trace de la pile des
exceptions est affiche, pointant vers une partie de notre code avec gestion dexception.
Visiblement, nous avons produit du code qui est capable de lever un exception vrifie
(comme FileNotFoundException) mais les donnes passes notre programme ne valide
pas ces exceptions (par exemple, lorsque lon essaie douvrir un fichier qui nexiste pas). Il
faut alors revoir les donnes passes en paramtre du programme. Notre code a bien dtect
les problmes quil fallait dtecter. Le chapitre suivant sur les entres/sorties prsentent de
nombreux exemples relatifs ce cas.
31
32
Chapitre 6
Gestion des entres/sorties simples
Le package java.io propose un ensemble de classes permettant de grer la plupart des en-
tres/sorties dun programme. Cette gestion consiste crer un objet flux dans lequel transitent
les donnes envoyer ou recevoir. Un flux connecte un objet Java un autre lment. Deux cas
sont illustrs dans ce chapitre : les interactions avec un utilisateur (entre clavier et sortie cran)
et les accs en lecture ou criture un fichier.
6.1 Flux dentre
Un flux dentre est une instance dune sous-classe de InputStream. Chaque classe de flux
dentre a son propre mode dchange de donnes qui spcifie un format particulier de donnes
ou un accs particulier. Les classes les plus couramment utilises sont :
ByteArrayInputStream permet de lire le flux dentre sous la forme doctets (byte) ;
DataInputStreampermet de lire le flux dentre sous la forme de types de donnes primitifs
de Java. Il existe des mthodes pour rcuprer un entier, un rel, un caractre,
FileInputStream est utilis pour lire le contenu dun fichier. Les objets de cette classe sont
souvent encapsuls dans un autre objet de classe InputStream qui dfinit le format des
donnes lire.
ObjectInputStream permet de lire des objets (c--d des instances de classes Java) par-
tir du flux dentre, si ces objets implmentent les interfaces java.io.Serializable ou
java.io.Externalizable.
Reader nest pas une sous-classe de InputStream mais reprsente un flux dentre pour
chanes de caractres. Plusieurs sous-classes de Reader permettent la cration de flux pour
chanes de caractres.
Scanner nest pas une sous-classe de InputStream, mais un Iterator qui permet de lire
un flux (fichier ou chane de caractres par exemple) mot par mot en dfinissant le
dlimiteur entre les mots (espace par dfaut).
La lecture de donnes partir dun flux dentre suit le droulement suivant :
1. Ouverture duflux : Elle se produit la crationdunobjet de la classe InputStream. Lors de
lappel au constructeur, on doit prciser quel lement externe est reli au flux (par exemple
un nom de fichier ou un autre flux).
2. Lecture de donnes : Des donnes provenant du flux sont lues au moyen de la mthode
read()) ou dune mthode quivalente. La mthode prcise employer dpend du type de
flux ouvert.
3. Fermeture du flux : Quand le flux nest plus ncessaire, il doit tre ferm par la mthode
close().
33
Chapitre 6. Gestion des entres/sorties simples
6.1.1 Lecture des entres clavier
Les donnes provenant de lutilisation du clavier sont transmises dans un flux dentre cr
automatiquement pour toute application Java. On accde ce flux par la variable statique de la
classe java.lang.System qui sappelle in. Ce flux est alors utilis comme paramtre dentre du
constructeur dun autre flux dentre. Pour cet autre flux, on utilise gnralement une sous-classe
de Reader pour rcuprer les entres de lutilisateur sous la forme dune chane de caractres. La
classe Clavier en donne un exemple :
import java.io.*;
public class Clavier {
try {
BufferedReader flux = new BufferedReader(
new InputStreamReader(System.in));
System.out.print("Entrez votre prenom : ");
String prenom = flux.readLine();
System.out.println("Bonjour " + prenom);
flux.close();
} catch (IOException ioe) {
System.err.println(ioe);
}
}
}
6.1.2 Lecture partir dun fichier
Un fichier est reprsent par un objet de la classe java.io.File. Le constructeur de cette
classe prend en paramtre dentre le chemin daccs du fichier. Le flux dentre est alors cr
laide de la classe FileInputStream sur lequel on peut lire caractre par caractre grce la
mthode read(). Lexemple suivant prsente une mthode pour afficher le contenu dun fichier :
34
6.1. Flux dentre
import java.io.*;
public class LectureFichier {
try {
File fichier = new File("monFichier.txt");
FileInputStream flux = new FileInputStream(fichier);
int c;
while ((c = flux.read()) > -1) {
System.out.write(c);
}
flux.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
Il arrive souvent denregistrer des donnes dans des fichiers textes. Il peut alors tre utile duti-
liser un BufferedReader ou un Scanner pour effectuer la lecture. Dans les exemples suivants, on
considre une matrice I0 I0 enregistre dans un fichier texte matrice.txt ligne par ligne, avec
les colonnes spares par des espaces :
import java.io.*;
public class LectureMatrice {
try {
FileReader fileReader = new FileReader("matrice.txt");
BufferedReader reader = new BufferedReader(fileReader);
while (reader.ready()) {
String[] line = reader.readLine().split(" ");
for (String s : line) {
System.out.print(s);
}
System.out.println();
}
reader.close();
fileReader.close();
}
}
}
35
On peut effectuer un traitement similaire avec un Scanner :
import java.io.*;
import java.util.Scanner;
public class LectureMatriceScanner {
try {
Scanner fileScanner = new Scanner(new File("matrice.txt"));
while (fileScanner.hasNextLine()) {
Scanner lineScanner = new Scanner(fileScanner.nextLine());
while (lineScanner.hasNext())
System.out.print(lineScanner.next());
System.out.println();
}
}
}
}
6.1.3 Lecture dobjets enregistrs
Il est parfois utile denregistrer ltat dobjet (de nimporte quelle classe implmentant les in-
terfaces java.io.Serializable ou java.io.Externalizable) pour des excutions futures. Le
flux dentre est encore cr laide de la classe FileInputStream et est ensuite encapsul dans un
autre flux spcifiant le format des donnes lire. Lexemple suivant illustre la lecture dun objet
de la classe Date dans un fichier nomm monFichier.dat :
import java.io.*;
public class LectureDate {
try {
File fichier = new File("monFichier.dat");
ObjectInputStream flux = new ObjectInputStream(
new FileInputStream(fichier));
Date laDate = (Date) flux.readObject();
System.out.println(laDate);
flux.close();
} catch (ClassNotFoundException cnfe) {
System.err.println(cnfe);
}
}
}
Lobjet qui est lu dans le fichier doit tre une instance de la classe java.util.Date.
36
6.2. Flux de sortie
6.2 Flux de sortie
Un flux de sortie est une instance dune sous-classe de OutputStream. Comme pour les flux
dentre, chaque classe de flux de sortie a son propre mode dcriture de donnes. Les classes les
plus couramment utilises sont :
ByteArrayOutputStream permet dcrire des octets vers le flux de sortie ;
DataOutputStream permet dcrire des types de donnes primitifs de Java vers le flux de
sortie.
FileOutputStream est utilis pour crire dans un fichier. Les objets de cette classe sont
souvent encapsuls dans un autre objet de classe OutputStream qui dfinit le format des
donnes crire.
ObjectOutputStreampermet dcrire des objets (c--d des instances de classes Java) vers le
flux de sortie, si ces objets implmentent les interfaces Serializable ou Externalizable.
Writer nest pas une sous-classe de OutputStream mais reprsente un flux de sortie pour
chanes de caractres. Plusieurs sous-classes de Writer permettent la cration de flux pour
chanes de caractres.
Lcriture de donnes vers un flux de sortie suit le mme droulement que la lecture dun flux
dentre :
1. Ouverture du flux : Elle se produit lors de la cration dun objet de la classe OutputStream.
2. Ecriture de donnes : Des donnes sont crites vers le flux aumoyende la mthode write()
ou dune mthode quivalente. La mthode prcise employer dpend du type de flux ou-
vert.
3. Fermeture du flux : Quand le flux nest plus ncessaire, il doit tre ferm par la mthode
close().
6.2.1 Ecriture sur la sortie standard cran
Comme pour les entres du clavier, lcriture vers lcran fait appel la variable statique out de
la classe System. Onappelle gnralement la mthode System.out.print ouSystem.out.println
comme cela a t fait dans de nombreux exemples de ce livret.
6.2.2 Ecriture dans un fichier
Lcriture dans un fichier se fait par un flux de la classe FileOutputStream qui prend en
entre un fichier (instance de la classe File). Ce flux de sortie permet dcrire des caractres dans
le fichier grce la mthode write(). Lexemple suivant prsente une mthode pour crire un
texte dans un fichier :
37
import java.io.*;
public class EcritureFichier {
try {
File fichier = new File("monFichier.txt");
FileOutputStream flux = new FileOutputStream(fichier);
String texte = "Hello World!";
for (int i = 0; i < texte.length(); i++) {
flux.write(texte.charAt(i));
}
flux.close();
}
}
}
On peut galement utiliser un Writer comme un FileWriter pour crire des chanes de
caractres dans un fichier assez simplement. Dans lexemple suivant, on crit une srie de I0
lignes de I0 entiers alatoires spars par des espaces dans un fichier pouvant tre lu par la classe
LectureMatrice :
import java.io.*;
import java.util.Random;
public class EcritureMatrice {
try {
FileWriter writer = new FileWriter("random.txt");
Random generator = new Random(System.currentTimeMillis());
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++)
writer.write(generator.nextInt() + " ");
writer.write("\n");
}
writer.close();
}
}
}
38
6.2. Flux de sortie
6.2.3 Ecriture dobjets
Le flux de sortie peut galement tre encapsul dans un flux de type ObjectOutputStream,
comme le montre lexemple suivant pour crire la date courante dans un fichier :
import java.io.*;
public class EcritureDate {
try {
File fichier = new File("monFichier.dat");
ObjectOutputStream flux = new ObjectOutputStream(
new FileOutputStream(fichier));
flux.writeObject(new Date());
flux.close();
}
}
}
Ce fichier peut ensuite tre lu par la classe LectureDate.
Remarque importante : Nous avons prsent dans ce chapitre plusieurs exemples dentre/-
sortie utilisant diffrents modes de lecture/criture (avec ousans flux). Nous conseillons toutefois
dutiliser en priorit un Scanner pour la lecture dans un fichier, et un FileWriter pour lcriture
dans un fichier.
39
40
Annexes
41
Annexe A
Applications graphiques (package swing)
Annexe
Lors des premires versions du langage Java, le seul package fourni par dfaut par Java SE
permettant de construire des interfaces graphiques tait le package java.awt. Depuis la version
1.1 du JDK, il est trs fortement recommand dutiliser les classes du package javax.swing pour
crire des interfaces graphiques. En effet, le package swing apporte deux avantages conceptuels
par rapport au package awt :
Les composants swing sont dits lgers (lightweight) contrairement aux composants lourd-
s (heavyweight) dawt. Lapparence graphique dun composant dit lourd dpend du sys-
tme dexploitation car elle fait appel un composant correspondant dans le systme dex-
ploitation. Avec un composant lger, son apparence (look-and-feel) est fixe et peut tre
modifie dans le code Java et il est donc possible de donner une fentre une apparence
la Windows tout en utilisant Linux.
Il applique compltement le schma Modle-Vue-Contrleur (cf. section A.1).
La plupart des classes de composants du package swing hritent de classes du package awt
en redfinissant certaines mthodes pour assurer les deux avantages prcdemment cits. Cepen-
dant, le package awt nest pas entirement obsolte et certaines de ces classes sont encore utilises
pour la gestion dvnements (cf. section A.3) ou la disposition des composants (classes impl-
mentant linterface LayoutManager).
A.1 Le schma Modle-Vue-Contrleur
Le schma Modle-Vue-Contrleur (MVC) est un mode de conception dapplications gra-
phiques prconisant la distinction des donnes, de leur apparence graphique et des traitements
qui peuvent tre effectus. Un composant graphique est dcompos en trois parties :
le modle contenant ses donnes et son tat courant ;
la vue qui correspond son apparence graphique ;
le contrleur associant des traitements des vnements pouvant se produire au sein du
composant.
La figure A.1 donne unexemple dune interface graphique simple contenant unboutonQuitter.
la dcomposition MVC de ce bouton (instance de la classe JButton) est constitue : (i) du
modle contenant la chane de caractres Quitter ; (ii) de la vue constitue dun rectangle gris
bord noir, dune taille donne, une position donne et au sein duquel est crite la chane de
caractres du modle ; (iii) du contrleur implmentant le traitement effectuer lors dun click
sur le bouton, cest--dire lappel linstruction de fermeture de la fentre.
Tous les composants graphiques du package swing ont un modle, une vue et peuvent avoir
plusieurs contrleurs. Pour faciliter la programmation, certaines classes (tel que JButton) encap-
sulent le modle et la vue dans une seule classe disposant de mthodes daccs et de modifications
43
Annexe A. Applications graphiques (package swing)
Figure A.1 Exemple de JButton
des donnes ou de lapparence. Dans ces cas-l, un modle par dfaut est utilis.
A.2 Composants graphiques
Dans un programme Java, une classe de composant graphique est une classe qui hrite de
java.awt.Component. Il est indispensable dhriter de cette classe car elle implmente de nom-
breuses mthodes ncessaires laffichage du composant, en renvoyant la dimension du compo-
sant, sa police de caractres, sa couleur de fond, etc.
La seconde classe essentielle pour lcriture dinterfaces graphiques est la classe Container.
Un container est un composant (qui hrite donc de Component) mais avec la particularit de pou-
voir contenir dautres composants. Ainsi, une interface graphique est un objet dune classe de
type java.awt.Container (par exemple une fentre ou une bote de dialogue) regroupant des
simples composants et dautres containers qui, eux aussi, contiennent dautres simples compo-
sants et containers, et ainsi de suite.
A.2.1 Composants
Nous ne prsentons pas ici toutes les classes de composants du package swing pour nous in-
tresser plutt la vue et au modle de chaque composant. Lutilisation de certains composants
est illustre dans la section A.2.3.
Vue
Lapparence graphique dun composant est le rsultat de limplmentation de la mthode
paint() de la classe Component. Quasiment toutes les classes hritant de Component redfinissent
cette mthode afin de dfinir laffichage du composant. Si vous crivez une classe hritant dune
classe de composant existante, il est donc fortement dconseill de redfinir la mthode paint
pour la plupart des composants existants car vous empcheriez son affichage normal.
Si vous souhaitez dfinir laffichage dun composant personnalis (par exemple pour afficher
une image ou des formes gomtriques), vous devrez faire hriter votre classe de composant de la
classe java.awt.Canvas qui reprsente un composant vide. Dans ce cas-l, il est souhaitable de
redfinir la mthode paint() qui est vide dans la classe Canvas.
Modle
Il existe pour chaque classe de composant, une seconde classe qui gre le modle de ce com-
posant (par exemple, ButtonModel reprsente un modle de bouton). En gnral un modle par
dfaut est cr dans le constructeur du composant. Laccs ce modle est trs souvent masqu car
il existe des mthodes, telles que setText() pour changer le texte dun bouton ou setSelected()
pour changer ltat dune case cocher, de la classe de composant qui peuvent tre directement
appeles pour changer les donnes du modle. Cependant, pour des composants plus complexes
44
A.2. Composants graphiques
tels que des tables (JTable) ou des arborescences (JTree), il est parfois indispensable de crer un
modle personnalis.
A.2.2 Containers
En premier lieu, il convient de rappeler quun container est un composant, et, par consquent,
que tout ce qui a t prsent prcdemment est aussi vrai pour les containers. En plus des ca-
ractristiques dun composant simple, un container contient un ensemble de composants ainsi
que des contraintes sur leur disposition. Lajout dun composant un container se fait par une
mthode add(). Il existe plusieurs mthodes add() acceptant des paramtres dentre diffrents.
La mthode utiliser dpend du type de disposition choisi.
Disposition des composants
Lobjet qui gre la disposition des composants est une instance dune classe qui doit impl-
menter linterface java.awt.LayoutManager. Cet objet doit tre ajout au container, soit lors de
lappel son constructeur, soit par la mthode setLayout(). Un seul LayoutManager est auto-
ris par container. Quelques classes utilises pour la disposition des composants sont prsentes
ci-dessous.
BorderLayout. Le container est dcoup en cinq cases : une case par ct (gauche, droite, haut
et bas) et une au centre. Lajout dun composant se fait en prcisant la case utiliser grce des
variables de classe de BorderLayout :
MyContainer.add(MyComponent,BorderLayout.NORTH);
MyContainer.add(MyComponent2,BorderLayout.CENTER);
La taille de chaque case dpend : (i) de la largeur maximale entre la case du nord, du sud et
laddition des largeurs des cases du centre, de lest et de louest ; (ii) de la hauteur maximale entre
la case lest, louest et laddition des hauteurs des cases du centre, du nord et du sud. La case
du centre est tire pour remplir tout lespace restant.
BorderLayout.NORTH
BorderLayout.CENTER
BorderLayout.SOUTH
BorderLayout.WEST BorderLayout.EAST
Figure A.2 Dcoupage du BorderLayout
45
Comp1 ... Comp2 Comp3
Figure A.3 Dcoupage du FlowLayout
Comp6 Comp5 Comp8
Comp10 Comp9 Comp12
Comp7
Comp11
Comp2 Comp1 Comp4 Comp3
Figure A.4 Dcoupage dun GridLayout 3x4
FlowLayout. Les composants sont ajouts les uns la suite des autres et de la gauche vers la
droite. Ds quune ligne est remplie de composants (cest--dire ds que la largeur du container
est atteinte, les composants restants sont ajouts sur une ligne en dessous. Il ny a pas dautres
contraintes de disposition :
MyContainer.add(MyComponent);
GridLayout. Le container est dcoup enune grille compose de ncases de taille gale. Le construc-
teur du GridLayout requiert en paramtres dentre le nombre de lignes et le nombre de colonnes
de la grille. Les composants sont ajouts les uns la suite des autres en remplissant dabord la
premire ligne, puis la seconde, etc. Il ny a pas dautres contraintes de disposition :
MyContainer.add(MyComponent);
Containers classiques
La classe de container la plus simple est javax.swing.JPanel. Un panel est un composant
initialement vide auquel on va ajouter des composants suivant la disposition choisie. La dispo-
sition peut tre spcifie lors de lappel au constructeur du panel (par ex, JPanel myPanel =
new JPanel(new BorderLayout());) ou par un appel explicite la mthode setLayout, par
exemple :
myPanel.setLayout(new GridLayout(4,5));
Les composants peuvent ensuite tre ajouts avec la mthode add() approprie.
Une interface graphique consiste donc en une hirarchie de composants telle que certains
composants sont des containers spcifiant la disposition dautres composants. La racine de cette
46
hirarchie est galement un container qui peut safficher librement (c--d. sans que sa disposi-
tion soit prcise dans un container). Parmi ces containers de haut niveau, on trouve la classe
javax.swing.JFrame qui reprsente une fentre et javax.swing.JDialog qui reprsente une
bote de dialogue. La cration dune fentre suit gnralement les tapes suivantes :
1. Cration dune instance de JFrame (ou dune sous-classe).
2. Ajout des composants au panel de la fentre. Ce panel est accessible par la mthode
getContentPane(). On peut galement attribuer la fentre un nouveau panel par la m-
thode setContentPane().
3. Calcul de la taille de la fentre laide de la mthode pack(). Ce calcul est automatique et
prend en compte la dimension prferre de chaque composant ainsi que leur disposition.
4. Affichage de la fentre par la mthode setVisible().
Par exemple, la figure A.1 (p. 44) est une instance dune sous-classe de JFrame :
import java.awt.*;
import javax.swing.*;
public class ExBouton extends JFrame {
public ExBouton() {
super();
JLabel label = new JLabel("Exemple de bouton");
JPanel panel = new JPanel(new BorderLayout());
panel.add(label, BorderLayout.NORTH);
JButton b = new JButton(" Quitter ");
panel.add(b, BorderLayout.SOUTH);
this.setContentPane(panel);
this.pack();
}
ExBouton bouton = new ExBouton();
bouton.setVisible(true);
}
}
A.2.3 Exemple dinterface
Le meilleur moyen dapprendre crire des interfaces graphiques est de sinspirer dexemples
dinterfaces existantes. La figure A.5 est un exemple de fentre produit avec le code suivant la
figure.
47
Figure A.5 Exemple dinterface graphique
48
i
m
p
o
r
t
j
a
v
a
.
a
w
t
.
*
;
i
m
p
o
r
t
j
a
v
a
.
u
t
i
l
.
V
e
c
t
o
r
;
i
m
p
o
r
t
j
a
v
a
x
.
s
w
i
n
g
.
*
;
i
m
p
o
r
t
j
a
v
a
x
.
s
w
i
n
g
.
b
o
r
d
e
r
.
E
m
p
t
y
B
o
r
d
e
r
;
p
u
b
l
i
c
c
l
a
s
s
E
x
I
n
t
e
r
f
a
c
e
e
x
t
e
n
d
s
J
F
r
a
m
e
{
/
*
*
*
L
e
s
v
a
r
i
a
b
l
e
s
p
o
i
n
t
a
n
t
c
h
a
q
u
e
c
o
m
p
o
s
a
n
t
s
o
n
t
d
e
c
l
a
r
e
e
s
*
e
n
v
a
r
i
a
b
l
e
s
d
'
i
n
s
t
a
n
c
e
e
t
e
n
t
y
p
e
p
r
o
t
e
c
t
e
d
.
E
l
l
e
s
*
a
u
r
a
i
e
n
t
t
r
e
s
b
i
e
n
p
u
e
t
r
e
d
e
s
v
a
r
i
a
b
l
e
s
l
o
c
a
l
e
s
a
u
*
c
o
n
s
t
r
u
c
t
e
u
r
m
a
i
s
,
p
o
u
r
d
e
s
r
a
i
s
o
n
s
p
e
d
a
g
o
g
i
q
u
e
s
,
*
l
a
g
e
s
t
i
o
n
d
e
s
e
v
e
n
e
m
e
n
t
s
n
'
e
s
t
p
r
e
s
e
n
t
e
e
q
u
e
p
l
u
s
*
t
a
r
d
(
s
e
c
t
i
o
n
e
v
e
n
t
s
)
d
a
n
s
u
n
e
c
l
a
s
s
e
h
e
r
i
t
a
n
t
*
d
e
E
x
I
n
t
e
r
f
a
c
e
.
L
e
s
v
a
r
i
a
b
l
e
s
s
o
n
t
d
e
t
y
p
e
p
r
o
t
e
c
t
e
d
*
a
f
i
n
d
e
p
o
u
v
o
i
r
y
a
c
c
d
e
r
d
a
n
s
c
e
t
t
e
s
o
u
s
-
c
l
a
s
s
e
.
*
/
p
r
o
t
e
c
t
e
d
J
R
a
d
i
o
B
u
t
t
o
n
b
u
t
t
o
n
1
,
b
u
t
t
o
n
2
,
b
u
t
t
o
n
3
;
p
r
o
t
e
c
t
e
d
J
C
o
m
b
o
B
o
x
c
o
u
l
e
u
r
;
p
r
o
t
e
c
t
e
d
J
T
e
x
t
F
i
e
l
d
t
e
x
t
;
p
r
o
t
e
c
t
e
d
J
B
u
t
t
o
n
a
j
o
u
t
;
p
r
o
t
e
c
t
e
d
J
L
i
s
t
t
e
x
t
L
i
s
t
;
p
r
o
t
e
c
t
e
d
V
e
c
t
o
r
<
S
t
r
i
n
g
>
l
i
s
t
D
a
t
a
;
p
r
o
t
e
c
t
e
d
D
e
s
s
i
n
d
e
s
s
i
n
;
p
u
b
l
i
c
E
x
I
n
t
e
r
f
a
c
e
(
)
{
s
u
p
e
r
(
"
U
n
e
x
e
m
p
l
e
d
e
f
e
n
e
t
r
e
"
)
;
/
/
l
e
p
r
o
g
r
a
m
m
e
d
o
i
t
s
e
t
e
r
m
i
n
e
r
q
u
a
n
d
l
a
f
e
n
e
t
r
e
e
s
t
f
e
r
m
e
e
t
h
i
s
.
s
e
t
D
e
f
a
u
l
t
C
l
o
s
e
O
p
e
r
a
t
i
o
n
(
J
F
r
a
m
e
.
E
X
I
T
_
O
N
_
C
L
O
S
E
)
;
/
/
c
r
e
a
t
i
o
n
d
u
p
a
n
e
l
g
a
u
c
h
e
J
P
a
n
e
l
g
a
u
c
h
e
=
n
e
w
J
P
a
n
e
l
(
n
e
w
G
r
i
d
L
a
y
o
u
t
(
6
,
1
,
0
,
5
)
)
;
/
/
c
r
e
a
t
i
o
n
d
e
s
c
a
s
e
s
a
c
o
c
h
e
r
J
L
a
b
e
l
l
a
b
e
l
=
n
e
w
J
L
a
b
e
l
(
"
F
o
r
m
e
:
"
)
;
b
u
t
t
o
n
1
=
n
e
w
J
R
a
d
i
o
B
u
t
t
o
n
(
"
C
a
r
r
e
"
,
t
r
u
e
)
;
b
u
t
t
o
n
2
=
n
e
w
J
R
a
d
i
o
B
u
t
t
o
n
(
"
C
e
r
c
l
e
"
,
f
a
l
s
e
)
;
b
u
t
t
o
n
3
=
n
e
w
J
R
a
d
i
o
B
u
t
t
o
n
(
"
T
r
i
a
n
g
l
e
"
,
f
a
l
s
e
)
;
J
L
a
b
e
l
l
a
b
e
l
2
=
n
e
w
J
L
a
b
e
l
(
"
C
o
u
l
e
u
r
:
"
)
;
c
o
u
l
e
u
r
=
n
e
w
J
C
o
m
b
o
B
o
x
(
)
;
c
o
u
l
e
u
r
.
a
d
d
I
t
e
m
(
"
B
l
e
u
"
)
;
c
o
u
l
e
u
r
.
a
d
d
I
t
e
m
(
"
R
o
u
g
e
"
)
;
c
o
u
l
e
u
r
.
a
d
d
I
t
e
m
(
"
V
e
r
t
"
)
;
/
/
l
e
g
r
o
u
p
e
d
e
b
o
u
t
o
n
p
e
r
m
e
t
d
'
i
n
t
e
r
d
i
r
e
l
a
s
e
l
e
c
t
i
o
n
/
/
d
e
p
l
u
s
i
e
u
r
s
c
a
s
e
s
e
n
m
e
m
e
t
e
m
p
s
B
u
t
t
o
n
G
r
o
u
p
g
r
o
u
p
=
n
e
w
B
u
t
t
o
n
G
r
o
u
p
(
)
;
g
r
o
u
p
.
a
d
d
(
b
u
t
t
o
n
1
)
;
g
r
o
u
p
.
a
d
d
(
b
u
t
t
o
n
2
)
;
g
r
o
u
p
.
a
d
d
(
b
u
t
t
o
n
3
)
;
/
/
r
e
m
p
l
i
s
s
a
g
e
d
u
p
a
n
e
l
g
a
u
c
h
e
g
a
u
c
h
e
.
a
d
d
(
l
a
b
e
l
)
;
g
a
u
c
h
e
.
a
d
d
(
b
u
t
t
o
n
1
)
;
g
a
u
c
h
e
.
a
d
d
(
b
u
t
t
o
n
2
)
;
g
a
u
c
h
e
.
a
d
d
(
b
u
t
t
o
n
3
)
;
g
a
u
c
h
e
.
a
d
d
(
l
a
b
e
l
2
)
;
g
a
u
c
h
e
.
a
d
d
(
c
o
u
l
e
u
r
)
;
/
/
c
r
e
a
t
i
o
n
d
u
p
a
n
e
l
b
a
s
J
P
a
n
e
l
b
a
s
=
n
e
w
J
P
a
n
e
l
(
n
e
w
B
o
r
d
e
r
L
a
y
o
u
t
(
0
,
1
0
)
)
;
/
/
c
r
e
a
t
i
o
n
e
t
r
e
m
p
l
i
s
s
a
g
e
d
u
p
a
n
e
l
d
'
a
j
o
u
t
d
e
t
e
x
t
e
J
P
a
n
e
l
t
e
x
t
P
a
n
e
l
=
n
e
w
J
P
a
n
e
l
(
n
e
w
G
r
i
d
L
a
y
o
u
t
(
3
,
1
,
0
,
5
)
)
;
l
a
b
e
l
=
n
e
w
J
L
a
b
e
l
(
"
A
j
o
u
t
e
r
u
n
t
e
x
t
e
p
o
s
s
i
b
l
e
:
"
)
;
t
e
x
t
P
a
n
e
l
.
a
d
d
(
l
a
b
e
l
)
;
t
e
x
t
=
n
e
w
J
T
e
x
t
F
i
e
l
d
(
1
6
)
;
t
e
x
t
P
a
n
e
l
.
a
d
d
(
t
e
x
t
)
;
a
j
o
u
t
=
n
e
w
J
B
u
t
t
o
n
(
"
A
j
o
u
t
e
r
"
)
;
t
e
x
t
P
a
n
e
l
.
a
d
d
(
a
j
o
u
t
)
;
/
/
c
r
e
a
t
i
o
n
d
u
m
o
d
e
l
e
d
e
l
a
l
i
s
t
e
l
i
s
t
D
a
t
a
=
n
e
w
V
e
c
t
o
r
<
S
t
r
i
n
g
>
(
)
;
l
i
s
t
D
a
t
a
.
a
d
d
E
l
e
m
e
n
t
(
"
H
e
l
l
o
W
o
r
l
d
"
)
;
l
i
s
t
D
a
t
a
.
a
d
d
E
l
e
m
e
n
t
(
"
U
n
e
b
e
l
l
e
f
i
g
u
r
e
"
)
;
l
i
s
t
D
a
t
a
.
a
d
d
E
l
e
m
e
n
t
(
"
C
h
a
m
p
i
o
n
s
d
u
m
o
n
d
e
!
"
)
;
l
i
s
t
D
a
t
a
.
a
d
d
E
l
e
m
e
n
t
(
"
A
c
i
a
o
,
b
o
n
s
o
i
r
.
.
.
"
)
;
l
i
s
t
D
a
t
a
.
a
d
d
E
l
e
m
e
n
t
(
"
C
h
a
n
g
e
z
l
a
c
o
u
l
e
u
r
"
)
;
l
i
s
t
D
a
t
a
.
a
d
d
E
l
e
m
e
n
t
(
"
J
'
a
d
o
r
e
J
a
v
a
"
)
;
l
i
s
t
D
a
t
a
.
a
d
d
E
l
e
m
e
n
t
(
"
A
l
l
e
z
l
e
s
v
e
r
t
s
!
"
)
;
l
i
s
t
D
a
t
a
.
a
d
d
E
l
e
m
e
n
t
(
"
C
a
m
a
r
c
h
e
"
)
;
l
i
s
t
D
a
t
a
.
a
d
d
E
l
e
m
e
n
t
(
"
b
l
a
b
l
a
b
l
a
"
)
;
/
/
c
r
e
a
t
i
o
n
d
e
l
a
l
i
s
t
e
t
e
x
t
L
i
s
t
=
n
e
w
J
L
i
s
t
(
l
i
s
t
D
a
t
a
)
;
t
e
x
t
L
i
s
t
.
s
e
t
S
e
l
e
c
t
i
o
n
M
o
d
e
(
L
i
s
t
S
e
l
e
c
t
i
o
n
M
o
d
e
l
.
S
I
N
G
L
E
_
S
E
L
E
C
T
I
O
N
)
;
/
/
l
'
i
n
c
l
u
s
i
o
n
d
e
l
a
l
i
s
t
e
d
a
n
s
u
n
J
S
c
r
o
l
l
P
a
n
e
p
e
r
m
e
t
/
/
d
e
l
a
f
a
i
r
e
d
e
f
i
l
e
r
p
a
r
d
e
s
a
s
c
e
n
c
e
u
r
s
J
S
c
r
o
l
l
P
a
n
e
s
c
r
o
l
l
P
a
n
e
=
n
e
w
J
S
c
r
o
l
l
P
a
n
e
(
t
e
x
t
L
i
s
t
)
;
s
c
r
o
l
l
P
a
n
e
.
s
e
t
P
r
e
f
e
r
r
e
d
S
i
z
e
(
n
e
w
D
i
m
e
n
s
i
o
n
(
2
0
0
,
1
0
0
)
)
;
/
/
r
e
m
p
l
i
s
s
a
g
e
d
u
p
a
n
e
l
b
a
s
49
b
a
s
.
a
d
d
(
s
c
r
o
l
l
P
a
n
e
,
B
o
r
d
e
r
L
a
y
o
u
t
.
N
O
R
T
H
)
;
b
a
s
.
a
d
d
(
t
e
x
t
P
a
n
e
l
,
B
o
r
d
e
r
L
a
y
o
u
t
.
S
O
U
T
H
)
;
/
/
r
e
m
p
l
i
s
s
a
g
e
d
u
p
a
n
e
l
p
r
i
n
c
i
p
a
l
J
P
a
n
e
l
m
a
i
n
P
a
n
e
l
=
(
J
P
a
n
e
l
)
t
h
i
s
.
g
e
t
C
o
n
t
e
n
t
P
a
n
e
(
)
;
m
a
i
n
P
a
n
e
l
.
s
e
t
L
a
y
o
u
t
(
n
e
w
B
o
r
d
e
r
L
a
y
o
u
t
(
1
0
,
1
0
)
)
;
m
a
i
n
P
a
n
e
l
.
a
d
d
(
g
a
u
c
h
e
,
B
o
r
d
e
r
L
a
y
o
u
t
.
W
E
S
T
)
;
d
e
s
s
i
n
=
n
e
w
D
e
s
s
i
n
(
)
;
m
a
i
n
P
a
n
e
l
.
a
d
d
(
d
e
s
s
i
n
,
B
o
r
d
e
r
L
a
y
o
u
t
.
C
E
N
T
E
R
)
;
m
a
i
n
P
a
n
e
l
.
a
d
d
(
b
a
s
,
B
o
r
d
e
r
L
a
y
o
u
t
.
S
O
U
T
H
)
;
/
/
u
n
e
b
o
r
d
u
r
e
p
e
r
m
e
t
d
'
a
e
r
e
r
l
'
a
f
f
i
c
h
a
g
e
m
a
i
n
P
a
n
e
l
.
s
e
t
B
o
r
d
e
r
(
n
e
w
E
m
p
t
y
B
o
r
d
e
r
(
1
0
,
1
0
,
1
0
,
1
0
)
)
;
/
/
c
a
l
c
u
l
d
e
l
a
d
i
m
e
n
s
i
o
n
d
e
l
a
f
e
n
e
t
r
e
t
h
i
s
.
p
a
c
k
(
)
;
}p
u
b
l
i
c
s
t
a
t
i
c
v
o
i
d
m
a
i
n
(
S
t
r
i
n
g
[
]
a
r
g
s
)
{
E
x
I
n
t
e
r
f
a
c
e
m
y
I
n
t
e
r
f
a
c
e
=
n
e
w
E
x
I
n
t
e
r
f
a
c
e
(
)
;
m
y
I
n
t
e
r
f
a
c
e
.
s
e
t
V
i
s
i
b
l
e
(
t
r
u
e
)
;
}
}/
/
C
e
t
t
e
c
l
a
s
s
e
h
e
r
i
t
e
d
e
c
a
n
v
a
s
p
o
u
r
r
e
d
f
i
n
i
r
l
a
/
/
m
e
t
h
o
d
e
p
a
i
n
t
.
L
a
v
u
e
e
s
t
c
o
d
e
e
d
a
n
s
c
e
t
t
e
c
l
a
s
s
e
c
l
a
s
s
D
e
s
s
i
n
e
x
t
e
n
d
s
C
a
n
v
a
s
{
S
t
r
i
n
g
f
i
g
u
r
e
;
C
o
l
o
r
c
o
u
l
e
u
r
;
S
t
r
i
n
g
t
e
x
t
;
/
/
l
e
c
o
n
s
t
r
u
c
t
e
u
r
d
e
l
a
c
l
a
s
s
e
p
u
b
l
i
c
D
e
s
s
i
n
(
)
{
f
i
g
u
r
e
=
"
C
a
r
r
e
"
;
c
o
u
l
e
u
r
=
C
o
l
o
r
.
b
l
u
e
;
t
e
x
t
=
"
H
e
l
l
o
W
o
r
l
d
"
;
t
h
i
s
.
s
e
t
B
a
c
k
g
r
o
u
n
d
(
C
o
l
o
r
.
w
h
i
t
e
)
;
}p
u
b
l
i
c
v
o
i
d
p
a
i
n
t
(
G
r
a
p
h
i
c
s
g
)
{
/
/
u
n
r
e
c
t
a
n
g
l
e
n
o
i
r
e
n
c
a
d
r
e
l
e
c
o
m
p
o
s
a
n
t
g
.
s
e
t
C
o
l
o
r
(
C
o
l
o
r
.
b
l
a
c
k
)
;
g
.
d
r
a
w
R
e
c
t
(
0
,
0
,
t
h
i
s
.
g
e
t
W
i
d
t
h
(
)
-
1
,
t
h
i
s
.
g
e
t
H
e
i
g
h
t
(
)
-
1
)
;
/
/
l
e
t
e
x
t
e
e
s
t
a
f
f
i
c
h
e
g
.
d
r
a
w
S
t
r
i
n
g
(
t
e
x
t
,
1
0
,
1
5
)
;
/
/
l
a
c
o
u
l
e
u
r
e
s
t
c
h
o
i
s
i
e
g
.
s
e
t
C
o
l
o
r
(
c
o
u
l
e
u
r
)
;
/
/
l
a
f
i
g
u
r
e
e
s
t
a
f
f
i
c
h
e
e
i
f
(
f
i
g
u
r
e
.
e
q
u
a
l
s
(
"
C
a
r
r
e
"
)
)
{
g
.
d
r
a
w
R
e
c
t
(
5
0
,
3
0
,
1
0
0
,
1
0
0
)
;
}
e
l
s
e
i
f
(
f
i
g
u
r
e
.
e
q
u
a
l
s
(
"
C
e
r
c
l
e
"
)
)
{
g
.
d
r
a
w
O
v
a
l
(
5
0
,
3
0
,
1
0
0
,
1
0
0
)
;
}
e
l
s
e
{
g
.
d
r
a
w
L
i
n
e
(
5
0
,
1
3
0
,
1
0
0
,
3
0
)
;
g
.
d
r
a
w
L
i
n
e
(
1
0
0
,
3
0
,
1
5
0
,
1
3
0
)
;
g
.
d
r
a
w
L
i
n
e
(
5
0
,
1
3
0
,
1
5
0
,
1
3
0
)
;
}
}/
/
c
e
s
m
e
t
h
o
d
e
s
p
e
r
m
e
t
t
e
n
t
d
e
c
h
a
n
g
e
r
l
e
t
e
x
t
e
,
/
/
l
a
c
o
u
l
e
u
r
o
u
l
a
f
i
g
u
r
e
a
a
f
f
i
c
h
e
r
p
u
b
l
i
c
v
o
i
d
s
e
t
T
e
x
t
(
S
t
r
i
n
g
t
x
t
)
{
t
e
x
t
=
t
x
t
;
}p
u
b
l
i
c
v
o
i
d
s
e
t
C
o
u
l
e
u
r
(
S
t
r
i
n
g
c
o
u
l
)
{
i
f
(
c
o
u
l
.
e
q
u
a
l
s
(
"
B
l
e
u
"
)
)
{
c
o
u
l
e
u
r
=
C
o
l
o
r
.
b
l
u
e
;
}
e
l
s
e
i
f
(
c
o
u
l
.
e
q
u
a
l
s
(
"
R
o
u
g
e
"
)
)
{
c
o
u
l
e
u
r
=
C
o
l
o
r
.
r
e
d
;
}
e
l
s
e
{
c
o
u
l
e
u
r
=
C
o
l
o
r
.
g
r
e
e
n
;
}
}p
u
b
l
i
c
v
o
i
d
s
e
t
F
i
g
u
r
e
(
S
t
r
i
n
g
f
i
g
)
{
f
i
g
u
r
e
=
f
i
g
;
}/
/
L
a
r
e
d
f
i
n
i
t
i
o
n
d
e
c
e
t
t
e
m
e
t
h
o
d
e
p
e
r
m
e
t
d
e
s
p
e
c
i
f
i
e
r
/
/
l
a
t
a
i
l
l
e
p
r
e
f
e
r
r
e
e
d
u
c
o
m
p
o
s
a
n
t
p
u
b
l
i
c
D
i
m
e
n
s
i
o
n
g
e
t
P
r
e
f
e
r
r
e
d
S
i
z
e
(
)
{
r
e
t
u
r
n
n
e
w
D
i
m
e
n
s
i
o
n
(
2
0
0
,
2
0
0
)
;
}
}
50
A.3. Contrleurs dvnements
A.3 Contrleurs dvnements
Le rle des contrleurs est dintercepter certains vnements et deffectuer un traitement as-
soci au type de lvnement. Un vnement peut tre produit par un click sur un bouton, la
slection dun lment dune liste, un dplacement de souris, la pression dune touche du clavier,
etc.
A.3.1 Evnements
Un vnement graphique est reprsent dans le langage Java comme un objet dont la classe
hrite de java.awt.AWTEvent. Parmi les sous-classes de AWTEvent, on peut citer les plus couram-
ment utilises :
ActionEvent : Se produit lorsquune action est effectue sur un composant. Ex : click sur
un bouton.
ItemEvent : Se produit lorsquune slection a t effectue sur un composant. Ex : cochage
dune case.
KeyEvent : Se produit lorsque unvnement provient duclavier. Ex : pressiondune touche.
MouseEvent : Se produit lorsque un vnement provient de la souris. Ex : dplacement de
la souris.
WindowEvent : Se produit lorsquune action est effectue sur une fentre. Ex : click sur
licone de fermeture dune fentre.
Des mthodes sont attaches chacune de ces classes pour avoir accs plus de dtails sur
lvnement. On peut, par exemple, rcuprer le composant source de lvnement, la position de
la souris lors du click, etc.
A.3.2 Interface Listener
Le contrleur qui intercepte un certain type dvnement doit implmenter une des interfaces
hritant de java.util.EventListener. Linterface implmenter dpend du type dvnement
intercepter. La table A.1 prsente les interfaces correspondant aux vnements dcrits ci-dessus.
Certaines de ces interfaces demandent quun grand nombre de mthodes soient implmen-
tes (par ex, WindowListener). Des classes, appeles adapter, implmentant ces interfaces sont
proposes dans lAPI, pour lesquelles toutes les mthodes ont des implmentations vides. Cette
facilit de programmation permet de nimplmenter que la mthode souhaite. Par exemple, on
utilisera la classe WindowAdapter pour implmenter un traitement effectuer la fermeture dun
fentre (mthode windowClosing()) sans avoir crire des mthodes vides pour tous les autres
cas o aucun traitement nest requis.
Aprs la cration dun objet contrleur, il est ncessaire de le rattacher un ou plusieurs com-
posants. Le contrleur intercepte uniquement les vnements des composants auquel il est ratta-
ch. Cette opration se fait par lappel une mthode du composant de la forme add...Listener.
Par exemple, le rattachement dun contrleur myActionListener un bouton scrit :
myButton.addActionListener(myActionListener);
A.3.3 Exemple de contrleur
Dans lexemple donn plus loin, des traitements ont t associs aux diffrents composants
de linterface prsente en section A.2.3. Les contrleurs ont t volontairement crs de manire
diffrente pour illustrer plusieurs cas :
51
Table A.1 Quelques interfaces pour contrleur
Contrleur Evnement Mthodes implmenter
ActionListener ActionEvent - actionPerformed(ActionEvent)
ItemListener ItemEvent - itemStateChanged(ItemEvent)
KeyListener KeyEvent - keyPressed(KeyEvent)
- keyReleased(KeyEvent)
- keyTyped(KeyEvent)
MouseListener MouseEvent - mouseClicked(MouseEvent)
- mouseEntered(MouseEvent)
- mouseExited(MouseEvent)
- mousePressed(MouseEvent)
- mouseReleased(MouseEvent)
WindowListener WindowEvent - windowActivated(WindowEvent)
- windowClosed(WindowEvent)
- windowClosing(WindowEvent)
- windowDeactivated(WindowEvent)
- windowDeiconified(WindowEvent)
- windowIconified(WindowEvent)
- windowOpened(WindowEvent)
le contrleur de la fentre est un objet instanci partir dune classe WindowControler
qui hrite de la classe WindowAdapter. Le seul traitement qui est prcis est de quitter le
programme quand lutilisateur clique sur le bouton de fermeture.
le contrleur des boutons de choix est utilis sur plusieurs composants. Il traite les vne-
ments provenant des boutons JRadioButton et JComboBox. Ce contrleur est une instance
de ChoiceControler qui implmente linterface ItemListener. Le traitement effectu est
une mise jour du dessin.
le contrleur de la liste est en fait le mme objet que celui reprsentant la fentre. Cest la
classe ExControleur qui implmente linterface ListSelectionListener et met jour le
dessin chaque fois que la slection de la liste change.
le contrleur de la zone de texte est aussi implment par lobjet fentre. Si la touche en-
tre est presse dans la zone de texte, la liste est mise jour.
le contrleur du bouton a une forme un peu spciale mais frquemment utilise. Il est
possible, en Java, de redfinir une mthode dune classe pendant une instanciation. Lors de
linstanciation du contrleur (new ActionListener()), la mthode actionPerformed()
est redfinie directement avant le point virgule de fin dinstruction. Cest le seul cas o
linstanciation dune interface est permise si toutes ses mthodes sont implmentes.
52
A.3. Contrleurs dvnements
i
m
p
o
r
t
j
a
v
a
.
a
w
t
.
e
v
e
n
t
.
*
;
i
m
p
o
r
t
j
a
v
a
x
.
s
w
i
n
g
.
*
;
i
m
p
o
r
t
j
a
v
a
x
.
s
w
i
n
g
.
e
v
e
n
t
.
*
;
p
u
b
l
i
c
c
l
a
s
s
E
x
C
o
n
t
r
o
l
e
u
r
e
x
t
e
n
d
s
E
x
I
n
t
e
r
f
a
c
e
i
m
p
l
e
m
e
n
t
s
L
i
s
t
S
e
l
e
c
t
i
o
n
L
i
s
t
e
n
e
r
,
A
c
t
i
o
n
L
i
s
t
e
n
e
r
{
p
u
b
l
i
c
E
x
C
o
n
t
r
o
l
e
u
r
(
)
{
/
/
a
p
p
e
l
a
u
c
o
n
s
t
r
u
c
t
e
u
r
d
e
E
x
I
n
t
e
r
f
a
c
e
p
o
u
r
c
r
e
e
r
l
a
/
/
f
e
n
e
t
r
e
e
t
s
e
s
c
o
m
p
o
s
a
n
t
s
s
u
p
e
r
(
)
;
/
/
a
j
o
u
t
d
'
u
n
c
o
n
t
r
l
e
u
r
l
a
f
e
n
t
r
e
t
h
i
s
.
a
d
d
W
i
n
d
o
w
L
i
s
t
e
n
e
r
(
n
e
w
W
i
n
d
o
w
C
o
n
t
r
o
l
e
r
(
)
)
;
/
/
U
n
c
o
n
t
r
l
e
u
r
u
n
i
q
u
e
e
s
t
c
r
p
o
u
r
l
e
s
b
o
u
t
o
n
s
/
/
d
e
c
h
o
i
x
C
h
o
i
c
e
C
o
n
t
r
o
l
e
r
c
o
n
t
r
o
l
e
u
r
=
n
e
w
C
h
o
i
c
e
C
o
n
t
r
o
l
e
r
(
d
e
s
s
i
n
)
;
b
u
t
t
o
n
1
.
a
d
d
I
t
e
m
L
i
s
t
e
n
e
r
(
c
o
n
t
r
o
l
e
u
r
)
;
b
u
t
t
o
n
2
.
a
d
d
I
t
e
m
L
i
s
t
e
n
e
r
(
c
o
n
t
r
o
l
e
u
r
)
;
b
u
t
t
o
n
3
.
a
d
d
I
t
e
m
L
i
s
t
e
n
e
r
(
c
o
n
t
r
o
l
e
u
r
)
;
c
o
u
l
e
u
r
.
a
d
d
I
t
e
m
L
i
s
t
e
n
e
r
(
c
o
n
t
r
o
l
e
u
r
)
;
/
/
l
e
r
o
l
e
d
e
c
o
n
t
r
l
e
u
r
p
o
u
r
l
a
l
i
s
t
e
e
t
l
e
c
h
a
m
p
d
e
/
/
t
e
x
t
e
e
s
t
a
s
s
u
r
e
p
a
r
l
'
o
b
j
e
t
c
o
u
r
a
n
t
E
x
C
o
n
t
r
o
l
e
u
r
t
e
x
t
L
i
s
t
.
a
d
d
L
i
s
t
S
e
l
e
c
t
i
o
n
L
i
s
t
e
n
e
r
(
t
h
i
s
)
;
t
e
x
t
.
a
d
d
A
c
t
i
o
n
L
i
s
t
e
n
e
r
(
t
h
i
s
)
;
/
/
L
e
c
o
n
t
r
o
l
e
u
r
d
u
b
o
u
t
o
n
e
s
t
e
c
r
i
t
d
i
r
e
c
t
e
m
e
n
t
d
a
n
s
/
/
l
a
c
l
a
s
s
e
a
j
o
u
t
.
a
d
d
A
c
t
i
o
n
L
i
s
t
e
n
e
r
(
n
e
w
A
c
t
i
o
n
L
i
s
t
e
n
e
r
(
)
{
p
u
b
l
i
c
v
o
i
d
a
c
t
i
o
n
P
e
r
f
o
r
m
e
d
(
A
c
t
i
o
n
E
v
e
n
t
e
)
{
S
t
r
i
n
g
s
t
r
=
t
e
x
t
.
g
e
t
T
e
x
t
(
)
;
i
f
(
s
t
r
.
l
e
n
g
t
h
(
)
>
0
)
{
l
i
s
t
D
a
t
a
.
a
d
d
E
l
e
m
e
n
t
(
t
e
x
t
.
g
e
t
T
e
x
t
(
)
)
;
t
e
x
t
.
s
e
t
T
e
x
t
(
"
"
)
;
t
e
x
t
L
i
s
t
.
s
e
t
L
i
s
t
D
a
t
a
(
l
i
s
t
D
a
t
a
)
;
}
}
}
)
;
}/
/
C
e
t
t
e
m
e
t
h
o
d
e
e
s
t
a
p
p
e
l
e
e
s
i
l
a
s
e
l
e
c
t
i
o
n
d
e
l
a
l
i
s
t
e
/
/
c
h
a
n
g
e
p
u
b
l
i
c
v
o
i
d
v
a
l
u
e
C
h
a
n
g
e
d
(
L
i
s
t
S
e
l
e
c
t
i
o
n
E
v
e
n
t
e
)
{
S
t
r
i
n
g
s
e
l
e
c
t
e
d
=
(
S
t
r
i
n
g
)
t
e
x
t
L
i
s
t
.
g
e
t
S
e
l
e
c
t
e
d
V
a
l
u
e
(
)
;
/
/
L
e
t
e
x
t
e
a
f
f
i
c
h
e
e
s
t
m
i
s
a
j
o
u
r
e
n
f
o
n
c
t
i
o
n
d
e
l
a
/
/
n
o
u
v
e
l
l
e
s
e
l
e
c
t
i
o
n
i
f
(
s
e
l
e
c
t
e
d
!
=
n
u
l
l
)
{
d
e
s
s
i
n
.
s
e
t
T
e
x
t
(
s
e
l
e
c
t
e
d
)
;
}
e
l
s
e
{
d
e
s
s
i
n
.
s
e
t
T
e
x
t
(
"
"
)
;
}d
e
s
s
i
n
.
r
e
p
a
i
n
t
(
)
;
}/
/
C
e
t
t
e
m
e
t
h
o
d
e
e
s
t
a
p
p
e
l
e
e
s
i
l
a
t
o
u
c
h
e
e
n
t
r
e
e
e
s
t
/
/
p
r
e
s
s
e
e
d
a
n
s
l
e
c
h
a
m
p
d
e
t
e
x
t
e
p
u
b
l
i
c
v
o
i
d
a
c
t
i
o
n
P
e
r
f
o
r
m
e
d
(
A
c
t
i
o
n
E
v
e
n
t
e
)
{
S
t
r
i
n
g
s
t
r
=
t
e
x
t
.
g
e
t
T
e
x
t
(
)
;
/
/
L
e
t
e
x
t
e
d
u
c
h
a
m
p
e
s
t
a
j
o
u
t
e
l
a
l
i
s
t
e
d
e
s
t
e
x
t
e
s
i
f
(
s
t
r
.
l
e
n
g
t
h
(
)
>
0
)
{
l
i
s
t
D
a
t
a
.
a
d
d
E
l
e
m
e
n
t
(
t
e
x
t
.
g
e
t
T
e
x
t
(
)
)
;
t
e
x
t
.
s
e
t
T
e
x
t
(
"
"
)
;
t
e
x
t
L
i
s
t
.
s
e
t
L
i
s
t
D
a
t
a
(
l
i
s
t
D
a
t
a
)
;
}
}/
/
L
e
m
a
i
n
d
o
i
t
e
t
r
e
r
e
d
e
f
i
n
i
e
p
o
u
r
c
r
e
e
r
u
n
o
b
j
e
t
d
e
l
a
/
/
c
l
a
s
s
e
E
x
C
o
n
t
r
o
l
e
u
r
e
t
n
o
n
E
x
I
n
t
e
r
f
a
c
e
p
u
b
l
i
c
s
t
a
t
i
c
v
o
i
d
m
a
i
n
(
S
t
r
i
n
g
[
]
a
r
g
s
)
{
E
x
C
o
n
t
r
o
l
e
u
r
m
y
C
o
n
t
r
o
l
e
u
r
=
n
e
w
E
x
C
o
n
t
r
o
l
e
u
r
(
)
;
m
y
C
o
n
t
r
o
l
e
u
r
.
s
e
t
V
i
s
i
b
l
e
(
t
r
u
e
)
;
}
}/
/
U
n
e
c
l
a
s
s
e
d
e
c
o
n
t
r
o
l
e
u
r
d
e
f
e
n
e
t
r
e
c
l
a
s
s
W
i
n
d
o
w
C
o
n
t
r
o
l
e
r
e
x
t
e
n
d
s
W
i
n
d
o
w
A
d
a
p
t
e
r
{
p
u
b
l
i
c
v
o
i
d
w
i
n
d
o
w
C
l
o
s
i
n
g
(
W
i
n
d
o
w
E
v
e
n
t
e
)
{
S
y
s
t
e
m
.
e
x
i
t
(
0
)
;
}
}/
/
U
n
e
c
l
a
s
s
e
p
o
u
r
l
e
c
o
n
t
r
o
l
e
d
e
s
b
o
u
t
o
n
s
d
e
c
h
o
i
x
.
/
/
C
e
t
t
e
c
l
a
s
s
e
e
s
t
u
t
i
l
i
s
e
e
p
o
u
r
l
e
s
J
R
a
d
i
o
B
u
t
t
o
n
e
t
}
/
/
l
e
J
C
o
m
b
o
B
o
x
c
l
a
s
s
C
h
o
i
c
e
C
o
n
t
r
o
l
e
r
i
m
p
l
e
m
e
n
t
s
I
t
e
m
L
i
s
t
e
n
e
r
{
D
e
s
s
i
n
d
e
s
s
i
n
;
/
/
I
l
e
s
t
n
e
c
e
s
s
a
i
r
e
q
u
e
l
e
d
e
s
s
i
n
s
o
i
t
p
a
s
s
e
e
n
p
a
r
a
m
e
t
r
e
/
/
p
o
u
r
s
a
m
i
s
e
a
j
o
u
r
a
p
r
e
s
u
n
e
v
e
n
e
m
e
n
t
.
53
p
u
b
l
i
c
C
h
o
i
c
e
C
o
n
t
r
o
l
e
r
(
D
e
s
s
i
n
d
)
{
d
e
s
s
i
n
=
d
;
}/
/
C
e
t
t
e
m
t
h
o
d
e
e
s
t
a
p
p
e
l
e
e
s
i
l
a
s
e
l
e
c
t
i
o
n
d
'
u
n
b
o
u
t
o
n
/
/
c
h
a
n
g
e
p
u
b
l
i
c
v
o
i
d
i
t
e
m
S
t
a
t
e
C
h
a
n
g
e
d
(
I
t
e
m
E
v
e
n
t
e
)
{
/
/
O
n
t
e
s
t
e
q
u
e
l
'
e
v
e
n
e
m
e
n
t
e
s
t
b
i
e
n
u
n
e
s
e
l
e
c
t
i
o
n
i
f
(
e
.
g
e
t
S
t
a
t
e
C
h
a
n
g
e
(
)
=
=
I
t
e
m
E
v
e
n
t
.
S
E
L
E
C
T
E
D
)
{
/
/
t
r
a
i
t
e
m
e
n
t
e
f
f
e
c
t
u
e
r
s
i
l
'
e
v
e
n
e
m
e
n
t
s
'
e
s
t
/
/
p
r
o
d
u
i
t
s
u
r
u
n
J
R
a
d
i
o
B
u
t
t
o
n
i
f
(
e
.
g
e
t
S
o
u
r
c
e
(
)
i
n
s
t
a
n
c
e
o
f
J
R
a
d
i
o
B
u
t
t
o
n
)
{
d
e
s
s
i
n
.
s
e
t
F
i
g
u
r
e
(
(
(
J
R
a
d
i
o
B
u
t
t
o
n
)
e
.
g
e
t
I
t
e
m
(
)
)
.
g
e
t
T
e
x
t
(
)
)
;
}
/
/
t
r
a
i
t
e
m
e
n
t
a
e
f
f
e
c
t
u
e
r
s
i
l
'
e
v
e
n
e
m
e
n
t
s
'
e
s
t
/
/
p
r
o
d
u
i
t
s
u
r
u
n
J
C
o
m
b
o
B
o
x
e
l
s
e
i
f
(
e
.
g
e
t
S
o
u
r
c
e
(
)
i
n
s
t
a
n
c
e
o
f
J
C
o
m
b
o
B
o
x
)
{
d
e
s
s
i
n
.
s
e
t
C
o
u
l
e
u
r
(
(
S
t
r
i
n
g
)
e
.
g
e
t
I
t
e
m
(
)
)
;
}
e
l
s
e
{
S
y
s
t
e
m
.
e
r
r
.
p
r
i
n
t
l
n
(
"
E
r
r
e
u
r
-
c
o
m
p
o
s
a
n
t
n
o
n
v
a
l
i
d
e
"
)
;
}d
e
s
s
i
n
.
r
e
p
a
i
n
t
(
)
;
}
}
}
54
Annexe B
Diagramme de classes UML
UML (Unified Modeling Language) a t cr en 1997 pour tre le langage standard de mod-
lisation orient-objet. UML contient diffrents diagrammes utiliss pour dcrire de nombreux
aspects du logiciel. Dans le cadre de ce cours, nous utiliserons uniquement le diagramme de
classes
1
.
Le diagramme de classes reprsente la structure statique du logiciel. Il dcrit lensemble des
classes qui sont utilises ainsi que leurs associations. Il est inspir des diagrammes Entit-Relation
utiliss en modlisation de bases de donnes, en y ajoutant les aspects oprationnels (les m-
thodes) et quelques subtilits smantiques (la composition, par exemple).
B.1 Reprsentation des classes et interfaces
B.1.1 Les classes
En UML, une classe est au minimumdcrite par un nom. Graphiquement, elle est reprsente
par un rectangle, ventuellement divis en 3 parties : son nom, ses attributs et ses oprations. On
appelle membres de la classe ses attributs et mthodes (ou oprations).
Nom de
classe
Nom de
classe
Opration
Opration
Attribut
Attribut
Nom de
classe
Figure B.1 Reprsentations UML possible dune classe, avec ou sans les membres
B.1.2 Les membres de classe
Chaque attribut est dcrit au moins par un nom (unique dans une mme classe) et par un type
de donnes.
Une opration, ou mthode, est dcrite au moins par un nom, par un ensemble darguments
ncessaires son invocation et par un type de retour. Chaque argument est dcrit par un nom
et un type de donnes.
1. le langage UML pourra tre tudi en profondeur lors du cours Analyse et Conception de Systmes Informa-
tiques de laxe Ingnierie des Systmes Informatiques
55
Annexe B. Diagramme de classes UML
Un niveau de visibilit est galement attribu chaque membre. La visibilit dun membre
dune classe dfinit quelles autres classes y ont accs (en terme de lecture/criture). UML utilise 3
niveaux de visibilit :
public (not par +), le membre est visible par toutes les classes
priv (not par -), le membre nest visible par aucune classe sauf celle qui le contient
protg (not par #), le membre est visible par toutes les sous-classes de celle qui le contient
(cette visibilit est explique ultrieurement)
+ calculerDureePret() : int
+ getAge() : int
+ surnom : String
- nom : String
- prenom : String
# dateNaissance : Date
Personne
Figure B.2 Exemple de classe Personne avec attributs et oprations
La figure B.2 est un exemple dune classe Personne avec toutes les possibilits de visibilit.
B.1.3 Les classes abstraites
En UML, le mot-cl {abstrait} (ou {abstract}) est accol aux classes et mthodes abs-
traites. Une autre manire souvent usite de reprsenter ces mthodes ou classes est dcrire leur
nom en italique. Les attributs et mthodes de classe sont souligns. La classe Personne dcrite dans
la figure ci-dessous montre un exemple dattribut et de mthode de classe.
Personne
Personne
{abstract}
Figure B.3 Deux reprsentations possibles pour une classe abstraite Personne
+ setAgeMajorite(a : int)
+ getAge() : int
+ surnom : String
- nom : String
- prenom : String
- ageMajorite : int = 18
Personne
Figure B.4 Exemple dun attribut et dune mthode de classe pour la classe Personne
B.1.4 Les interfaces
En UML, une interface est dcrite par le mot-cl interface dans le bloc dentte, comme
prsent dans la figure B.5.
56
B.2. Les relations
<<interface>>
Interface
Figure B.5 Exemple dinterface
B.2 Les relations
En conception oriente objet, les relations englobent notamment les relations dhritage et de
ralisation dinterface.
B.2.1 Lhritage
En UML, lhritage se reprsente par une flche la pointe creuse. La figure B.6 dcrit deux
classes Super-classe et Sous-classe. La classe Sous-classe hrite de la classe Super-classe.
Super-classe
Sous-classe
Figure B.6 Exemple dhritage
B.2.2 La ralisation
La ralisation dune interface par une classe se reprsente par une flche pointille pointe
creuse, comme illustr dans la figure B.7.
<<interface>>
Interface
Classe
Figure B.7 Exemple de ralisation de linterface Interface par la classe Classe
B.3 Les associations
Certaines relations entre classes dun mme diagramme sont reprsentes en UML sous la
forme dassociations. Le plus souvent une association ne relie que deux classes. Une association
57
peut tre identifie par un nom et chacune de ses extrmits dfinit le nombre dinstances des
classes relies qui sont impliques dans cette association. Onappelle multiplicit ce nombre dins-
tances qui peut prendre les valeurs suivantes :
Multiplicit Interprtation
1 un et un seul
0..1 zro ou un
N exactement N
M..N de M N
* zro ou plus
0..* zro ou plus
1..* un ou plus
Responsable Collaborateur
*
1
manage
chef subordonn
Figure B.8 Exemple dassociation manage
Lexemple de la figure B.8 dcrit une association manage entre la classe Responsable et la
classe Collaborateur. Un responsable gre plusieurs collaborateurs, ses subordonns. Un col-
laborateur est gr par un seul responsable, son chef. Les lments subordonn et chef sont des
rles dassociation.
B.3.1 Direction des associations
Les associations peuvent tre diriges, ce qui contraint la visibilit et la navigation dans le mo-
dle. La direction se reprsente par une flche classique. Par dfaut, sil ny a pas de flche, lasso-
ciation est bidirectionnelle (comme sil y avait une flche chaque extrmit de lassociation).
*
1
A B
*
1
A B
*
1
A B
Figure B.9 Exemples dassociations diriges
La figure B.10 prsente des exemples de directions, dont voici les interprtations. La premire
ligne signifie que A connat tous les B auxquels elle est associe, et rciproquement, un B connat le
A auquel il est associ. La deuxime ligne signifie que seul le A connat les B auxquels il est associ,
mais pas linverse. Finalement, dans la troisime ligne, un B connat le A auquel il est associ, mais
pas linverse. En fait, ceci va impliquer la prsence ou non dun attribut a de type A dans la classe
B ou b de type B dans la classe A en fonction de la direction. Par exemple, pour la deuxime ligne,
A possde une liste dobjet de type B mais B ne possde pas dattribut de type A.
58
B.4. Correspondance UML-Java
B.3.2 Agrgation et composition
Deux sous-types dassociations permettent de prciser un sens particulier ces relations :
lagrgation et la composition. Elles peuvent galement tre diriges.
*
1
A B
*
1
A B
*
1
A B
*
1
A B
Figure B.10 Exemples de compositions et dagrgations.
Lagrgation est une association avec relation de subordination, souvent nomme possde
reprsente par un trait reliant les deux classes et dont lorigine se distingue de lautre extrmit
(la classe subordonne) par un losange creux. Une des classes regroupe dautres classes. On peut
dire que lobjet A utilise ou possde une instance de la classe B.
La composition est une association liant le cycle de vie des deux classes concernes. Une as-
sociation de composition sinterprte comme une classe est compose de un ou plusieurs lment
de lautre classe. Elle est reprsente par un trait reliant les deux classes et dont lorigine se dis-
tingue de lautre extrmit (la classe composant) par un losange plein. On peut dire que lobjet A
est compos instance de la classe B, et donc si lobjet de type A est dtruit, les objets de type B qui
le composent sont galement dtruit. Ce sera galement souvent les objets de type A qui creront
les objets de type B.
B.4 Correspondance UML-Java
Java permet de programmer tout modle sous forme de diagramme de classe UML tel que
prsent ci-dessus. Voici quelques exemples de correspondance entre le modle UML et le codage
Java.
B.4.1 Classes et membres
+ getAge() : int
+ surnom : String
- nom : String
- prenom : String
Personne
public class Personne {
public String surnom;
private String prenom;
private String nom;
protected Date dateNaissance;
public int calculerDureePret() {...}
public int getAge() {...}
}
B.4.2 Classes abstraites
59
+ setAgeMajorite(a : int)
+ getAge() : int
+ surnom : String
- nom : String
- prenom : String
- ageMajorite : int = 18
Personne
public abstract class Personne {
public String surnom;
private String prenom;
private String nom;
protected Date dateNaissance;
private static int ageMajorite = 18;
public int calculerDureePret() {...}
public static void setAgeMajorite(int a) {...}
public int getAge() {...}
}
B.4.3 Interfaces
+ afcher()
<<interface>>
IAfchable
interface IAffichable {
void afficher();
}
B.4.4 Hritage
- nom : String
Personne
- iD : int
Adherent
public class Adherent extends Personne {
private int iD;
}
B.4.5 Ralisation
+ afcher()
<<interface>>
IAfchable
+ imprimer()
<<interface>>
IImprimable
+ afcher()
+ imprimer()
- nom : String
- chier : File
Image
public class Image implements IAffichable, IImprimable {
private String nom;
private File fichier;
public void afficher(){...}
public void imprimer(){...}
}
B.4.6 Associations
A1 B1
public class A1 {
private B1 b1;
...
}
60
B.4. Correspondance UML-Java
A2 B2
*
public class A2 {
private ArrayList<B2> b2s;
...
}
Homme
Femme
0..1
0..1
mari
epouse
public class Homme {
private Femme epouse;
...
}
public class Femme {
private Homme mari;
...
}
Personne
1
chef
0..*
subordonne
public class Personne {
private ArrayList<Personne> subordonnes;
private Personne chef;
...
}
61
62
Rfrences
Livres :
Programmer en Java, 7e Edition, Claude Delannoy, Eyrolles, 2011
The Java Tutorial : A Short Course on the Basics, 4th Edition, Collectif, Prentice Hall, 2006
Effective Java, 2nd Edition, Joshua Bloch, Prentice Hall, 2008
Java in a nutshell, 5th edition, David Flanagan, OReilly, 2005
Sites web :
Le site officiel Java, http://www.oracle.com/technetwork/java/index.html
Le tutorial Java, http://docs.oracle.com/javase/tutorial/
lAPI du JDK 1.7, http://docs.oracle.com/javase/7/docs/api/
Un site (franais) de dveloppeurs, http://www.javafr.com/
Le site JavaWorld, http://www.javaworld.com
Quelques autres liens :
des liens en rapport avec Java, http://www.javamug.org/mainpages/Java.html
Tutoriaux jGuru, http://java.sun.com/developer/onlineTraining/
plein dautres cours, http://java.developpez.com/cours/
63

Livre T Java

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Livre T Java

Uploaded by

Copyright:

Available Formats

Initiation la programmation oriente-objet

avec le langage Java

You might also like