Dej 1 30

Développons en Java
Jean Michel DOUDOUX

Table des matières
Développons en Java.............................................................................................................................................................1

Préambule..............................................................................................................................................................................2
A propos de ce document.........................................................................................................................................2
Remerciements.........................................................................................................................................................4
Notes de licence.......................................................................................................................................................4
Marques déposées....................................................................................................................................................4
Historique des versions............................................................................................................................................5

Partie 1 : les bases du langage Java....................................................................................................................................7

1. Présentation de Java.........................................................................................................................................................8
1.1. Les caractéristiques...........................................................................................................................................8
1.2. Un bref historique de Java .................................................................................................................................9
1.3. Les différentes éditions et versions de Java....................................................................................................10
1.3.1. Les évolutions des plates-formes Java..................................................................................................11
1.3.2. Les différentes versions de Java ............................................................................................................11
1.3.3. Java 1.0..................................................................................................................................................12
1.3.4. Java 1.1..................................................................................................................................................12
1.3.5. Java 1.2 (nom de code Playground)......................................................................................................13
1.3.6. J2SE 1.3 (nom de code Kestrel)............................................................................................................13
1.3.7. J2SE 1.4 (nom de code Merlin)............................................................................................................13
1.3.8. J2SE 5.0 (nom de code Tiger)...............................................................................................................14
1.3.9. Java SE 6 (nom de code Mustang)........................................................................................................14
1.3.10. Java 6 update.......................................................................................................................................17
1.3.10.1. Java 6 update 1..........................................................................................................................18
1.3.10.2. Java 6 update 2..........................................................................................................................18
1.3.10.3. Java 6 update 3..........................................................................................................................18
1.3.10.4. Java 6 update 4..........................................................................................................................18
1.3.10.5. Java 6 update 5..........................................................................................................................18
1.3.10.6. Java 6 update 6..........................................................................................................................20
1.3.10.7. Java 6 update 7..........................................................................................................................20
1.3.10.8. Java 6 update 10........................................................................................................................21
1.3.10.9. Java 6 update 11........................................................................................................................21
1.3.10.10. Java 6 update 12......................................................................................................................21
1.3.10.11. Java 6 update 13......................................................................................................................21
1.3.10.12. Java 6 update 14......................................................................................................................21
1.3.10.13. Java 6 update 15......................................................................................................................22
1.3.10.14. Java 6 update 16......................................................................................................................22
1.3.11. Les futures versions de Java ................................................................................................................22
1.3.12. Le résumé des différentes versions.....................................................................................................22
1.3.13. Les extensions du JDK........................................................................................................................22
1.4. Un rapide tour d'horizon des API et de quelques outils..................................................................................23
1.5. Les différences entre Java et JavaScript..........................................................................................................24
1.6. L'installation du JDK .......................................................................................................................................25
1.6.1. L'installation de la version 1.3 DU JDK de Sun sous Windows 9x......................................................25
1.6.2. L'installation de la documentation de Java 1.3 sous Windows.............................................................27
1.6.3. La configuration des variables système sous Windows 9x...................................................................28
1.6.4. Les éléments du JDK 1.3 sous Windows..............................................................................................29
1.6.5. L'installation de la version 1.4.2 du JDK de Sun sous Windows ..........................................................29
1.6.6. L'installation de la version 1.5 du JDK de Sun sous Windows .............................................................30
1.6.7. Installation JDK 1.4.2 sous Linux Mandrake 10..................................................................................31

2. Les notions et techniques de base en Java....................................................................................................................35
2.1. Les concepts de base.......................................................................................................................................35
2.1.1. La compilation et l'exécution................................................................................................................35
2.1.2. Les packages.........................................................................................................................................38
2.1.3. Le déploiement sous la forme d'un jar..................................................................................................40
2.1.4. Le classpath...........................................................................................................................................41


Table des matières
2. Les notions et techniques de base en Java
2.1.4.1. La définition du classpath pour exécuter une application ...........................................................43
2.1.4.2. La définition du classpath pour exécuter une application avec la variable CLASSPATH .........45
2.1.4.3. La définition du classpath pour exécuter une application utilisant une ou plusieurs
bibliothèques .............................................................................................................................45
2.1.4.4. La définition du classpath pour exécuter une application packagée en jar.................................46
2.2. L'exécution d'une applet..................................................................................................................................48

3. La syntaxe et les éléments de bases de Java.................................................................................................................49
3.1. Les règles de base ............................................................................................................................................49
3.2. Les identificateurs...........................................................................................................................................49
3.3. Les commentaires ............................................................................................................................................50
3.4. La déclaration et l'utilisation de variables.......................................................................................................50
3.4.1. La déclaration de variables...................................................................................................................50
3.4.2. Les types élémentaires..........................................................................................................................51
3.4.3. Le format des types élémentaires..........................................................................................................52
3.4.4. L'initialisation des variables..................................................................................................................53
3.4.5. L'affectation..........................................................................................................................................53
3.4.6. Les comparaisons..................................................................................................................................54
3.5. Les opérations arithmétiques ...........................................................................................................................54
3.5.1. L'arithmétique entière...........................................................................................................................55
3.5.2. L'arithmétique en virgule flottante........................................................................................................55
3.5.3. L'incrémentation et la décrémentation..................................................................................................56
3.6. La priorité des opérateurs................................................................................................................................57
3.7. Les structures de contrôles..............................................................................................................................57
3.7.1. Les boucles............................................................................................................................................57
3.7.2. Les branchements conditionnels...........................................................................................................59
3.7.3. Les débranchements..............................................................................................................................59
3.8. Les tableaux .....................................................................................................................................................59
3.8.1. La déclaration des tableaux...................................................................................................................60
3.8.2. L'initialisation explicite d'un tableau....................................................................................................60
3.8.3. Le parcours d'un tableau.......................................................................................................................61
3.9. Les conversions de types.................................................................................................................................61
3.9.1. La conversion d'un entier int en chaîne de caractère String ..................................................................62
3.9.2. La conversion d'une chaîne de caractères String en entier int..............................................................62
3.9.3. La conversion d'un entier int en entier long..........................................................................................62
3.10. La manipulation des chaînes de caractères...................................................................................................62
3.10.1. Les caractères spéciaux dans les chaines............................................................................................63
3.10.2. L'addition de chaînes de caractères.....................................................................................................63
3.10.3. La comparaison de deux chaines........................................................................................................64
3.10.4. La détermination de la longueur d'une chaine....................................................................................64
3.10.5. La modification de la casse d'une chaine............................................................................................64

4. La programmation orientée objet.................................................................................................................................65
4.1. Le concept de classe........................................................................................................................................65
4.1.1. La syntaxe de déclaration d'une classe ..................................................................................................65
4.2. Les objets.........................................................................................................................................................66
4.2.1. La création d'un objet : instancier une classe........................................................................................66
4.2.2. La durée de vie d'un objet.....................................................................................................................68
4.2.3. La création d'objets identiques..............................................................................................................68
4.2.4. Les références et la comparaison d'objets.............................................................................................68
4.2.5. L'objet null............................................................................................................................................69
4.2.6. Les variables de classes .........................................................................................................................69
4.2.7. La variable this......................................................................................................................................69
4.2.8. L'opérateur instanceof...........................................................................................................................70
4.3. Les modificateurs d'accès................................................................................................................................71
4.3.1. Les mots clés qui gèrent la visibilité des entités...................................................................................71
4.3.2. Le mot clé static....................................................................................................................................71
4.3.3. Le mot clé final.....................................................................................................................................72


Table des matières
4. La programmation orientée objet
4.3.4. Le mot clé abstract................................................................................................................................73
4.3.5. Le mot clé synchronized.......................................................................................................................73
4.3.6. Le mot clé volatile .................................................................................................................................73
4.3.7. Le mot clé native...................................................................................................................................74
4.4. Les propriétés ou attributs...............................................................................................................................74
4.4.1. Les variables d'instances.......................................................................................................................74
4.4.2. Les variables de classes .........................................................................................................................74
4.4.3. Les constantes.......................................................................................................................................74
4.5. Les méthodes...................................................................................................................................................75
4.5.1. La syntaxe de la déclaration..................................................................................................................75
4.5.2. La transmission de paramètres..............................................................................................................76
4.5.3. L'émission de messages........................................................................................................................77
4.5.4. L'enchainement de références à des variables et à des méthodes.........................................................77
4.5.5. La surcharge de méthodes.....................................................................................................................77
4.5.6. Les constructeurs ...................................................................................................................................78
4.5.7. Le destructeur........................................................................................................................................79
4.5.8. Les accesseurs.......................................................................................................................................79
4.6. L'héritage.........................................................................................................................................................79
4.6.1. Le principe de l'héritage........................................................................................................................79
4.6.2. La mise en oeuvre de l'héritage.............................................................................................................80
4.6.3. L'accès aux propriétés héritées ..............................................................................................................80
4.6.4. La redéfinition d'une méthode héritée ...................................................................................................80
4.6.5. Le polymorphisme................................................................................................................................80
4.6.6. Le transtypage induit par l'héritage facilite le polymorphisme.............................................................81
4.6.7. Les interfaces et l'héritage multiple......................................................................................................81
4.6.8. Des conseils sur l'héritage.....................................................................................................................83
4.7. Les packages...................................................................................................................................................83
4.7.1. La définition d'un package....................................................................................................................83
4.7.2. L'utilisation d'un package......................................................................................................................83
4.7.3. La collision de classes...........................................................................................................................84
4.7.4. Les packages et l'environnement système .............................................................................................84
4.8. Les classes internes.........................................................................................................................................84
4.8.1. Les classes internes non statiques.........................................................................................................87
4.8.2. Les classes internes locales...................................................................................................................91
4.8.3. Les classes internes anonymes..............................................................................................................93
4.8.4. Les classes internes statiques................................................................................................................94
4.9. La gestion dynamique des objets....................................................................................................................95

5. Les packages de bases .....................................................................................................................................................96
5.1. Les packages selon la version du JDK............................................................................................................96
5.2. Le package java.lang.....................................................................................................................................102
5.2.1. La classe Object..................................................................................................................................102
5.2.1.1. La méthode getClass()..............................................................................................................103
5.2.1.2. La méthode toString()...............................................................................................................103
5.2.1.3. La méthode equals() ..................................................................................................................103
5.2.1.4. La méthode finalize()................................................................................................................103
5.2.1.5. La méthode clone()...................................................................................................................104
5.2.2. La classe String...................................................................................................................................104
5.2.3. La classe StringBuffer.........................................................................................................................106
5.2.4. Les wrappers.......................................................................................................................................107
5.2.5. La classe System.................................................................................................................................108
5.2.5.1. L'utilisation des flux d'entrée/sortie standard ............................................................................108
5.2.5.2. Les variables d'environnement et les propriétés du système....................................................110
5.2.6. Les classes Runtime et Process...........................................................................................................112
5.3. La présentation rapide du package awt java ..................................................................................................115
5.4. La présentation rapide du package java.io....................................................................................................115
5.5. Le package java.util......................................................................................................................................115
.
5.5.1. La classe StringTokenizer...................................................................................................................115


Table des matières
5. Les packages de bases
5.5.2. La classe Random...............................................................................................................................116
5.5.3. Les classes Date et Calendar...............................................................................................................116
5.5.4. La classe SimpleDateFormat..............................................................................................................117
5.5.5. La classe Vector..................................................................................................................................123
5.5.6. La classe Hashtable.............................................................................................................................124
5.5.7. L'interface Enumeration......................................................................................................................124
5.5.8. La manipulation d'archives zip...........................................................................................................125
5.5.9. Les expressions régulières..................................................................................................................128
5.5.9.1. Les motifs.................................................................................................................................129
5.5.9.2. La classe Pattern.......................................................................................................................130
5.5.9.3. La classe Matcher.....................................................................................................................131
5.5.10. La classe Formatter...........................................................................................................................133
5.5.11. La classe Scanner..............................................................................................................................134
5.6. La présentation rapide du package java.net..................................................................................................135
5.7. La présentation rapide du package java.applet.............................................................................................135
.

6. Les fonctions mathématiques .......................................................................................................................................136
6.1. Les variables de classe..................................................................................................................................136
6.2. Les fonctions trigonométriques.....................................................................................................................137
6.3. Les fonctions de comparaisons.....................................................................................................................137
6.4. Les arrondis...................................................................................................................................................137
6.4.1. La méthode round(n)...........................................................................................................................137
6.4.2. La méthode rint(double) ......................................................................................................................138
6.4.3. La méthode floor(double)...................................................................................................................138
6.4.4. La méthode ceil(double).....................................................................................................................139
6.4.5. La méthode abs(x)...............................................................................................................................139
6.5. La méthode IEEEremainder(double, double) ................................................................................................139
6.6. Les Exponentielles et puissances..................................................................................................................140
6.6.1. La méthode pow(double, double).......................................................................................................140
6.6.2. La méthode sqrt(double).....................................................................................................................140
6.6.3. La méthode exp(double).....................................................................................................................140
6.6.4. La méthode log(double)......................................................................................................................141
6.7. La génération de nombres aléatoires.............................................................................................................141
6.7.1. La méthode random()..........................................................................................................................141
6.8. La classe BigDecimal....................................................................................................................................141

7. La gestion des exceptions.............................................................................................................................................148
7.1. Les mots clés try, catch et finally..................................................................................................................149
7.2. La classe Throwable......................................................................................................................................150
7.3. Les classes Exception, RunTimeException et Error.....................................................................................151
7.4. Les exceptions personnalisées .......................................................................................................................151
7.5. Les exceptions chaînées................................................................................................................................152
7.6. L'utilisation des exceptions...........................................................................................................................153

8. Le multitâche .................................................................................................................................................................155
8.1. L'interface Runnable.....................................................................................................................................155
8.2. La classe Thread............................................................................................................................................156
8.3. La création et l'exécution d'un thread............................................................................................................158
8.3.1. La dérivation de la classe Thread........................................................................................................158
8.3.2. L'implémentation de l'interface Runnable..........................................................................................159
8.3.3. La modification de la priorité d'un thread...........................................................................................160
8.4. La classe ThreadGroup ..................................................................................................................................161
8.5. Un thread en tâche de fond (démon).............................................................................................................161
8.6. L'exclusion mutuelle.....................................................................................................................................162
8.6.1. La sécurisation d'une méthode............................................................................................................162
8.6.2. La sécurisation d'un bloc.....................................................................................................................162
8.6.3. La sécurisation de variables de classes...............................................................................................163
8.6.4. La synchronisation : les méthodes wait() et notify() ...........................................................................163


Table des matières
9. JDK 1.5 (nom de code Tiger).......................................................................................................................................164
9.1. Les nouveautés du langage Java version 1.5.................................................................................................164
9.2. L'autoboxing / unboxing ................................................................................................................................164
9.3. Les importations statiques.............................................................................................................................165
9.4. Les annotations ou méta données (Meta Data).............................................................................................166
9.5. Les arguments variables (varargs) .................................................................................................................166
9.6. Les generics...................................................................................................................................................168
9.7. Les boucles pour le parcours des collections................................................................................................171
9.8. Les énumérations (type enum)......................................................................................................................173

10. Les annotations...........................................................................................................................................................177
10.1. La mise en oeuvre des annotations ..............................................................................................................178
10.2. L'utilisation des annotations........................................................................................................................179
10.2.1. La documentation..............................................................................................................................179
10.2.2. L'utilisation par le compilateur.........................................................................................................180
10.2.3. La génération de code.......................................................................................................................180
10.2.4. La génération de fichiers...................................................................................................................180
10.2.5. Les API qui utilisent les annotations .................................................................................................180
10.3. Les annotations standards ............................................................................................................................180
10.3.1. L'annotation @Deprecated................................................................................................................180
10.3.2. L'annotation @Override....................................................................................................................181
10.3.3. L'annotation @SuppressWarning ......................................................................................................183
10.4. Les annotations communes (Common Annotations)..................................................................................184
10.4.1. L'annotation @Generated ..................................................................................................................184
10.4.2. Les annotations @Resource et @Resources.....................................................................................185
10.4.3. Les annotations @PostConstruct et @PreDestroy............................................................................186
10.5. Les annotations personnalisées...................................................................................................................186
10.5.1. La définition d'une annotation ...........................................................................................................186
10.5.2. Les annotations pour les annotations................................................................................................188
10.5.2.1. L'annotation @Target.............................................................................................................188
10.5.2.2. L'annotation @Retention........................................................................................................189
10.5.2.3. L'annotation @Documented...................................................................................................189
10.5.2.4. L'annotation @Inherited.........................................................................................................190
10.6. L'exploitation des annotations.....................................................................................................................190
10.6.1. L'exploitation des annotations dans un Doclet .................................................................................190
.
10.6.2. L'exploitation des annotations avec l'outil Apt.................................................................................191
10.6.3. L'exploitation des annotations par introspection ...............................................................................197
10.6.4. L'exploitation des annotations par le compilateur Java....................................................................199
10.7. L'API Pluggable Annotation Processing.....................................................................................................199
10.7.1. Les processeurs d'annotations...........................................................................................................200
10.7.2. L'utilisation des processeurs par le compilateur...............................................................................202
10.7.3. La création de nouveaux fichiers......................................................................................................202
10.8. Les ressources relatives aux annotations .....................................................................................................204

Partie 2 : Développement des interfaces graphiques.....................................................................................................205

11. Le graphisme...............................................................................................................................................................206
11.1. Les opérations sur le contexte graphique....................................................................................................206
11.1.1. Le tracé de formes géométriques......................................................................................................206
11.1.2. Le tracé de texte................................................................................................................................207
11.1.3. L'utilisation des fontes......................................................................................................................207
11.1.4. La gestion de la couleur....................................................................................................................208
11.1.5. Le chevauchement de figures graphiques.........................................................................................208
11.1.6. L'effacement d'une aire.....................................................................................................................208
11.1.7. La copier une aire rectangulaire........................................................................................................208

12. Les éléments d'interfaces graphiques de l'AWT ......................................................................................................209
12.1. Les composants graphiques .........................................................................................................................210
12.1.1. Les étiquettes
.....................................................................................................................................210


Table des matières
12. Les éléments d'interfaces graphiques de l'AWT
12.1.2. Les boutons.......................................................................................................................................211
12.1.3. Les panneaux .....................................................................................................................................211
12.1.4. Les listes déroulantes (combobox)....................................................................................................212
12.1.5. La classe TextComponent.................................................................................................................213
12.1.6. Les champs de texte..........................................................................................................................213
12.1.7. Les zones de texte multilignes..........................................................................................................214
12.1.8. Les listes............................................................................................................................................216
12.1.9. Les cases à cocher.............................................................................................................................219
12.1.10. Les boutons radio............................................................................................................................220
12.1.11. Les barres de défilement.................................................................................................................221
12.1.12. La classe Canvas.............................................................................................................................222
12.2. La classe Component..................................................................................................................................223
12.3. Les conteneurs.............................................................................................................................................224
12.3.1. Le conteneur Panel............................................................................................................................225
12.3.2. Le conteneur Window.......................................................................................................................225
12.3.3. Le conteneur Frame..........................................................................................................................225
12.3.4. Le conteneur Dialog..........................................................................................................................227
12.4. Les menus ....................................................................................................................................................228
12.4.1. Les méthodes de la classe MenuBar.................................................................................................230
12.4.2. Les méthodes de la classe Menu.......................................................................................................230
12.4.3. Les méthodes de la classe MenuItem................................................................................................230
12.4.4. Les méthodes de la classe CheckboxMenuItem...............................................................................231
12.5. La classe java.awt.Desktop.........................................................................................................................231

13. La création d'interfaces graphiques avec AWT......................................................................................................233
13.1. Le dimensionnement des composants.........................................................................................................233
13.2. Le positionnement des composants.............................................................................................................234
13.2.1. La mise en page par flot (FlowLayout).............................................................................................235
13.2.2. La mise en page bordure (BorderLayout).........................................................................................236
13.2.3. La mise en page de type carte (CardLayout)....................................................................................237
13.2.4. La mise en page GridLayout.............................................................................................................238
13.2.5. La mise en page GridBagLayout......................................................................................................240
13.3. La création de nouveaux composants à partir de Panel..............................................................................241
13.4. L'activation ou la désactivation des composants.........................................................................................242

14. L'interception des actions de l'utilisateur .................................................................................................................243
14.1. L'interception des actions de l'utilisateur avec Java version 1.0.................................................................243
14.2. L'interception des actions de l'utilisateur avec Java version 1.1.................................................................243
14.2.1. L'interface ItemListener....................................................................................................................245
14.2.2. L'interface TextListener....................................................................................................................246
14.2.3. L'interface MouseMotionListener.....................................................................................................247
14.2.4. L'interface MouseListener................................................................................................................247
.
14.2.5. L'interface WindowListener ..............................................................................................................248
14.2.6. Les différentes implémentations des Listeners.................................................................................249
14.2.6.1. Une classe implémentant elle même le listener......................................................................249
14.2.6.2. Une classe indépendante implémentant le listener.................................................................250
14.2.6.3. Une classe interne...................................................................................................................251
14.2.6.4. Une classe interne anonyme ....................................................................................................251
14.2.7. Résumé..............................................................................................................................................252

15. Le développement d'interfaces graphiques avec SWING .......................................................................................253
15.1. La présentation de Swing............................................................................................................................253
15.2. Les packages Swing....................................................................................................................................254
15.3. Un exemple de fenêtre autonome................................................................................................................254
15.4. Les composants Swing................................................................................................................................255
15.4.1. La classe JFrame...............................................................................................................................256
15.4.1.1. Le comportement par défaut à la fermeture............................................................................258
15.4.1.2. La personnalisation de l'icône.................................................................................................259


Table des matières
15. Le développement d'interfaces graphiques avec SWING
15.4.1.3. Centrer une JFrame à l'écran ...................................................................................................259
15.4.1.4. Les événements associées à un JFrame..................................................................................260
15.4.2. Les étiquettes : la classe JLabel........................................................................................................260
15.4.3. Les panneaux : la classe JPanel........................................................................................................263
.
15.5. Les boutons.................................................................................................................................................263
15.5.1. La classe AbstractButton..................................................................................................................263
15.5.2. La classe JButton..............................................................................................................................265
15.5.3. La classe JToggleButton...................................................................................................................266
15.5.4. La classe ButtonGroup......................................................................................................................267
15.5.5. Les cases à cocher : la classe JCheckBox.........................................................................................267
15.5.6. Les boutons radio : la classe JRadioButton......................................................................................268
15.6. Les composants de saisie de texte...............................................................................................................268
15.6.1. La classe JTextComponent...............................................................................................................269
15.6.2. La classe JTextField..........................................................................................................................270
15.6.3. La classe JPasswordField..................................................................................................................270
15.6.4. La classe JFormattedTextField.........................................................................................................272
15.6.5. La classe JEditorPane ........................................................................................................................272
15.6.6. La classe JTextPane..........................................................................................................................273
15.6.7. La classe JTextArea..........................................................................................................................273
15.7. Les onglets ...................................................................................................................................................275
15.8. Le composant JTree....................................................................................................................................276
15.8.1. La création d'une instance de la classe JTree....................................................................................276
15.8.2. La gestion des données de l'arbre ......................................................................................................279
15.8.2.1. L'interface TreeNode..............................................................................................................280
15.8.2.2. L'interface MutableTreeNode.................................................................................................280
15.8.2.3. La classe DefaultMutableTreeNode.......................................................................................281
15.8.3. La modification du contenu de l'arbre ...............................................................................................282
15.8.3.1. Les modifications des noeuds fils...........................................................................................282
15.8.3.2. Les événements émis par le modèle ........................................................................................283
15.8.3.3. L'édition d'un noeud................................................................................................................284
15.8.3.4. Les éditeurs personnalisés .......................................................................................................284
15.8.3.5. 3.5 La définition des noeuds éditables....................................................................................285
15.8.4. La mise en oeuvre d'actions sur l'arbre.............................................................................................286
15.8.4.1. Etendre ou refermer un noeud .................................................................................................286
15.8.4.2. La détermination du noeud sélectionné..................................................................................287
15.8.4.3. Le parcours des noeuds de l'arbre...........................................................................................287
15.8.5. La gestion des événements................................................................................................................288
15.8.5.1. La classe TreePath..................................................................................................................289
15.8.5.2. La gestion de la sélection d'un noeud.....................................................................................290
15.8.5.3. Les événements lies à la sélection de noeuds.........................................................................291
15.8.5.4. Les événements lorsqu'un noeud est étendu ou refermé.........................................................293
15.8.5.5. Le contrôle des actions pour étendre ou refermer un noeud...................................................294
15.8.6. La personnalisation du rendu............................................................................................................294
15.8.6.1. Personnaliser le rendu des noeuds..........................................................................................295
15.8.6.2. Les bulles d'aides (Tooltips)...................................................................................................298
15.9. Les menus ....................................................................................................................................................298
15.9.1. La classe JMenuBar..........................................................................................................................301
15.9.2. La classe JMenuItem.........................................................................................................................303
15.9.3. La classe JPopupMenu......................................................................................................................303
15.9.4. La classe JMenu................................................................................................................................305
15.9.5. La classe JCheckBoxMenuItem........................................................................................................306
15.9.6. La classe JRadioButtonMenuItem....................................................................................................306
15.9.7. La classe JSeparator..........................................................................................................................306
15.10. L'affichage d'une image dans une application...........................................................................................307

16. Le développement d'interfaces graphiques avec SWT ............................................................................................312
16.1. La présentation de SWT..............................................................................................................................312
16.2. Un exemple très simple...............................................................................................................................314


Table des matières
16. Le développement d'interfaces graphiques avec SWT
16.3. La classe SWT .............................................................................................................................................314
16.4. L'objet Display............................................................................................................................................315
16.5. L'objet Shell................................................................................................................................................315
.
16.6. Les composants...........................................................................................................................................317
16.6.1. La classe Control...............................................................................................................................317
16.6.2. Les contrôles de base........................................................................................................................318
16.6.2.1. La classe Button......................................................................................................................318
16.6.2.2. La classe Label.......................................................................................................................318
.
16.6.2.3. La classe Text.........................................................................................................................319
16.6.3. Les contrôles de type liste.................................................................................................................320
16.6.3.1. La classe Combo.....................................................................................................................320
16.6.3.2. La classe List..........................................................................................................................321
.
16.6.4. Les contrôles pour les menus............................................................................................................321
16.6.4.1. La classe Menu.......................................................................................................................321
16.6.4.2. La classe MenuItem................................................................................................................322
16.6.5. Les contrôles de sélection ou d'affichage d'une valeur.....................................................................323
16.6.5.1. La classe ProgressBar.............................................................................................................323
16.6.5.2. La classe Scale........................................................................................................................324
16.6.5.3. La classe Slider.......................................................................................................................324
16.6.6. Les contrôles de type « onglets »......................................................................................................325
16.6.6.1. La classe TabFolder................................................................................................................325
16.6.6.2. La classe TabItem...................................................................................................................326
16.6.7. Les contrôles de type « tableau »......................................................................................................326
16.6.7.1. La classe Table ........................................................................................................................326
16.6.7.2. La classe TableColumn...........................................................................................................328
16.6.7.3. La classe TableItem................................................................................................................328
16.6.8. Les contrôles de type « arbre ».........................................................................................................329
16.6.8.1. La classe Tree.........................................................................................................................329
16.6.8.2. La classe TreeItem..................................................................................................................330
16.6.9. La classe ScrollBar ............................................................................................................................330
16.6.10. Les contrôles pour le graphisme.....................................................................................................330
16.6.10.1. La classe Canvas...................................................................................................................330
16.6.10.2. La classe GC.........................................................................................................................331
16.6.10.3. La classe Color ......................................................................................................................332
16.6.10.4. La classe Font.......................................................................................................................332
16.6.10.5. La classe Image.....................................................................................................................333
16.7. Les conteneurs.............................................................................................................................................334
16.7.1. Les conteneurs de base......................................................................................................................334
16.7.1.1. La classe Composite...............................................................................................................334
16.7.1.2. La classe Group .......................................................................................................................336
16.7.2. Les contrôles de type « barre d'outils ».............................................................................................336
16.7.2.1. La classe ToolBar...................................................................................................................336
16.7.2.2. La classe ToolItem..................................................................................................................337
16.7.2.3. Les classes CoolBar et Cooltem.............................................................................................339
16.8. La gestion des erreurs ..................................................................................................................................340
16.9. Le positionnement des contrôles.................................................................................................................340
16.9.1. Le positionnement absolu.................................................................................................................341
16.9.2. Le positionnement relatif avec les LayoutManager..........................................................................341
16.9.2.1. FillLayout...............................................................................................................................341
.
16.9.2.2. RowLayout.............................................................................................................................342
.
16.9.2.3. GridLayout..............................................................................................................................343
16.9.2.4. FormLayout............................................................................................................................346
16.10. La gestion des événements........................................................................................................................346
16.10.1. L'interface KeyListener...................................................................................................................347
16.10.2. L'interface MouseListener..............................................................................................................349
.
16.10.3. L'interface MouseMoveListener.....................................................................................................350
16.10.4. L'interface MouseTrackListener.....................................................................................................351
16.10.5. L'interface ModifyListener.............................................................................................................351


Table des matières
16. Le développement d'interfaces graphiques avec SWT
16.10.6. L'interface VerifyText()..................................................................................................................352
16.10.7. L'interface FocusListener................................................................................................................353
16.10.8. L'interface TraverseListener...........................................................................................................354
16.10.9. L'interface PaintListener.................................................................................................................355
16.11. Les boîtes de dialogue...............................................................................................................................356
16.11.1. Les boîtes de dialogues prédéfinies................................................................................................356
16.11.1.1. La classe MessageBox..........................................................................................................356
16.11.1.2. La classe ColorDialog...........................................................................................................357
16.11.1.3. La classe FontDialog .............................................................................................................358
16.11.1.4. La classe FileDialog ..............................................................................................................359
16.11.1.5. La classe DirectoryDialog .....................................................................................................359
16.11.1.6. La classe PrintDialog............................................................................................................360
16.11.2. Les boites de dialogues personnalisées...........................................................................................361

17. JFace............................................................................................................................................................................363
17.1. La structure générale d'une application.......................................................................................................364
17.2. Les boites de dialogues...............................................................................................................................365
17.2.1. L'affichage des messages d'erreur.....................................................................................................365
17.2.2. L'affichage des messages d'information à l'utilisateur......................................................................366
17.2.3. La saisie d'une valeur par l'utilisateur...............................................................................................368
17.2.4. La boîte de dialogue pour afficher la progression d'un traitement ...................................................369
.

Partie 3 : Les API avancées
..............................................................................................................................................373

18. Les collections..............................................................................................................................................................375
18.1. Présentation du framework collection.........................................................................................................375
18.2. Les interfaces des collections......................................................................................................................376
18.2.1. L'interface Collection........................................................................................................................377
18.2.2. L'interface Iterator.............................................................................................................................378
18.3. Les listes......................................................................................................................................................379
18.3.1. L'interface List..................................................................................................................................379
18.3.2. Les listes chaînées : la classe LinkedList..........................................................................................379
18.3.3. L'interface ListIterator......................................................................................................................381
.
18.3.4. Les tableaux redimensionnables : la classe ArrayList......................................................................381
18.4. Les ensembles.............................................................................................................................................382
18.4.1. L'interface Set...................................................................................................................................382
18.4.2. L'interface SortedSet.........................................................................................................................382
18.4.3. La classe HashSet.............................................................................................................................383
.
18.4.4. La classe TreeSet..............................................................................................................................383
18.5. Les collections gérées sous la forme clé/valeur..........................................................................................384
18.5.1. L'interface Map.................................................................................................................................384
18.5.2. L'interface SortedMap.......................................................................................................................385
18.5.3. La classe Hashtable...........................................................................................................................385
18.5.4. La classe TreeMap............................................................................................................................386
18.5.5. La classe HashMap...........................................................................................................................386
18.6. Le tri des collections...................................................................................................................................387
18.6.1. L'interface Comparable.....................................................................................................................387
18.6.2. L'interface Comparator.....................................................................................................................387
18.7. Les algorithmes...........................................................................................................................................387
18.8. Les exceptions du framework.....................................................................................................................389

19. Les flux.........................................................................................................................................................................390
19.1. La présentation des flux..............................................................................................................................390
19.2. Les classes de gestion des flux....................................................................................................................390
19.3. Les flux de caractères..................................................................................................................................392
19.3.1. La classe Reader ................................................................................................................................393
19.3.2. La classe Writer................................................................................................................................394
19.3.3. Les flux de caractères avec un fichier...............................................................................................394


Table des matières
19. Les flux
19.3.3.1. Les flux de caractères en lecture sur un fichier......................................................................394
.
19.3.3.2. Les flux de caractères en écriture sur un fichier.....................................................................395
19.3.4. Les flux de caractères tamponnés avec un fichier............................................................................395
.
19.3.4.1. Les flux de caractères tamponnés en lecture avec un fichier..................................................395
19.3.4.2. Les flux de caractères tamponnés en écriture avec un fichier................................................396
19.3.4.3. La classe PrintWriter..............................................................................................................397
.
19.4. Les flux d'octets ...........................................................................................................................................399
19.4.1. Les flux d'octets avec un fichier. ......................................................................................................399
.
19.4.1.1. Les flux d'octets en lecture sur un fichier...............................................................................399
19.4.1.2. Les flux d'octets en écriture sur un fichier..............................................................................400
19.4.2. Les flux d'octets tamponnés avec un fichier.....................................................................................401
19.5. La classe File...............................................................................................................................................402
19.6. Les fichiers à accès direct...........................................................................................................................404
.
19.7. La classe java.io.Console............................................................................................................................406

20. La sérialisation............................................................................................................................................................407
20.1. Les classes et les interfaces de la sérialisation............................................................................................407
20.1.1. L'interface Serializable ......................................................................................................................407
20.1.2. La classe ObjectOuputStream...........................................................................................................408
20.1.3. La classe ObjectInputStream............................................................................................................409
20.2. Le mot clé transient.....................................................................................................................................410
20.3. La sérialisation personnalisée ......................................................................................................................411
20.3.1. L'interface Externalizable.................................................................................................................411

21. L'interaction avec le réseau.......................................................................................................................................412
21.1. L'introduction aux concepts liés au réseau..................................................................................................412
21.2. Les adresses internet...................................................................................................................................413
.
21.2.1. La classe InetAddress ........................................................................................................................413
21.3. L'accès aux ressources avec une URL .........................................................................................................414
21.3.1. La classe URL...................................................................................................................................414
21.3.2. La classe URLConnection................................................................................................................415
21.3.3. La classe URLEncoder ......................................................................................................................416
21.3.4. La classe HttpURLConnection.........................................................................................................417
21.4. L'utilisation du protocole TCP....................................................................................................................417
21.4.1. La classe SocketServer ......................................................................................................................418
21.4.2. La classe Socket................................................................................................................................420
21.5. L'utilisation du protocole UDP ....................................................................................................................421
21.5.1. La classe DatagramSocket................................................................................................................421
21.5.2. La classe DatagramPacket................................................................................................................422
21.5.3. Un exemple de serveur et de client...................................................................................................422
21.6. Les exceptions liées au réseau .....................................................................................................................424
21.7. Les interfaces de connexions au réseau .......................................................................................................424

22. La gestion dynamique des objets et l'introspection.................................................................................................426
22.1. La classe Class............................................................................................................................................426
22.1.1. L'obtention d'un objet à partir de la classe Class..............................................................................427
22.1.1.1. La détermination de la classe d'un objet.................................................................................427
22.1.1.2. L'obtention d'un objet Class à partir d'un nom de classe........................................................427
22.1.1.3. Une troisième façon d'obtenir un objet Class.........................................................................428
22.1.2. Les méthodes de la classe Class........................................................................................................428
22.2. La recherche des informations sur une classe.............................................................................................429
22.2.1. La recherche de la classe mère d'une classe ......................................................................................429
22.2.2. La recherche des modificateurs d'une classe .....................................................................................429
22.2.3. La recherche des interfaces implémentées par une classe................................................................430
22.2.4. La recherche des champs publics......................................................................................................430
22.2.5. La recherche des paramètres d'une méthode ou d'un constructeur...................................................431
22.2.6. La recherche des constructeurs de la classe......................................................................................432
22.2.7. La recherche des méthodes publiques...............................................................................................433


Dej 1 30

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Dej 1 30

Similar to Dej 1 30 (20)

Dej 1 30