0 évaluation0% ont trouvé ce document utile (0 vote) 156 vues67 pagesCours Java
programmation java de manière détaillée
Copyright
© © All Rights Reserved
Formats disponibles
Téléchargez aux formats PDF ou lisez en ligne sur Scribd
Table des matiéres
Introduction au langage Java 1
11 Environnement Java 1
xia Compilation 2
11.2 Interprétation 2
1.2 Programmation orientée-objet 2
12a Classe 3
122 Objet 4
Syntaxe du langage 7
21 Types de données 7
211 Types primitifs 7
212 Tableaux et matrices 8
213 Chaines de caractéres 8
2.2 Opérateurs 9
23, Structures de controle. 9
231 Instructions conditionnelles 9
2.3.2 Instructions itératives : . 10
23.3. Instructions break et continue n
Elements de programmation Java 8
3.1 Premiers pas, B
gaa ClasseHelloWorld. 6... 6... cee ce
3.12 Packages 4
3.2 Variables et méthodes : 5
3.21 Visibilité des champs 5
3.2.2 Variables et méthodes de classe... . . . 16
Heritage 19
41 Principe de U'héritage 19
4.1 Redéfinition 20
41.2 Polymorphisme a
4a Interfaces eee : . 23
43. Classes abstraites 24
44 Classes et méthodes génériques . . . 25
Gestion des exceptions 7
51 Déclaration 7
5.2 Interception et traitement 29
53 Classes d'exception . . : : 30
5.4 Classification des erreurs en Java . 30Table des matiéres
6 Gestion des entrées/sorties simples
6a
62,
Flux d'entrée :
a1 — Lecture des entrées clavier
61.2 Lecture a partir d'un fichier
613 Lecture d’objets enregistrés
Flux de sortie :
6.21 — Ecriture sur la sortie standard “écran”
62.2 Eeriture dans un fichier
623 Ecriture d'objets
A. Applications graphiques (package swing)
AX
Aa
AS
Le schéma Modéle-Vue-Controleur
‘Composants graphiques
A21 Composants
Aza Containers
A23 _Exemple diinterface
Controleurs d’événements
Aga Evénements
Aga Interface Listener
A33 Exemple de contréleur
B_ Diagramme de classes UML
Ba
Bs
Ba
Représentation des classes et interfaces
Baa Les classes
Baz Lesmembres de classe
Baz __ Les classes abstraites
Ba4 Les interfaces
Les relations
Bar Lhéritage
Baa Laréalisation
Les associations
B3a__ Direction des associations
B3.2_Agrégation et composition
‘Correspondance UML-Java
B41 Classes et membres
B42 Classes abstraites
B.g3 Interfaces
B44 Heritage
B45 Réalisation
B4.6 Associations
33
33
34
34
36
37
37
37
39
4B
B
44
44
45
a
By
51
5.
5
55
55
55
55
56
56
57
57
57
57
58
59
39
59
59
60
60
60
60Table des matiéres
La plupart des programmes donnés en exemple dans ce cours sont téléchargeables & URL
http://www ense. fr/~picard/cours/1A/ javaTable des matiéresChapitre 1
Introduction au langage Java
Le langage Java est un langage généraliste de programmation synthétisant les principaux lan-
gages existants lors de sa création en 1995 par Sun Microsystems. Il permet une programmation
orientée-objet (8 l'instar de SmallTalk et, dans une moindre mesure, C++), modulaire (langage
ADA) et reprend une syntaxe trés proche de celle du langage C.
Outre son orientation objet, le langage Java a l'avantage d’étre modulaire (on peut écrire des
portions de code génériques, c-A-d utilisables par plusieurs applications), rigoureux (la plupart
des erreurs se produisent &la compilation et non al'exécution) et portable (un méme programme
compilé peut sexécuter sur différents environnements). En contre-partie, les applications Java ont
le défaut d’étre plus lentes & l'exécution que des applications programmeées en C par exemple.
1.1 Environnement Java
Java est un langage interprété, ce qui signifie qu'un programme compile n’est pas directement
exécutable parle systéme d’exploitation mais il doit étre interprété par un autre programme, qu’on
appelle interpréteur. La figure 1. illustre ce fonctionnement.
Exemple
Code source MyProg.java
contac javac MyProg java
brine sgh
imation Java ia
‘Systeme tom ion Systéme asian
Ficure 11 ~ Interpretation du langage
‘Un programmeur Java écrit son code source, sous la forme de classes, dans des fichiers dont
Yextension est . java. Ce code source est alors compilé par le compilateur javac en un langage
appelé bytecode et enregistre le résultat dans un fichier dont Pextension est -class. Le bytecode
1CChapitre 1. introduction au langage Java
ainsi obtenu n'est pas directement utilisable, Il doit étre interprété par la machine virtuelle de Java
qui transforme alors le code compilé en code machine compréhensible par le systéme d'exploita-
tion, C'est la raison pour laquelle Java est un langage portable : le bytecode reste le méme quelque
soit l'environnement d’exécution,
En 2009, Sun Microsystems est racheté par Oracle Corporation qui fournit dorénavant les
outils de développement Java SE (Standard Edition) contenus dans le Java Development Kit (JDK)
Au moment oit est écrit ce livret, la derniére version stable est le JDK 1.7.
La compilation s‘effectue par la commande javac suivie d'un ou plusieurs nom de fichiers
contenant Ie code source de classes Java, Par exemple, javac MyProg. java compile la classe My-
Prog dontlle code source est situé dans le fichier MyProg. java. La compilation nécessite souvent la
ptécision de certains paramétres pour s'effectuer correctement, notamment lorsque le code source
fait référence a certaines classes situées dans d'autres répertoires que celui du code compilé, I faut
alors ajouter option -classpath suivie des répertoires (séparés par un ; sous Windows et : sous
Unix) des classes référencées, Par exemple
Javac classpath /prog/exos1:/cours MyProg. java
compilera le fichier MyProg. java si celui-ci fait référence a d'autres classes situées dans les ré
pertoires /prog/exosi et /cours. Le résultat de cette compilation est un fichier nommé My-
Prog. class contenant le bytecode correspondant au source compilé. Ce fichier est créé par défaut
dans le répertoire oit a compilation s'est produite. Il est cependant fortement souhaitable de ne
pas mélanger les fichiers contenant le code source et ceux contenant le bytecode. Un répertoire
de destination oi sera créé le fichier MyProg.class peut étre précisé par ‘option -d, par exemple
Javac -d /prog/exos1 -classpath /cours MyProg. java
1.1.2 Interprétation
Le bytecode obtenu par compilation ne peut étre exécuté qu’a aide de linterpréteur. L'exé
cution s‘effectue par la commande java suivie du nom de la classe & exécuter (sans l'extension
-c1ass). Comme lors de la compilation, il se peut que des classes d'autres répertoires soient né-
cessaires. Il faut alors utiliser option -classpath comme dans l'exemple qui suit,
Java -classpath /prog/exosi:/cours MyProg
1.2. Programmation orientée-objet
‘Chaque langage de programmation appartient & une “Samille” de langages définissant une
approche ou une méthodologie générale de programmation. Par exemple, le langage C est un
langage de programmation procédurale car il suppose que le programmeur s intéresse en prio-
rité aux fraitements que son programme devra effectuer. Un programmeur C commencera par
identifier ces traitements pour écrire les fonctions qui les réalisent sur des données prises comme
paramétres d'entrée.
La programmation orientée-objet (introduite par le langage SmallTalk) propose une métho-
dologie centrée sur les données. Le programmeut Java va d'abord identifier un ensemble d objets,
tel que chaque objet représente un élément qui doit étre utilisé ou manipulé par le programme,
sous la forme d’ensembles de données. Ce n'est que dans un deuxime temps, que le program-
meur va écrire les traitements, en associant chaque traitement a un objet donné. Un objet peut
21.2, Programmation or
-objet
étre vu comme une entité regroupant un ensemble de données et de méthodes (I'équivalent d'une
fonction en C) de traitement.
1.2.1 Classe
Un objet est une variable (presque) comme les autres. I faut notamment qu'il soit déclaré
avec son type. Le type d'un objet est un type complexe (par opposition aux types primitifs entier,
caractére, ...) qu’on appelle une classe
Une classe regroupe un ensemble de données (qui peuvent étre des variables primitives ou des
objets) et un ensemble de méthodes de traitement de ces données et/ou de données extérieures &
Ia classe, On parle d'encapsulation pour désigner le regroupement de données dans une classe.
Par exemple, une classe Rectangle utilisée pour instancier des objets représentant des rec
tangles, encapsule 4 entiers : la longueur et la largeur du rectangle ainsi que la position en abscisse
et en ordonnée de l'origine du rectangle (par exemple, le coin en haut a gauche). On peut alors
imaginer que la classe Rectangle implémente une méthode permettant de déplacer le rectangle qui
nécessite en entrée deux entiers indiquant la distance de déplacement en abscisse et en ordonneée.
Laccés aux positions de l'origine du rectangle se fait directement (ie. sans passage de paramétre)
lorsque les données sont encapsulées dans la classe oit est définie la méthode. 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 + ys
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 systéme, Les traitements a effectuer sont programmés
dans les méthodes de ces classes qui peuvent faire appel & des méthodes d'autres classes, En géné-
ral, on définit une classe, dite “exécutable”, dont une méthode peut étre appelée pour exécuter le
programme.
Encapsulation
Lors dela conception d'un programme orienté-objet, le programmeur doit identifier les objets
tes données appartenant & chaque objet mais aussi des droits 'accés qu’ont les autres objets sur
ces données. L’encapsulation de données dans un objet permet de cacher ou non leur existence
aux autres objets du programme. Une donnée peut étre déclarée en acc’s
«+ public : les autres objets peuvent accéder & la valeur de cette donnée ainsi que la modifier ;
3CChapitre 1. introduction au langage Java
«+ privé : les autres objets n'ont pas le droit d'accéder directement & la valeur de cette donnée
(ni de la modifier). En revanche, ils peuvent le faire indirectement par des méthodes de
Tobjet concerné (si celles-ci existent en accés public)
Les différents droits d’accés utilisables en Java sont détaillés dans la section 3.21
Méthode constructeur
‘Chaque classe doit définir une ou plusieurs méthodes particulitres appelées des construc-
teurs. Un constructeur est une méthode invoquée lors de la création d'un objet. Cette méthode,
qui peut etre vide, effectue es opérations nécessaires al 'initialisation d'un objet. Chaque construc
teur doit avoirle méme nom quela classe oii il est défini et n'a aucune valeur de retour (cestYobjet
créé qui est renvoyé). Dans lexemple précédent de a classe rectangle, le constructeur initialise la
valeur des données encapsulées
class Rectangle {
Rectangle(int lon, int lar) {
‘this. longueur = lon;
‘this.largeur = lars
‘this.origine_x = 05
‘this.origine_y = 0;
Plusieurs constructeurs peuvent étre définis sils acceptent des paramétres d’entrée différents.
1.2.2 Objet
Instanciation
Un objet est une instance (anglicisme signifiant «cas» ou «exemple ») d'
rencé par une variable ayant un état (ou valeur). Pour créer un objet, il est nécessaire de déclarer
uune variable dont le type est Ia classe & instancier, puis de faire appel & un constructeur de cette
classe. L'exemple ci-dessous illustre la eréation d’un objet de classe Cercle en Java :
Cercle mon_rond;
mmon_rond = new Cercle();
L'usage de parenthéses & initialisation du vecteur, montre qu'une méthode est appelée pour
Pinstanciation. Cette méthode est un constructeur de la classe Cercle. Si le constructeur appelé
nécessite des paramétres dentrée, ceux-ci doivent étre précisés entre ces parentheses (comme lors
dun appel classique de méthode). L'instanciation d'un objet de la classe Rectangle faisant appel
au constructeur donné en exemple ci-dessous pourra s écrire
Rectangle mon_rectangle = new Rectangle(15,5);
= Remarque importante :en Java, la notion de pointeur est transparente pourle programmeur.
1 faut néanmoins savoir que toute variable désignant un objet est un pointeur. II sensuit alors
‘quelle passage dobjets comme paramétres d'une méthode est toujours un passage par référence.
A inverse, le passage de variables primitives comme paramaétres est toujours un passage par
valeur
41.2, Programmation or
Accés aux variables et aux méthodes
Pour accéder & une variable associée & un objet, il faut préciser l'objet qui la contient. Le sym-
bole.” sert & séparer l'identificateur de objet de lidentificatcur de la variable. Une copie de la
Jongueur d'un rectangle dans un entier temp s'écrit
int temp = mon_rectangle. longueur}
La méme syntaxe est utilisée pour appeler une méthode d'un objet. Par exemple
mon_rectangle.deplace(1@,-3);
Pour qu'un tel appel soit possible, il faut que trois conditions soient remplies
1. La variable ou la méthode appelée existe!
2, Une variable désignant objet vis¢ existe et soit instanciée,
3. Llobjet, au sein duquel est fait cet appel, ait le droit d’accéder & la méthode ow & la variable
(cf. section 3.2.3).
Pour référencer objet “courant” (celui dans lequel se situe la ligne de code), le langage Java
fournit le mot-clé this. Celui-ci n'a pas besoin d’étre instancié et s‘utilise comme une variable
désignant I objet courant, Le mot-clé this est également utilisé pour faire appel un constructeur
de Vobjet courant. Ces deux utilisations possibles de this sont illustrées 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 = x5
this.origine y = ys
Carre(int cote) (
this(cote, @, 8);CChapitre 1. introduction au langage JavaChapitre 2
Syntaxe du langage
Le langage C a servi de base pour la syntaxe du langage Java
© le caractére de fin d'une instruction est “;
+ les commentaires (non traités par le compilateur) se situent entre les symboles “/*" et “*/"
‘ou commencent parle symbole “//” en se terminant la fin de la ligne
int a; // ce conmentaire tient sur une Ligne
int b;
/*Ce commentaire nécessite
2 Lignes*/
int a;
« les identificateurs de variables ou de méthodes acceptent les caractires {a.7}, {A.Z}, §, —
ainsi que les caractéres {o..9} sls ne sont pas le premier caractére de identificateur. Il faut
évidemment que lidentificateur ne soit pas un mot réservé du langage (comme int ou for)
Ex : non_entier et okdaL.l sont des identificateurs valides mais
non-entier et 4a11 ne sont pas valides pour des identificateurs,
2.1 Types de données
2.1.1. Types primi
Le tableau 2.1 liste l'ensemble des types primitifs de données de Java,
En plus de ces types primitifs, le terme void est utilisé pour spécifier le retour vide ou une
absence de paramétres d'une méthode, On peut remarquer que chaque type primitif posséde une
classe qui encapsule un attribut du type primitif. Par exemple, la classe Integer encapsule un
attribut de type int et permet ainsi d’effectuer des opérations de traitement et des manipulations
qui seraient impossibles sur une simple variable de type int,
ATinverse du langage C, Java est un langage trés rigoureux sur le typage des données. Il est in-
terdit d'affecter une variable la valeur d'une variable d'un type différent’ si cette seconde variable
n'est pas explicitement transformée. Par exemple
int a;
double b = 5.
a
1, exception faite des types associs par une relation dhéritage, cf. section 4CChapitre2. Syntaxe du langage
‘Taste 2.1- Type primitifs de données en Java
Type | Classe éq._| Valeurs Portée Défaut
Boolean [ Boolean | true ou false | NIA false
byte | Byte entier signé | (128.128) @
char | character | caractéxe {\uoooo..\aFFFFD wooo.
short [Short entier igné | (32768, 32767), @
int | integer | entiersigné | (2147483648, 2147483647) 0
Tong [tong entier signé [22 —T} 7
Float _| Float | réelsigné 13, 40282343, 4028234" 00
1, 40239846-8.1, 40239846-*)
double | Double | reel signé 11, 797698131, 797695") _| 0.0
{-4, 94065645". 4, 94065
est interdit et doit étre écrit de la maniére suivante
int a;
double b = 5.0 ;
a= (int)b 5
2.1.2 Tableaux et matrices
‘Une variable est déclarée comme un tableau dés lors que des crochets sont présents soit aprés
son type, soit aprés son identificateur, Les deux syntaxes suivantes sont acceptées pour déclarer
wun tableau d'entiers (méme sila premiére, non autorisée en C, est plus intuitive)
int[] mon_tableau;
int mon_tableau2{ J;
Un tableau a toujours une taille fixe* qui doit étre précisée avant Vaffectation de valeurs & ses
indices, de la maniére 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 créer des matrices ou des tableaux &
plusieurs dimensions en multipliant les crochets (ex : int[][] ma_natrices). A Tinstar du C,
on accéde aux éléments d'un tableau en précisant un indice entre crochets (mon_tableau[3] est
le quatriéme entier du tableau) et un tableau de taille n stocke ses éléments & des indices alant de
oan.
2.1.3 Chaines de caractéres
Les chaines de caractéres ne sont pas considérées en Java comme un type primitif ou comme
un tableau. On utilise une classe particuliére, nommée String, fournie dans le package java. lang.
Les variables de type String ont les caractéristiques suivantes
+ leur valeur ne peut pas étre modifiée
7 pour ullser des ensembles & taille variable, a classe java.util Vector est ts ule22, Opérateurts
+ on peut utiliser Popérateur + pour concaténer deux chaines de caractéres
string s1 = “hello”;
String s2 = “world”;
String s3 = sl +” " + 82;
//apres ces instructions s3 vaut “hello world”
« Vinitialisation d'une chaine de caractéres s’écrit
String s = new String(); //pour une chaine vide
‘String s2 = new String(”hello world”) ;
// pour une chatne de valeur "hello workd”
‘+ un ensemble de méthodes de la classe java.lang.String permettent d'effectuer des opé-
rations ou des tests sur une chaine de caractéres (voir la documentaion de la classe String)
2.2 Opérateurs
‘Une liste des opérateurs disponibles en Java est présentée par ordre de priorité décroissante
dans le tableau 2.2.
2.3 Structures de contréle
Les structures de contréle permettent d'exécuter un bloc dinstructions soit plusieurs fois
(instructions itératives) soit selon la valeur d'une expression (instructions conditionnelles ou de
choix multiple), Dans tous ces cas, un bloc d'instruction est
* soit une instruction unique;
« soit une suite d'instructions commengant par une accolade ouvrante “{” et se terminant par
tune accolade fermante ")”.
2.3.1 Instructions conditionnelles
Syntaxe
if () [else ]
?:
doit renvoyer une valeur booléenne. Si celle-ci est vraie c'est (resp.
) qui est exécuté sinon (resp. ) est exécuté. La partie
else est facultative
Exemple
if (a == b) (
a = 505
b= 0;
y else
asa-t
yCChapitre2. Syntaxe du langage
‘TaBLe 2.2 - Opérateurs Java
Fe [Oper Sate Basa | iganton
p= 7 re
ie fants | portdeerementatin
: ar fan | serene
Veto ‘ooo> | complement ogigue
(ome | operon» svai>_| etungenea dere
oa aera ‘arb | walapheason
x cartoxeanty farts | retede la don
TT arbres Ebi
Te Sea eR tans ag
Syauche
» cents cont | cents | deep dei
e acts & Garb cooa> | ingériewr ou yal
* Geb year ‘eos supénear ov deal
instanceot | evaisinetanceotceiy | coma | tat denne
= Sabo es) [el
TF eerOECeAO eno PETS
‘toon a
7 entree ent | OU econ TBE
“tee? ‘oo _| OV eacuatboolen
7 nT ont ents OUSEES
aos a0» ‘000 _| OU Boon
=e ERS easy ET og
= I en | OU rg
Ligende
erty leur aithndigue
‘oor valeur booleane
“str cine de arcs (tring)
2.3.2 Instructions itératives
Les instruction itératives permettent dexécuter plusieurs fois un bloc d'instructions, et ce,
jusqu’a ce qu'une condition donnée soit fausse. Les trois types d'instruction itératives sont les
suivantes
TantQue..faire... L'exécution de cette instruction suit les étapes suivantes
1. la condition (qui doit renvoyer une valeur booléenne) est évaluée. Si celle-ci est vraie on
passe al'étape 2, sinon on passe aétape 43
2. lebloc est exécuté ;
3. retour al étape 1;
4. la boucle est terminée et le programme continue son exécution en interprétant les instruc~
tion suivant le bloc.
Syntaxe
luhile ()
Exemple
1023, Structures de contrdle
while (a != b) ates
Faire..TantQue.... L’exécution de cette instruction suit les étapes suivantes
1, lebloc est exécuté;
2. la condition (qui doit renvoyer une valeur booléenne) est évaluée. Si celle-ci est vraie on
retourne a étape 1, sinon on passe a'étape 3;
3. la boucle est terminée et le programme continue son exécution en interprétant les instruc:
tion suivant le bloc.
Syntaxe
do while () ;
Exemple
do ats
while (a |
Ds
Pour..Faire Cette boucle est constituée de trois parties : (i) une initialisation (la déclaration de
variables locales 4 la boucle est autorisée dans cette partie) ; (ii) une condition d’arrét; (iii) un
ensemble d’instructions 4 exécuter aprés chaque itération (chacune de ces instructions est séparée
par une virgule). L’exécution de cette instruction suit les étapes suivantes
1, les initialisations sont effectuées;
2, la condition (qui doit renvoyer une valeur booléenne) est évaluée, Si celle-ci est vraie on
passe & ape 2, sinon on passe aT étape 6;
ebloc principal est exécutés
les instructions & exécuter aprés chaque itération sont exécutées
retour aTétape 2;
la boucle est terminée et le programme continue son exécution en interprétant les instruc-
tions suivant le bloc principal
Syntaxe
for (; ;)
Exemple
for (int i= 8, j= 49; (4 < 25) @& (j >= 25); dnt, 5
if (tab[i] > tab[j]) {
int tampon = tab[j];
> Question : que se passe-tiilsile break situé aprés le case *c? est omis?
2.3.3 Instructions break et continue
instruction break est utilisée pour sortir immeédiatement d'un bloc d'instructions (sans trai
ter les instructions restantes dans ce bloc). Dans le cas d'une boucle on peut également utiliser
instruction continue avec la différence suivante
break : l'exécution se poursuit aprés la boucle (comme sila condition darrét devenait vraie) ;
uCChapitre2. Syntaxe du langage
continue : 'exécution du bloc est arrétée mais pas celle de la boule, Une nouvelle itération
du bloc commence sila condition d’arrét est toujours vraie.
Exemple:
RChapitre 3
Eléments de programmation Java
3.1 Premiers pas
‘Un programme écrit en Java consiste en un ensemble de classes représentant les éléments ma-
nipulés dans le programme et les traitements associés. L’exécution du programme commence par
Yexécution d'une classe qui doit implémenter une méthode particuliére “public static void
main(String[] args)”. Les classes implémentant cette méthode sont appellées classes exécu-
tables.
‘Une classe Java Hel loWorld qui affiche la chaine de caractéres “Hello world” s'écrit
public class HelloWorld {
public static void main(String[] args) {
System.out.printin("Hello world”) ;
Lexécution (aprés compilation) de cette classe se fait dela maniére suivante
C:\pjava HelloWorlé
Hello world
c\>
= Remarque :le tableau de chatnes de caractéres args qui est un paramétre d’entrée de la mé-
thode main contient des valeurs précisées & 'exécution, Sila classe avait été exécutée par la ligne
de commande “Java HelloWorld 4 toto _”, ce tableau contiendrait 3 éléments dont les va-
leurs seraient respectivement “A”, “toto” et “”
Dans ce premier programme trds simple, une seule classe est uilisée, Cependant, la concep-
tion d’un programme orienté-objet nécessite, pour des problémes plus complexes, de créer plu-
sieurs classes et la classe exécutable ne sert souvent qu’a instancier les premiers objets. La classe
exécutable suivante crée un objet en instanciant la classe Rectangle (cf. section 1.2.1) et affiche sa
surface
BCChapitre 3. Eléments de programmation Java
public class RectangleMain {
public static void main(string[] args) (
Rectangle rect = new Rectangle(5, 10);
systen.out.println(*La surface est ” + rect.surface());
ow Remarque importante : il est obligatoire d'implémenter chaque classe publique dans un fi-
chier séparé et il est indispensable que ce fichier ait le méme nom que celui de la classe. Dans le
«cas précédent, deux fichiers ont ainsi été créés : RectangleMain, java et Rectangle. java
3.1.2 Packages
Un grand nombre de classes, fournies par Java SE, implémentent des données et traitements
_génériques utilisables par un grand nombre d'applications. Ces classes forment 'API (Application
Programmer Interface) du langage Java. Une documentation en ligne pour ‘API java est disponible
aTURL
http: //docs. oracle. com/javase/7/docs/api/
"Toutes ces classes sont organisées en packages (ou bibliothéques) dédiés & un theme précis.
Parmi les packages les plus utilisés, on peut citer les suivants
Package | Description
Javaawt | Classes graphiques et de gestion dinterfaces
java Gestion des entrées/sorties
javalang _ | Classes de base (importé par défaut)
java.util | Classes utiitaires
javax swing | Autres classes graphiques
Pour accéder & une classe d'un package donne, il faut préalablement importer cette classe ou
son package. Par exemple, la classe Date appartenant au package java.util qui implémente un
ensemble de méthodes de traitement sur une date peut étre importée de deux maniéres,
# une seule classe du package est importée
import java.util.Date;
*# toutes les classes du package sont importées (méme les classes non utilisées)
import java.util.*;
Le programme suivant utilise cette classe pour afficher la date actuelle
import java.util.pate;
public class DateMain (
Public static void main(String[] args) (
Date today = new Date();
System.out.printIn(”"Nous sonmes le ” + today. toString());
“443.2. Variables et méthodes
Test possible de créer vos proptes packages en précisant, avant la déclaration d'une classe, le
package auquel elle appartient. Pour assigner la classe précédente & un package, nommeé fr.emse,
il faut modifier le fichier de cette classe comme suit :
package fr.ense;
import java.util.Date;
public class Datetiain {
y
Enfin, il faut que le chemin daccés du fichier DateMain. java corresponde au nom de son
package, Celui-ci doit donc étre situé dans un répertoire fr/emse/DateMain. java accessible &
partir des chemins d'accés définis lors de la compilation ou de I'exécution (voir section 1:1.)
3.2 Variables et méthodes
3.21 Vi
1é des champs
Dans les exemples précédents, le mot-clé public apparait parfois au début d'une déclaration
de classe ou de méthode sans qu'l ait été expliqué jusqu'ici. Ce mot-clé autorise n’importe quel
objet & utiliser la classe ou la méthode déclarée comme publique. La portée de cette autorisation
dépend de élément & laquelle elle s applique (voir le tableau 3.1)
Tams 3. - Portée des autorisations
‘Higment | Autorisations
‘Variable | Lecture et écriture
‘Méthode [ Appel dela méthode
Classe | Instanciation W objets de cette classe et
accés aux variables et méthodes de classe
Le mode public n'est, bien sat, pas le seul type d'accés disponible en Java. Deux autres mot-
clés peuvent étre utilisés en plus du type d'accés par défaut : protected et private. Le tableau
3.arécapitule ces différents types d'accts (la notion de sous-classe est expliquée dans la section 4)
Taste 3.2 — Autorisations d'accés
public | protected | défaut | private
Dans la meme classe ‘Our Ou | ow | Ow
Dans une classe du ‘Oui ‘Oui | Oui | Non
méme package
Dans une sous-classe Oui Oui_| Non | Now
d'un autre package
Dans une classe queleon- | Oui Non | Non [Non
que d'un autre package
1sCChapitre 3. Eléments de programmation Java
Si aucun mot-clé ne précise le type d'accés, celui par défaut est appliqué. En général, il est
souhaitable que les types d'accts soient limités et le type d'accés public, qui est utilisé systéma-
tiquement par les programmeurs débutants, ne doit étre utilisé que s'il est indispensable, Cette
restriction permet d'éviter des erreurs lors d'accés & des méthodes ou de modifications de va-
riables sans connaitre totalement leur tle.
3.2.2 Variables et méthodes de classe
Dans certains cas, il est plus judicieux d'attacher une variable ou une méthode & une classe
plutdt qu’aux objets instanciant cette classe. Par exemple, la classe java. 1ang. Integer posséde
tune variable MAX_VALUE qui représente Ia plus grande valeur qui peut étre affectée & un entier.
Or, cette variable étant commune & tous les entiers, elle n'est pas dupliquée dans tous les objets
instanciant la classe Integer mais elle est associée directement @ la classe Integer. Une telle va-
riable est appelée variable de classe, Dela méme maniée, il existe des méthodes de classe qui sont.
associées directement & une classe. Pour déclarer une variable ou méthode de classe, on utilise le
mot-clé static qui doit étre précisé avant le type de la variable ou le type de retour de la méthode.
La classe java. 1ang.Math nous fournit un bon exemple de variable et de méthodes 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 Nath fournit un ensemble d'outils (variables et méthodes) trés utiles pour des pro-
grammes devant effectuer des opération mathématiques complexes. Dans la portion de classe
reproduite ci-dessus, on peut notamment y trouver une approximation de la valeur de 1 et une
méthode convertissant la mesure d'un angle d'une valeur en degrés en une valeur en radians. Dans
le cas de cette classe, il est tout a fait inutile de créer et d'instancier un objet & partir de la classe
Nath. En effet, la valeur de 1 ou la conversion de degrés en radians ne vont pas varier suivant
objet auquel elles sont rattachées. Ce sont des variables et des méthodes de classe qui peuvent
étre invoquées & partir de toute autre classe (car elles sont déclarées en accés public) de la maniére
suivante
public class MathMain (
public static void main(String[] args) (
system.out.printin("pi = " + Math.Pr);
Systen.out.printin("98° = ” + Math. toRadians(90));
‘> Question : Dans les sections précédentes, nous avons déja utilisé une variable de classe et une
méthode de classe. Pouver-vous trouver lesquelles ?
163.2. Variables et méthodes
”CChapitre 3. Eléments de programmation Java
8Chapitre 4
Héritage
Dans certaines applications, les classes utilisées ont en commun certaines variables, méthodes
de traitement ou méme des signatures de méthode. Avec un langage de programmation orienté-
objet, on peut définir une classe a différent niveaux d’abstraction permettant ainsi de factoriser
certains attributs communs plusicurs classes. Une classe générale définit alors un ensemble d'at-
tributs qui sont partagés par d'autres classes, dont on dira qui elles héritent de cette classe générale.
Par exemple, les classes Carre et Rectangle peuvent partager une méthode surface() ren-
voyant le résultat du calcul de la surface de la figure. Plutét que d’crire deux fois cette méthode,
on peut définir une relation d’héritage entre les classes Carre et Rectangle. Dans ce cas, seule la
classe Rectangle contient le code de la méthode surface() mais celle-ci est également utilisable
sur les objets de la classe Carre si elle hérite de Rectangle,
4.1. Principe deI’héritage
Liidée principale de I'héritage est d'organiser les classes de maniére hiérarchique. La relation
Ahéritage est unidirectionnelle et, si une classe B hérite d'une 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 hiérarchique de ces classes telle que Carre hérite de Rectangle qui hérite, ainsi que
Cercle, d'une classe Forme,
Forme
Rectangle Cercle
Carre
Frcure 4.1- Exemple de relations d’héritage
Pour le moment, nous considérerons la classe Forme comme vide (c'est-a-dire sans aucune
variable ni méthode) et nous nous intéressons plus particuliérement aux classes Rectangle et
19Chapitre 4, Héritage
Carre, La classe Rectangle héritant d'une classe vide, elle ne peut profiter d'aucun de ses attri-
buts et doit définir toutes ses variables et méthodes. Une relation ’héritage se définit en Java par
Je 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;
t
public int surface() ¢
return this.longueur * this. largeur;
y
Public void affiche() (
System.out.printIn(”rectangle ” + longueur + "x” + Largeur);
}
En revanche, la classe Carre peut bénéficier de la classe Rectangle et ne nécessite pas la ré-
écriture de ces méthodes sicelles-ci conviennent la sous-classe. Toutes les méthodes et variables
de la classe Rectangle ne sont néanmoins pas accessibles dans la classe Carre, Pour qu'un attri-
but puisse étre utilisé dans une sous-classe, il faut que son type d'accés soit public ou protected,
ou, siles deux classes sont situées dans le méme package, qu'il utilise le type d'accés par défaut.
Dans cet exemple, les variables longueur et largeur ne sont pas accessibles dans la class Carre
qui doit passer par les méthodes getLargeur() et getLongueur(), déclarées comme publiques.
4.1.1 Redéfinition
Lihéritage intégral des attributs de la classe Rectangle pose deux problémes
1. il faut que chaque carré ait une longueur et une largeur égales;
2. la méthode af fiche écrit le mot “rectangle” en début de chaine. Il serait souhaitable que
ce soit “carré” qui saffiche.
De plus, les constructeurs ne sont pas hérités par une sous-classe. Il faut donc écrire un construc-
‘eur spécifique pour Carre. Ceci nous permettra de résoudre le premier probléme en écrivant un.
constructeur qui ne prend qu'un paramétre qui sera affecté 4 la longueur et 4 la largeur. Pour
attribuer une valeur & ces variables (qui sont privées), le constructeur de Carre doit faire appel
204.1. Principe de Phértage
au constructeur de Rectangle en utilisant le mot-clé super qui fait appel au constructeur de la
classe supérieure comme suit,
public Carre(int cote) (
super (cote, cote);
= Remarques :
‘* Lapel au constructeur d'une classe supérieure doit toujours se situer dans un constructeur
et toujours en tant que premiere instruction ;
« Siaucun appel 4 un constructeur d'une classe supérieure n'est fait, le constructeur fait appel
implicitement & un constructeur vide de la classe supérieure (comme sila ligne super() était
présente). Si aucun constructeur vide n'est accessible dans la classe supérieure, une erreur se
produit lors de la compilation.
Le second probléme peut étre résolu par une redéfinition de méthode. On dit qu'une méthode
dune sous-classe redéfinit une méthode de sa classe supérieure, si elles ont la méme signature
mais que le traitement effectué est ré-écrit dans la sous-classe. Voici le code de la classe Carre oit
sont résolus les deux problémes soulevés
public class Carre extends Rectangle {
public Carre(int cote) ¢
super(cote, cote);
>
public void affiche() ¢
System.out.printin(”carré
+ this.getLongueur());
>
Lors de la redéfinition d'une méthode, il est encore possible d’accéder & la méthode redi
nie dans la classe supérieure, Cet accés utilise également le mot-clé super comme préfixe & Ia
méthode. Dans notre cas, il faudrait écrire super.affiche() pour effectuer le traitement de la
méthode affiche() de Rectangle.
Enfin, ilest possible d’interdire la redéfinition d’une méthode ou d'une variable en introdui-
sant le mot-clé Final au début d'une signature de méthode ou d'une déclaration de variable. I!
est aussi possible d interdire Phéritage d'une classe en utilisant final au début de la déclaration,
dune classe (avant le mot-clé class).
4.1.2. Polymorphisme
Le polymorphisme est la faculté attribuée 4 un objet d’étre une instance de plusieurs classes.
Ta une seule classe “réelle” qui est celle dont le constructeur a été appelé en premier (Cest-A-dire
la classe figurant aprés le new) mais il peut aussi étre déclaré avec une classe supérieure & sa classe
réelle. Cette propriété est trés utile pour la création d ensembles regroupant des objets de classes
différentes comme dans lexemple suivant
aChapitre 4, Héritage
Forne[] tableau = new Forme[4];
tableau[o] = new Rectangle(10,20);
tableau[1] = new Cercle(15);
tableau[2] = new Rectangle(5,30);
tableau[3] = new Carre(10);
Lopérateur instanceof peut étre utilisé pour tester l'appartenance une classe comme suit,
for (int i = @ ; i < tableau.length ; i++) {
if (tableau[i] instanceof Forme)
System.out.printIn(”element ” + 1 +” est une forme”);
if (tableau[i] instanceof Cercle)
System.out.printIn(”element ” + 1 +” est un cercle”);
if (tableau[i] instanceof Rectangle)
System.out.printIn(”element ” + i +” est un rectangle”)
if (tableau[i] instanceof Carre)
System.out.printIn(”element ” + 1 +” est un carré”);
Lexécution de ce code sur le tableau précédent affiche le texte suivant
clement [2] est une forne
elenent[0] est un rectangle
elenent[1] est une forne
elenent[1] est un cercle
elenent[2] est une forme
elenent[2] est un rectangle
elenent[3] est une forne
elenent[3] est un rectangle
elenent[3] est un carré
Liensemble des classes Java, y compris celles crites en dehors de API, forme une hiérarchie
avec une racine unique, Cette racine est la classe Object dont hérite toute autre classe. En effet, si
‘vous ne précisez pas explicitement une relation d’héritage lors de Vécriture d'une classe, celle-ci
hérite par défaut de la classe Object. Grace A cette propriété, des classes génériques' de création
et de gestion d'un ensemble, plus élaborées que les tableaux, regroupent des objets appartenant &
la classe Object (donc de n'importe quelle classe)
Une des propriétés induites par le polymorphisme est que T'interpréteur Java est capable de
trouver le traitement effectuer lors de 'appel d'une méthode sur un objet. Ainsi, pour plusieurs
objets déclarés sous la méme classe (mais n’ayant pas la méme classe réelle),le traitement associé &
tune méthode donné peut étre différent. Si cette méthode est redéfinie par la classe réelle d'un objet
(ou par une classe située entre la classe réelle et la classe de déclaration), le traitement effectué est
celui défini dans la classe la plus spécifique de l'objet et qui redéfinie la méthode.
Dans notre exemple, la méthode afFiche() est redéfinie dans toutes les sous-classes de Forme
et les traitements effectués sont
for (int i = @ ; 4 < tableau.length ; i++) {
tableau[i].affiche();
}
‘voir par exemple les lasses Java util. Vector, java.util nashtable,
242. Interfaces
Résultat
rectangle 10x20
cercle 15
rectangle 5x30
carré 10
Dans Wétat actuel de nos classes, ce code ne pourra cependant pas étre compilé. En effet, la
fonction afFiche() est appelée sur des objets dont la classe déclarée est Forme mais celle-ci ne
contient aucune fonction appelée affiche() (elle est seulement définie 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 méme titre qu'une classe, mais abstrait et qui donc ne peut étre
instancié (par appel & new plus constructeur). Une interface décrit un ensemble de signatures de
miéthodes, sans implémentation, qui doivent étre implémentées dans toutes les classes qui iim
plémentent Vinterface. L'utilité du concept interface réside dans le regroupement de plusieurs
classes, tel que chacune implémente un ensemble commun de méthodes, sous un méme type. Une
interface posséde les caractéristiques suivantes
« elle contient des signatures de méthodes;
« elle ne peut pas contenir de variables
«© une interface peut hériter d'une autre interface (avec le mot-clé extends)
«# une classe (abstraite ou non) peut implémenter plusieurs interfaces. La liste des interfaces
implémentées doit alors figurer apres le mot-clé implements placé dans la déclaration de
classe, en séparant chaque interface par une virgule.
Dans notre exemple, Forme peut étre une interface décrivant les méthodes qui doivent étre
implémentées par les classes Rectangle et Cercle, ainsi que parla classe Carre (méme si celle-ci,
peut profiter de son héritage de Rectangle). L'interface Forme s’écritalors dela manire suivante
public interface Forme (
public int surface() ;
public void affiche() ;
Pour obliger les classes Rectangle, Cercle et Carre & implémenter les méthodes surface()
et affiche(), il faut modifier Phéritage de ce qui était la classe Forme en une implémentation de
interface définie ci-dessus
public class Rectangle implements Forme {
y
et
Public class Cercle implements Forme {
y
2BChapitre4. Héritage
Cette structure de classes nous permet désormais de pouvoir compiler 'exemple donné dansla
section 4.1.2 traitant du polymorphisme. En déclarant un tableau constitué d’objets implémentant
interface Forme, on peut appeler la méthode af Fiche() qui existe et est implémentée par chaque
objet.
Siune classe implémente une interface mais que le programmeur n'a pas écrit 'implémenta-
tion de toutes les méthodes de l'interface, une erreur de compilation se produira sauf sila classe
est une classe abstraite.
4.3 Classes abstraites
Le concept de classe abstraite se situe entre celui de classe et celui d'interface, Cest une classe
qu'on ne peut pas directement instancier car certaines de ses méthodes ne sont pas implémen-
tées, Une classe abstraite peut done contenir des variables, des méthodes implémentées et des
signatures de méthode & implémenter. Une classe abstraite peut implémenter (partiellement ou
totalement) des interfaces et peut hériter d'une classe ou d'une classe abstraite
Le mot-clé abstract est utilisé devant le mot-clé class pour déclarer une classe abstraite,
ainsi que pour la déclaration de signatures de méthodes & implémenter,
Imaginons que l'on souhaite attribuer deux variables, origine_x et origine_y, & tout objet
représentant 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
public void setOriginey(int y) ¢
this.origine_y = y;
public abstract int surface();
public abstract void affiche();
2444, Classes et méthodes génériques
De plus, il faut rétablir V'héritage des classes Rectangle et Cercle vers Forme
public class Rectangle extends Forne {
}
et
public class Cercle extends Forme {
Lorsqu’une classe hérite d'une classe abstraite, elle doit
« soit implémenter les méthodes abstraites de sa super-classe en les dotant d'un corps;
« soit étre elle-méme abstraite si au moins une des méthodes abstraites de sa super-classe
reste abstraite
44 Classes et méthodes génériques
Test parfois utile de définir des classes paramétrées par un type de données (ou une classe)
Par exemple, dans le package java.util, de nombreuses classes sont génériques et notamment
les classes représentant des ensembles (Vector, ArrayList, etc.). Ces classes sont génériques dans
le sens oit elles prennent en paramatre un type (classe ou interface) quelconque E. € est en quelque
sorte une variable qui peut prendre comme valeur un type de donné. Ceci se note comme suit, en
prenant 'exempe de java.util ArrayList
package java.util ;
public class ArrayList
extends AbstractList
implements List, ...
public & set(int index, € element) {
public boolean add(E e) (
‘Nous pouvons remarquer que le type passé en paramétre est noté entre chevrons (ex : ),
et quill peut ensuite étre réutilisé dans le corps de a classe, par des méthodes (ex: a méthode set
renvoie un élément de classe €)
est possible de définir des contraintes sur le type passé en paramétre, comme par exemple
une contrainte de type extends*
2. Td, on utlise T extends & pour signaler que le type T est un sous type de E, que € soit une classe ov une
interface (on n’utlise pas implements).
25Chapitre 4, Héritage
public class SortedList
En bref, nous définissons une liste ordonnée d’éléments comparables entre eux (pour pouvoir les
trier), grace 4 la méthode int conpareTo(T 0) de Interface Comparable? qui permet de com-
parer un Comparable 4 un élément de type T
a. Tang. Comparable pour plus d information sur cete interface.
26Chapitre 5
Gestion des exceptions
Lors de Iécriture d’un programme, la prise en compte d’erreurs prend une place trés impor
tante sil'on souhaite écrire un programme robuste. Par exemple, la simple ouverture d'un fichier
peut provoquer beaucoup d'erreurs telles que Iinexistence du fichier, un mauvais format, une in-
terdiction d’accés, une erreur de connexion au périphérique, ... Pour que notre programme soit
robuste, il faut que toutes les erreurs possibles soient détectées et traitées.
Certains langages de programmation, dont le langage Java, proposent un mécanisme de prise
en compte des erreurs, fondé sur la notion d’exception. Une exception est un objet qui peut étre
émis par une méthode si un événement dordre “exceptionnel” (les erreurs rentrent dans cette
catégorie) se produit. La méthode en question ne renvoie alors pas de valeur de retour, mais met
une exception expliquant la cause de cette émission. La propagation d'une émission se déroule
selon les étapes suivantes
1. Une exception est générée a lintérieur d'une méthode;
2, Sila méthode prévoit un traitement de cette exception, on va au point 4, sinon au point 3;
3. Llexception est renvoyée & la méthode ayant appelé la méthode courante, on retourne au
point 2;
4, Llexception est traitée et le programme reprend son cours aprésle traitement de exception.
La gestion erreurs par propagation d’exception présente deux atouts majeurs
+ Une facilité de programmation et de lisibilité:il est possible de regrouper la gestion d'er-
reurs un méme niveau. Cela évite des redondances dans 'écriture de traitements d’erreurs
et encombre peu le reste du code avec ces traitements.
+ Une gestion des erreurs propre et explicite: certains langages de programmation utilisent
Ja valeur de retour des méthodes pour signaler une erreur a la méthode appelante. Etant
donné que ce n’est pas le rdle dela valeur de retour de décrire une erreur, il est souvent im-
possible de connaitre les causes réelles de erreur, La dissociation dela valeur de retour et de
exception permet cette derniére de décrire précisément la ligne de code ayant provoqué
erreur et la nature de cette erreur.
5.1 Déclaration
Mest nécessaire de déclarer, pour chaque méthode, les classes d'exception qu'elle est suscep-
tible d’émettre. Cette déclaration se fait a la fin de la signature d’une méthode par le mot-clé
throws a la suite duquel les classes d’exceptions (séparées par une virgule s'il en existe plusieurs)
qui peuvent étre générées sont précisées. La méthode parsetnt de la classe Integer est un bon
exemple :
7Cchapitre 5. Gestion des exceptions
public static int parseInt(String s) throws NumberFormatException {
y
Cette méthode convertit une chaine de caractéres, qui doit contenir uniquement des chifftes,
en un entier. Une erreur peut se produire si cette chaine de caractéres ne contient pas que des
chifites. Dans ce cas une exception de la classe NunberFormat xcept ion est émise.
Une exception peut étre émise dans une méthode de deux maniéres : (i) par une autre mé-
thode appelée dans le corps de la premiére méthode ; (ii) par la création d'un objet instanciant la
classe Exception (oula classe Throwable) et la evée explicite del'exception en utilisant le mot-clé
throw.
L’exemple ci-dessous illustre ce second cas
public class ExenpleException {
*
* Cette méthode renvoie Le nom du mois
* correspondant au chiffre donné en paranétre.
* Si celui-ci n’est pas valide une exception de classe
* IndexOutofBoundsException est Levée.
v7
public static String month(int mois)
‘throws IndexOutoffoundsException {
if ((mois < 1) || (mois > 12)) ¢
throw new IndexOutOffoundsException(
"Ye nunero du nois qui est ”
+” doit @tre compris entre 1 et 12”);
4 (mois
y)
return "Janvier";
else if (mois == 2)
return "Février”;
else if (mois == 11)
return "Novenbre”;
else
return "Décenbre”;
La signification des exceptions de la classe IndexOutofBoundsException est qu'un index
donné dépasse les bornes minimum et maximum qu'il devrait respecter. Si une méthode de-
mande la chaine de caractéres correspondant & des mois inexistants (inférieur & 1 ou supérieur
4 12) une exception signalera cette erreur. On peut remarquer dans cet exemple que la détection
et la formulation de I'erreur sont codées dans la méthode mais pas son traitement.
285.2. Interception et traitement
5.2 Interception et traitement
Avant de coder le traitement de certaines exceptions, il faut préciser l'endroit oii elles vont
étre interceptées, Si une méthode A appelle une méthode 8 qui appelle une méthode ¢ qui appelle
tune méthode , et que cette méthode O léve une exception, celle-ci est d'abord transmise & C qui
peut lintercepter ou la transmettre 4 8, qui peut aussi intercepter ou la transmettre 4 A.
interception d'exceptions se fait par une sorte de “mise sur éoute” d'une portion de code
Pour cela on utilise le mot-clé try suivi du bloc & surveiller. $i aucune exception ne se produit
dans le bloc correspondant, le programme se déroule normalement comme si instruction try
Atait absente, Par contre, si une exception est levée, le traitement de l'exception est exécuté puis
Yexécution du programme reprend son cours aprés le bloc testé
Test également nécessaire de préciser quelles classes d'exception doivent étre interceptées
dans le bloc testé. Linterception d'une classe d'exception s écrit grace au mot-clé catch suivi de
la classe concerné, d'un nom de variable correspondant & lobjet exception, puis du traitement.
Si une exception est levée sans qu’aucune interception ne soit prévue pour sa classe, celle-ci est
propagée a la méthode précédente.
Dans Yexemple ci-dessous, le programme demande & Tutilisateur de saisir le numero d'un
mois et affiche & l'écran le nom de ce mois. Les exceptions qui peuvent étre levées par ce pro-
gramme sont traitées
public class ExempleTraitementéxception (
public static void main(string[] args) {
System.out.print(”Entrez le numero d’un mois : ”);
try (
BufferedReader input = new BufferedReader(
new InputStreanReader (System. in));
String choix = input.readLine();
int numero = Integer. parseint (choix) ;
System. out. print1n(Exemple€xception month (numero) );
} catch (IndexoutofBoundséxception e) (
System.err.printIn(”Nunero incorrect :
+ e.getMessage());
} catch (NumberFormatexception e) (
System.err.printIn("Entrée incorrecte : ”
+ e.getMessage());
} catch (TOException e) ¢
‘System.err.printIn(”Erreur dacces : ”
+ e.getMessage());
‘Trois classes dexception sont ici traitées
# IndexoutofBoundsexceptiion (levé par la méthode month) se produit si le numero entré
par 'utilisateur est inférieur 41 ou supérieur & 125
+ NunberFormatexception (levé par la méthode parseInt) qui se produit si le texte entré
par Putilisateur n’est pas convertible en entier
# ToException (levé par la méthode readL ine) qui se produit siil y a eu une erreur @accés
au périphérique d’entrée.
29Cchapitre 5. Gestion des exceptions
Dans chacun de ces cas, le traitement consiste & afficher le message d’erreur associé & l'exception,
5.3. Classes d’exception
Une classe est considérée comme une classe d'exception dés lors qu'elle hérite de la classe
Throwable. Un grand nombre de classes 'exception sont proposées dans I'API pour couvrir les
catégories d'erreurs les plus fréquentes. Les relations d’héritage entre ces classes permettent de
lever ou d'intercepter des exceptions décrivant une erreur & différents niveaux de précision. Les
classes d'exception les plus fréquemment utilisées sont récapitulées dans le tableau 51.
Tans 5.1 - Classes d’exception fréquentes
Classe Description.
‘ANTException Tes exceptions de cette classe peuvent se
produire lors d’opérations de type
graphique.
Classtastéxception Signale une erreur lors de la conversion
d'un objet en une classe incompatible
avec sa vraie classe
FileNotFoundexception Signale une tentative Couverture @un
fichier inexistant
TndexOutofBoundsException | Se produit lorsque Ton essaie daccéder
un élément inexistant dans un.
ensemble.
TOException Tes exceptions de cette classe peuvent se
produire lors d'opérations d'entrées/
sorties
NullPointerException Se produit lorsqu'un pomnteur null
est recu par une méthode n’acceptant
pas cette valeur, ou lorsque on
appelle une méthode ow une variable
partir d'un pointeur null.
oF Remarque : Il n'est pas indispensable d'intercepter les exceptions héritant de la
classe RuntimeException (dans le tableau ci-dessus, les classes qui en héritent sont
ClassCastexception, IndexoutofBoundsException et Nul1PointerException). Celles-ci
peuvent étre propagées jusqu'a la machine virtuelle et n'apparaitre que pendant l'exécution, Ces
‘exceptions sont appelées exception non vérifiges ou unchecked exceptions,
Si aucune des classes d'exception ne correspond a un type d'erreur que vous souhaitez ex-
primer, vous pouvez, également écrire vos propres classes d'exception. Pour cela, il suffit de faire
hériter votre classe de la classe java. lang. Exception
5.4 Classification des erreurs en Java
‘On peut finalement distinguer quatre types de situations d'erreurs en Java:
305.4, Classification des erreurs en Java
Erreurs de compilation. Avant méme de pouvoir exécuter le programme, notre code source gé-
nie des erreur parle compilateur. Il faut alors réviser et corriger le code pour ne plus avoir
erreurs
Erreurs d’exécution. Alors que notre programme est en cours d'exécution, la JVM étant mal
configurée ou corrompue, le programme s'arréte ou se géle. A priori, c'est une erreur non
pas due a notre programme, mais & la configuration ou l'état de l'environnement d'exécu-
tion de notre programme.
Exception non vérifiée. Alors que notre programme est en cours @exécution, une trace della pile
des exceptions est affichée, pointant vers une partie de notre code sans gestion d’exception,
Visiblement, nous avons utilisé du code qui est capable de lever un exception non vérifige
(comme NuL1Pointer€xception). Il faut modifier le programme pour que cette situation
ne survienne pas.
Exception vérifiée. Alors que notre programme est en cours d’exécution, une trace de la pile des
exceptions est affichée, pointant vers une partie de notre code avec gestion d'exception.
Visiblement, nous avons produit du code qui est capable de lever un exception vérifige
(comme FileNotFoundException) mais les données passées & notre programme ne valide
pas ces exceptions (par exemple, lorsque l'on essaie d'ouvrir un fichier qui n’existe pas). I!
faut alors revoir les données passées en paramétre du programme. Notre code a bien détecté
les problémes qu'il fallait détecter. Le chapitre suivant sur les entrées/sorties présentent de
nombreux exemples relatifs & ce cas.
31Cchapitre 5. Gestion des exceptions
32Chapitre 6
Gestion des entrées/sorties simples
‘Le package java. io propose un ensemble de classes permettant de gérer la plupart des en.
trées/sorties d'un programme. Cette gestion consiste a créer un objet flux dans lequel transitent
les données & envoyer ou 4 recevoir. Un flux connecte un objet Java & un autre élément. Deux cas
sont illustrés dans ce chapitre : les interactions avec un utilisateur (entrée clavier et sortie écran)
et les accés en lecture ou écriture 4 un fichier.
6.1 Flux d’entrée
Un flux d’entrée est une instance d’une sous-classe de InputStream, Chaque classe de flux
entrée a son propre mode d’échange de données qui spécifie un format particulier de données
ou un accés particulier. Les classes les plus couramment utilisées sont
« ByteArrayInputStream permet de lire le flux d’entrée sous la forme doctets (byte)
« DatalnputStream permet de lire le flux d’entrée sous la forme de types de données primitifs
de Java, Il existe des méthodes pour récupérer un entier, un réel, un caractére,
«+ FileInputStream est utilisé pour lire le contenu d'un fichier. Les objets de cette classe sont
souvent encapsulés dans un autre objet de classe InputStream qui définit le format des
données a lire.
+ ObjectinputStream permet de lire des objets (c-a-d des instances de classes Java) & par-
tir du flux d’entrée, si ces objets implémentent les interfaces java.io.Serializable ou
java.io. Externalizable
« Reader n'est pas une sous-classe de InputStream mais représente un flux d’entrée pour
chaines de caractéres. Plusieurs sous-classes de Reader permettent la création de flux pour
chaines de caractéres,
# Scanner n’est pas une sous-classe de InputStream, mais un Iterator qui permet de lire
un flux (fichier ou chaine de caractéres par exemple) “mot” par “mot” en définissant le
délimiteur entre les mots (espace par défaut),
La lecture de données & partir d’un flux d'entrée suit le déroulement suivant
1, Ouverture du flux : Elle se produit ala création d’un objet dela classe InputStream, Lors de
Yappel au constructeur, on doit préciser quel élement externe est relié au flux (par exemple
‘un nom de fichier ou un autre flux)
2. Lecture de données : Des données provenant du flux sont lues au moyen de la méthode
read()) ou d'une méthode équivalente. La méthode précise a employer dépend du type de
flux ouvert.
3. Fermeture du flux : Quand le flux n’est plus nécessaire, il doit étre fermé par la méthode
close),
33CChapltre 6. Gestion des entrées/sorties simples
614
Les données provenant de utilisation du clavier sont transmises dans un flux d'entrée créé
automatiquement pour toute application Java, On accéde & ce flux par la variable statique de la
classe java. lang. Systen qui s'appelle in, Ce flux est alors utilisé comme paramatre d'entrée du
constructeur d'un autre flux d'entrée, Pour cet autre flux, on utilise généralement une sous-classe
de Reader pour récupérer les entrées de T'utlisateur sous la forme d'une chaine de caractéres. La
Lecture des entrées clavier
classe Clavier en donne un exemple
import java.io.
public class Clavier (
public static void main(string[] args) {
try (
BufferedReader flux = new BufferedReader(
new InputStreamReader (System. in));
system.out.print(”Entrez votre prenom
String prenom = flux.readLine();
Systen.out.print1n(”Bonjour ” + prenom) ;
flux.close();
catch (IOException ioe) {
System. err. printIn(ioe) ;
“ys
6.1.2 Lecture partir d’un fichier
Un fichier est représenté par un objet de la classe java.io.File. Le constructeur de cette
classe prend en paramétre d’entrée le chemin d’accés du fichier. Le flux d’entrée est alors cxéé
4 aide de la classe FileInputStream sur lequel on peut lire caractére par caractére grace a la
méthode read(). L’exemple suivant présente une méthode pour afficher le contenu d'un fichier
46.1 Flux dientrée
import java.io.*;
public class LectureFichier {
public static void main(String[] ares) {
try {
File fichier = new File("nonFichier.txt”);
FileInputstrean flux = new FileTnputstrean(fichier) ;
Ant ¢;
while ((¢ = flux.read()) > -1) ¢
systen. out write(c);
+
flux. close();
} catch (FileNotFoundexception e) (
e.printStackTrace();
} catch (IOException e) (
e.printStackTrace();
+
}
}
arrive souvent d enregistrer des données dans des fichiers textes. I peut alors étre utile d’uti-
liser un BufferedReader ou un Scanner pour effectuer la lecture. Dans les exemples suivants, on
considére une matrice 10 x 10 enregistrée dans un fichier texte matrice. txt ligne par ligne, avec
les colonnes séparées par des espaces
import java.io.*;
public class Lecturematrice {
public static void main(String[] args) {
try {
FileReader fileReader = new FileReader("natrice.txt”);
BufferedReader reader = new BufferedReader (fileReader) ;
while (reader.ready())
String[] line = reader.readLine().split(” ”)
for (String s : line) {
system.out.print(s);
System. out .printIn();
y
reader. close();
fileReader.close();
} catch (FileNotFoundexception e) (
e.printStackTrace();
} catch (10Exception e) (
e.printstackTrace();
}
}
y
35CChapltre 6. Gestion des entrées/sorties simples
‘On peut effectuer un traitement similaire avec un Scanner
import java.io.*;
import java.util.scanner;
public class LectureMatriceScanner {
public static void main(String[] args) {
try (
Scanner fileScanner = new Scanner(new File(”natrice.txt”));
while (fileScanner.hasNextLine()) {
Scanner lineScanner = new Scanner (fileScanner.nextLine());
while (LineScanner.hastiext())
-print(LineScanner.next());
println();
system.o)
system
} catch (FileNotFoundexception e) {
e.printStackTrace();
}
}
y
6.1.3 Lecture d’objets enregistrés
est parfois utile d’enregistrer état d objet (de nimporte quelle classe implémentant les in-
terfaces java. io. Serializable ou java.io. Externalizable) pour des exécutions futures. Le
flux d’entrée est encore créé aide de a classe FileTnputStrean et est ensuite encapsulé dans un
autre flux spécifiant le format des données lire. L’exemple suivant illustre la lecture d'un objet
de la classe Date dans un fichier nommé monFichier.dat
import java.io.*;
import java.util.pate;
public class LectureDate (
public static void main(String[] args) {
try (
File fichier = new File(”nonFichier.dat”) ;
ObjectInputstream flux = new ObjectInputstream(
new FileInputStream(fichier)) ;
Date lapate = (Date) flux.readobject();
System. out. printIn(labate) ;
flux.close();
} catch (IOException ice) {
System. err. printIn(ioe) ;
} catch (ClassNotFoundexception cnfe) (
system. err. printIn(enfe) ;
Liobjet qui est lu dans le fichier doit étre une instance de la classe java.util.Date.
366.2. Flux de sortie
6.2 Fluxde sortie
Un flux de sortie est une instance d'une sous-classe de OutputStream, Comme pour les flux
entrée, chaque classe de flux de sortie a son propre mode d’écriture de données, Les classes les
plus couramment utilisées sont
+ ByteArrayOutputStream permet d’écrire des octets vers le flux de sortie;
+ DataOutputStream permet d'écrire des types de données primitifs de Java vers le flux de
sortie
+ FileOutputStream est utilisé pour écrire dans un fichier. Les objets de cette classe sont
souvent encapsulés dans un autre objet de classe OutputStrean qui définit le format des
données a écrire.
# ObjectOutputStream permet ’écrire des objets (c-4-d des instances de classes Java) vers le
flax de sortie, ices objets implémentent les interfaces Serializable ou Externalizable
# Writer n’est pas une sous-classe de OutputStream mais représente un flux de sortie pour
chaines de caractéres. Plusieurs sous-classes de Writer permettent la création de flux pour
chaines de caractéres,
Liécriture de données vers un flux de sortie suit le méme déroulement que la lecture d’un flux
dentrée
1. Ouverture du flux : Elle se produit lors de la création d'un objet de la classe OutputStream,
2, Ecriture de données : Des données sont écrites versle flux au moyen dela méthode write()
ou d'une méthode équivalente. La méthode précise & employer dépend du type de flux ou-
vert
3. Fermeture du flux : Quand le flux n’est plus nécessaire, il doit étre fermé par la méthode
close(),
6.2.1 Ecriture surla sortie standard “écran”
Comme pourles entrées du clavier, lécriture vers écran fait appel la variable statique out de
laclasse Systen, On appelle généralementla méthode System. out. print ou Systen.out.println
comme cela a été fait dans de nombreux exemples de ce livret
6.2.2 Ecriture dans un fichier
Lécriture dans un fichier se fait par un flux de la classe FiledutputStream qui prend en
entrée un fichier (instance de la classe File). Ce flax de sortie permet d’écrire des caractéres dans
le fichier grace & la méthode write(). L’exemple suivant présente une méthode pour écrire un
texte dans un fichier
37CChapltre 6. Gestion des entrées/sorties simples
import java.io.*;
public class EcritureFichier (
public static void main(string[] ares) {
try (
File fichier = new File(*sonFichier. txt”);
Fileoutputstrean flux = new FileOutputstrean(fichier) ;
String texte = "Hello World!”;
for (int i = 0; i < texte.length(); i++) {
flux.urite(texte.charat(1))3
flux.close();
} catch (FileNotFoundexception e) {
e.printStackTrace();
} catch (IOException e) {
e-printStackTrace();
On peut également utiliser un Writer comme un FileWiriter pour écrire des chaines de
caractéres dans un fichier assez simplement, Dans 'exemple suivant, on écrit une série de 10
lignes de 10 entiers aléatoires séparés par des espaces dans un fichier pouvant étre lu parla classe
Lecturematrice
import java.io.*;
import java.util.Random;
public class Ecriturematrice (
public static void main(String[] args) {
try (
Filenriter writer = new FileWriter(”randon.txt”) ;
Randon generator = new Random(System. current Tinemillis());
for (int i= 0; 1 <9; it) {
for (int j= 0; 4< 9; J++)
weiter. write(generator.nextint() +”
writer write(”\n");
weiter.close();
} catch (FileNotFoundexception e) (
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
386.2. Flux de sortie
6.
3 Ecriture d’objets
Le flux de sortie peut également étre encapsulé dans un flux de type ObjectoutputStrean,
comme le montre Pexemple suivant pour écrire la date courante dans un fichier
import java.io.*;
import java.util.pate;
public class EcritureDate (
public static void main(String[] args) {
try {
File fichier = new File(”monFichier.dat”) ;
ObjectOutputstream flux = new ObjectOutputstream(
new FileOutputstrean(fichier)) ;
flux.writeobdject(new Date());
flux. close();
catch (T0Exception ioe) {
system.err.printIn(ioe) ;
Ce fichier peut ensuite étre lu par la classe Lecturebate.
= Remarque importante : Nous avons présenté dans ce chapitte plusieurs exemples d’entrée/-
sortie utilisant différents modes de lecture/écriture (avec ou sans flux). Nous conseillons toutefois:
utiliser en priorité un Scanner pour lalecture dans un fichier, et un FileWriter pour Iécriture
dans un fichier
39CChapltre 6. Gestion des entrées/sorties simples
40AnnexesAnnexe A
Applications graphiques (package swing)
Annexe
Lors des premiéres versions du langage Java, le seul package fourni par défaut par Java SE
permettant de construire des interfaces graphiques était le package java. awt. Depuis la version
14 du JDK, ilest trés fortement recommandé d'utiiser 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"Iégers” (lightweight) contrairement aux composants “lourd-
s° (heavyweight) d'awt. L’apparence graphique d'un composant dit lourd dépend du sys-
téme dexploitation car elle fait appel A un composant correspondant dans le systéme d’ex-
ploitation, Avec un composant léger, son apparence (look-and-feel) est fixée et peut étre
modifiée dans le code Java et il est donc possible de donner & une fenétre une apparence &
la Windows tout en utilisant Linux.
# applique complétement le schéma Modéle-Vue-Contrdleur (cf. section A.)
1a plupart des classes de composants du package swing héritent de classes du package awt
en redéfinissant certaines méthodes pour assurer les deux avantages précédemment cités. Cepen-
dant, le package awt n'est pas entiérement obsolete et certaines de ces classes sont encore utilisées,
pour la gestion d’événements (cf. section A.3) ow la disposition des composants (classes implé-
mentant interface Layout Manager)
A.1_ Le schéma Modéle-Vue-Contréleur
Le schéma Modéle-Vue-Contréleur (MVC) est un mode de conception dapplications gra-
phiques préconisant la distinction des données, de leur apparence graphique et des traitements
qui peuvent étre effectués. Un composant graphique est décomposé en trois parties
« le modele contenant ses données et son état courant;
« la vue qui correspond a son apparence graphique;
« le contréleur associant des traitements 3 des événements pouvant se produire au sein du
composant.
La figure A.1donne un exemple d'une interface graphique simple contenant un bouton “Quitter’
la decomposition MVC de ce bouton (instance de la classe 38utton) est constituée : (i) du
modéle contenant la chaine de caractéres “Quitter” ; (ii) de la vue constituée d'un rectangle gris
bord noir, d'une taille donnée, a une position donnée et au sein duquel est écrite la chaine de
caractéres du modéle; (iii) du contrOleur implémentant le traitement A effectuer lors d'un click
sur le bouton, 'est-a-dire lappel 4 instruction de fermeture de la fenétre.
Tous les composants graphiques du package swing ont un modéle, une vue et peuvent avoir
plusieurs contréleurs. Pour faciliter la programmation, certaines classes (tel que 38utton) encap-
sulent le modéle et la vue dans une seule classe disposant de méthodes d'accds et de modifications
a‘Annexe A. Applications graphique (package swing)
Exemple de bouton
Frovre A.1- Exemple de 3Button
des données ou de l'apparence. Dans ces cas-la, un modéle par défaut est utilisé
A.2__Composants graphiques
Dans un programme Java, une classe de composant graphique est une classe qui hérite de
Java.awt.Conponent. Il est indispensable dhériter de cette classe car elle implémente de nom-
breuses méthodes nécessaires & l'alfichage du composant, en renvoyant la dimension du compo
sant, sa police de caractéres, sa couleur de fond, etc.
La seconde classe essentielle pour l'écriture d’interfaces graphiques est la classe Container.
‘Un container est un composant (qui hérite donc de Component) mais avec la particularité de pou-
voir contenir @autres composants. Ainsi, une interface graphique est un objet d'une classe de
type java. awt Container (par exemple une fenétre ou une boite de dialogue) regroupant des
simples composants et d'autres containers qui, eux aussi, contiennent autres simples compo:
sants et containers, et ainsi de suite.
A.2.1 Composants
‘Nous ne présentons pas ici toutes les classes de composants du package swing pour nous in-
téresser plutat a la vue et au modéle de chaque composant. L'utilisation de certains composants
estillustrée dans la section A.2.3,
Vue
L/apparence graphique d’un composant est le résultat de limplémentation de la méthode
paint) dela classe Component. Quasiment toutes les classes héritant de Component redéfinissent
cette méthode afin de définir V'affichage du composant. Si vous écriver une classe héritant d'une
classe de composant existante, il est donc fortement déconseillé de redéfinir la méthode paint
pour la plupart des composants existants car vous empécheriez son affichage normal.
Sivous souhaiter définir Vaffichage d’un composant personnalisé (par exemple pour afficher
‘une image ou des formes géomeétriques), vous devrez faire hériter votre classe de composant dela
classe Java. awt .Canvas qui représente un composant vide, Dans ce cas-Ia, il est soubaitable de
redéfinir la méthode paint () qui est vide dans la classe Canvas.
Modéle
existe pour chaque classe de composant, une seconde classe qui gére le modele de ce com-
posant (par exemple, ButtonModel représente un modéle de bouton). En général un modéle par
défaut est créé dansle constructeur du composant, Laces 4 ce modéle est trés souvent masqué car
ilexiste des méthodes, telles que set Text () pour changer le texte d'un bouton ou setSelected()
pour changer l'état d'une case & cocher, de la classe de composant qui peuvent étre directement
appelées pour changer les données du modele. Cependant, pour des composants plus complexes
“4‘A2. Composants graphiques
tels que des tables (Table) ou des arborescences (JTree), il est parfois indispensable de créer un
modele personnalisé
A.2.2 Containers
En premier liu, il convient de rappeler qu'un container est un composant, et, par conséquent,
que tout ce qui a été présenté précédemment est aussi vrai pour les containers. En plus des ca-
ractéristiques d'un composant simple, un container contient un ensemble de composants ainsi
que des contraintes sur leur disposition. L'ajout d'un composant & un container se fait par une
méthode add (). Il existe plusieurs méthodes add() acceptant des paramitres d'entrée différents.
La méthode & utiliser dépend du type de disposition choisi,
osition des composants
Lrobjet qui gére la disposition des composants est une instance d'une classe qui doit implé
menter interface java. ant. LayoutManager. Cet objet doit étre ajouté au container, soit lors de
Vappel & son constructeur, soit par la méthode setLayout(). Un seul LayoutManager est auto-
risé par container. Quelques classes utilisées pour la disposition des composants sont présentées
ci-dessous.
jerLayout. Le container est découpé en cing cases : une case par cdté (gauche, droite, haut
et bas) et une au centre. L’ajout d'un composant se fait en précisant la case & utiliser grace & des
variables de classe de BorderLayout
MyContainer. add (MyComponent , BorderLayout .NORTH) ;
MyContainer. add (MyComponent2, BorderLayout..CENTER) 5
La taille de chaque case dépend : (i) de la largeur maximale entre la case du nord, du sud et
Yaddition des largeurs des cases du centre, de est et de !ouest: (ii) dela hauteur maximale entre
Ia case A lest, & Fouest et 'addition des hauteurs des cases du centre, du nord et du sud. La case
du centre est étirée pour remplir tout I'espace restant
Border ayout NORTH
BorderLayout. WEST BordetLayout.CENTER | BorderLayou.EAST
BorderLayout. SOUTH
Froure A.2 - Découpage du BorderLayout
45‘Annexe A. Applications graphique (package swing)
Comp! |] Comp2 |} Comps
Frovre A.3 - Découpage du FlowLayout
Compl |] Comp2 |] Comps |] Comps
Comps |] Comps |] Comp? |] Comps
Comp9 || Comp10]] Comptt |} Compi2
Fiore A.4- Découpage d'un GridLayout 3x4
FlowLayout. Les composants sont ajoutés les uns & la suite des autres et de la gauche vers la
droite. Das qu'une ligne est remplie de composants (c'est-A-dire dés que la largeur du container
est atteinte, les composants restants sont ajoutés sur une ligne en dessous. Il n'y a pas d'autres
contraintes de disposition
MyContainer. add (MyComponent) ;
GridLayout. Lecontainerest découpé en une grille composée den cases de taille gale. Le construc
teur du GridLayout requiert en paramétres d’entrée le nombre de lignes et le nombre de colonnes
de la grille. Les composants sont ajoutés les uns 4 la suite des autres en remplissant d’abord la
premiere ligne, puis la seconde, etc. II n'y a pas d'autres 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 spécifige lors de Pappel au constructeur du panel (par ex, JPanel myPanel =
new 2Panel (new BorderLayout());) ou par un appel explicite & la méthode setLayout, par
exemple
myPanel.sct Layout (new GridLayout (4,5);
Les composants peuvent ensuite dtre ajoutés avec la méthode add() appropriée.
Une interface graphique consiste donc en une hiérarchie de composants telle que certains
composants sont des containers spécifiant la disposition d autres composants. La racine de cette
46‘A2. Composants graphiques
hirarchie est également un container qui peut s'afficher librement (c-A-d. sans que sa disposi-
tion soit précisée dans un container). Parmi ces containers de haut niveau, on trouve la classe
Javax. swing. JFrame qui représente une fenétre et javax.swing.JOialog qui représente une
boite de dialogue. La création d'une fenétre suit généralement les étapes suivantes
1. Création d'une instance de 3Frame (ou d'une sous-classe).
2, Ajout des composants au panel de la fenétre. Ce panel est accessible par la méthode
getContentPane(). On peut également attribuer & la fenétre un nouveau panel par la mé-
thode setcontentPane(),
3. Calcul de la taille de la fenétre a aide de la méthode pack(). Ce calcul est automatique et
prend en compte la dimension préferrée de chaque composant ainsi que leur disposition,
4. Alfichage de la fenétre par la méthode setVisible()
Par exemple, la figure A.1 (p. 44) est une instance d'une sous-classe de JFrame
import java.awt.*;
import javax.swing.*;
public class ExBouton extends JFrame {
public ExBouton() {
super();
BLabel label = new 3Label(Exenple de bouton”);
3Panel panel = new JPanel(new BorderLayout());
panel.add(label, BorderLayout.NORTH) ;
Button b = new JButton(” Quitter ”);
panel.add(b, BorderLayout .SOUT#) ;
this. setContentPane(panel) ;
this.pack();
}
public static void main(string[] args) {
ExBouton bouton = new ExBouton() ;
bouton.setVisible(true);
A.2.3. Exemple d’interface
Le meilleur moyen d'apprendre a écrire des interfaces graphiques est de s'inspirer d’exemples
interfaces existantes. La figure A.5 est un exemple de fenétre produit avec le code suivant la
figure.
a‘Annexe A. Applications graphique (package swing)
Fone Hello World
Ocarre
O cercte
O Triangle
Couleur:
Ga
Hello World
Une belle figure
Champions du monde |
‘Aciao, Donsor...
Changez la couleur
aclare |
Ajouter un texte possible:
( ‘Ajouter )
a
Fioure A.5 - Exemple d'interface graphique
48‘A2. Composants graphiques
(98 “aoe)uopsuauro nau}o2s5p0s19) 2394-0464 TOIDE
Garsiatjoueerravose sow» suegttoi aunettOs9st
‘unonusae sop aod lo} ated #1 oe 77
anand sungrt0u350 un sup 93897 P13 woien>wneT //
youi2a as" ons Fapawon verasasT)ope0/399TeSS yST IN
Seteeset)sseye mou = SE He03
Dusty a) op wouaeoes 77
ceL9e19150) 312801390 ETT
Citta 83.) 1900, NTT
a) sabe soy tare aueL PFE eee
Seintan ef Eedue) owe pperenees
Cocsaysuog “08:3 sus 9 eae
soon store.) 309996 eSEDASL
sGeamdyy aptea aun) s249[9PPe "ene
(oorise scious phe eaeeNeTT
jBupsng0194 mau = eC.
1) 39 aT9Ro8 mp wonate4> 77
rofe)aneoueayean
ennai ete
(ooptsrioie me 03
Gaaez)ope Teves
l:ttavssed 983 un sayy) ARETE AU = Tet
FG "9 °1 “ebanokeyr.9 mau) TOUEGE Haw = TAREGNON TRAE
Succ sp anolnye Youd rp 2b8s5)y0u04 39 H0)I8e.> 77
“ayapateuopuoy no) ourae meu = eg coueee
son oud np worsens 7/
39h) 997908" sna9
(dtnayay astro sone
Fnotaa)onipoe sono
e2ononeay) eee m= EYaRET LOGE
step ‘rorbuesi,)uasangeypee Sou = EuCEING
(te) iparaso3,)uaanapypeue se ~ aos¥ng
(Gy “yauaey,)uasanerpeye mou = Tuam
“niS03 9 9903 sop wOh308 77
16 °F ‘a)anofersrp mou) Tavede Hos a4oned coHedC
‘Cason unea ames) wyaesadcesoraejocsoe-eE
sosuof 9e0 su3ausf 2) Fuone ssuaaoy 97 3960 Daoud 39/7
S(casyauns ap arene un)snene
Oeenewne oreo
‘uyssap uyssoe persoeud
feemset dupa aoiaan poised
sernanes sere pesnaed
abe wsarae petsiaud
sway pretsale patted
aaqnos wopeqwene pas>eioud
fewring "Toning “Tuenand LonMORPRAE petseead
osse)s-snes 23399 suey voppo8 A spornod 9p ufo
Suovtuoy so}> aun sump (sis#9 wohss05) pbs
) sensi spusnee ssejunyenes sero orTand
‘sapaeasopong tuys xenet. ey
49‘Annexe A. Applications graphique (package swing)
(gue ‘ebepucrsuana mou wanes
) (arrsposojouened voyseoua >rrapd
Storedio> mp 9509/aut 917858 9) 7/
Joxfisnds op roused dpoynow 23399 9p 0143/9950 97 //
a = ants
(ap agans)aunny 0s pran 9ttand
‘
Dane &
enh yo3) a4 2509 (
onteraaye> = snayno>
2» (rwiae)stensortns) 9
) (tpas Burseyanotranses pra 2Ptapd
2 (a0
aaypisio 6 anys 0} Ro sey? 81/7
((oousea. starters) 3
Snopndla bes stad ey 77
SS asisfe sss 203 29/7
Ouaranstsna “1 ~ Quaprmat-sna “9 ‘envsiee's
apete-saten)soton
YC soyadeus)sunee pron >ycerd
arr yeaatesjpineatooneeren
‘ ones
S500 31a
ess0)9 9) op arasanussae> 91. 7/
‘auntie Burs
) see spunser essa 55019
27 spunfopos sod sondz> 9p 03.04 2850)9 93809 /7
‘
(ansn)oveysinas"apeysenurAu
sisjuves pj 213088 Send
supsunf 07 ap uopeuoan 3
(91 ‘or Yor “orsapsogfaduy Mu) sps09:96 Taveee
2804380.) s8088,0 soased 2unpde4 208 //
unos: 4nofe sop “se9)e0e-Toueesen
es" aeferaspueg“uysap) 200" Tevegsteu
or") ano aapaog nso" s95Tawees Te
auegueswonet ss aueavreu toveae
nes yoke aopuog Touenxos)poeseq
50
Vous aimerez peut-être aussi