Développez en java

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....................................................................................................................................................5
Historique des versions............................................................................................................................................5
Partie 1 : Les bases du langage Java...................................................................................................................................8
1. Présentation de Java.........................................................................................................................................................9
1.1. Les caractéristiques...........................................................................................................................................9
1.2. Un bref historique de Java...............................................................................................................................10
1.3. Les différentes éditions et versions de Java....................................................................................................11
1.3.1. Les évolutions des plates-formes Java..................................................................................................12
1.3.2. Les différentes versions de Java............................................................................................................13
1.3.3. Java 1.0..................................................................................................................................................13
1.3.4. Java 1.1..................................................................................................................................................14
1.3.5. Java 1.2 (nom de code Playground)......................................................................................................14
1.3.6. J2SE 1.3 (nom de code Kestrel)............................................................................................................14
1.3.7. J2SE 1.4 (nom de code Merlin)............................................................................................................15
1.3.8. J2SE 5.0 (nom de code Tiger)...............................................................................................................15
1.3.9. Java SE 6 (nom de code Mustang)........................................................................................................16
1.3.9.1. Les évolutions de Java 6.............................................................................................................16
1.3.9.2. Java 6 update...............................................................................................................................19
1.3.10. Java SE 7.............................................................................................................................................27
1.3.10.1. Les JSR de Java 7.....................................................................................................................29
1.3.10.2. Java 7 update.............................................................................................................................30
1.3.11. Les futures versions de Java................................................................................................................32
1.3.12. Le résumé des différentes versions.....................................................................................................33
1.3.13. Le support des différentes versions.....................................................................................................33
1.3.14. Les extensions du JDK........................................................................................................................33
1.4. Un rapide tour d'horizon des API et de quelques outils..................................................................................34
1.5. Les différences entre Java et JavaScript..........................................................................................................35
1.6. L'installation du JDK.......................................................................................................................................36
1.6.1. L'installation de la version 1.3 du JDK de Sun sous Windows 9x........................................................36
1.6.2. L'installation de la documentation de Java 1.3 sous Windows.............................................................38
1.6.3. La configuration des variables système sous Windows 9x...................................................................39
1.6.4. Les éléments du JDK 1.3 sous Windows..............................................................................................40
1.6.5. L'installation de la version 1.4.2 du JDK de Sun sous Windows..........................................................40
1.6.6. L'installation de la version 1.5 du JDK de Sun sous Windows.............................................................41
1.6.7. Installation JDK 1.4.2 sous Linux Mandrake 10..................................................................................42
2. Les notions et techniques de base en Java....................................................................................................................46
2.1. Les concepts de base.......................................................................................................................................46
2.1.1. La compilation et l'exécution................................................................................................................46
2.1.2. Les packages.........................................................................................................................................49
2.1.3. Le déploiement sous la forme d'un jar..................................................................................................51
2.1.4. Le classpath...........................................................................................................................................52
2.1.4.1. La définition du classpath pour exécuter une application...........................................................54
2.1.4.2. La définition du classpath pour exécuter une application avec la variable CLASSPATH.........56
2.1.4.3. La définition du classpath pour exécuter une application utilisant une ou plusieurs
bibliothèques.............................................................................................................................56
2.1.4.4. La définition du classpath pour exécuter une application packagée en jar.................................57
2.2. L'exécution d'une applet..................................................................................................................................59

Table des matières
3. La syntaxe et les éléments de bases de Java.................................................................................................................60
3.1. Les règles de base............................................................................................................................................60
3.2. Les identificateurs...........................................................................................................................................61
3.3. Les commentaires............................................................................................................................................61
3.4. La déclaration et l'utilisation de variables.......................................................................................................61
3.4.1. La déclaration de variables...................................................................................................................61
3.4.2. Les types élémentaires..........................................................................................................................62
3.4.3. Le format des types élémentaires..........................................................................................................63
3.4.4. L'initialisation des variables..................................................................................................................64
3.4.5. L'affectation..........................................................................................................................................64
3.4.6. Les comparaisons..................................................................................................................................65
3.5. Les opérations arithmétiques...........................................................................................................................65
3.5.1. L'arithmétique entière...........................................................................................................................66
3.5.2. L'arithmétique en virgule flottante........................................................................................................66
3.5.3. L'incrémentation et la décrémentation..................................................................................................67
3.6. La priorité des opérateurs................................................................................................................................67
3.7. Les structures de contrôles..............................................................................................................................68
3.7.1. Les boucles............................................................................................................................................68
3.7.2. Les branchements conditionnels...........................................................................................................70
3.7.3. Les débranchements..............................................................................................................................70
3.8. Les tableaux.....................................................................................................................................................70
3.8.1. La déclaration des tableaux...................................................................................................................71
3.8.2. L'initialisation explicite d'un tableau....................................................................................................71
3.8.3. Le parcours d'un tableau.......................................................................................................................72
3.9. Les conversions de types.................................................................................................................................72
3.9.1. La conversion d'un entier int en chaîne de caractère String..................................................................73
3.9.2. La conversion d'une chaîne de caractères String en entier int..............................................................73
3.9.3. La conversion d'un entier int en entier long..........................................................................................73
3.10. La manipulation des chaînes de caractères...................................................................................................73
3.10.1. Les caractères spéciaux dans les chaines............................................................................................74
3.10.2. L'addition de chaînes de caractères.....................................................................................................74
3.10.3. La comparaison de deux chaines........................................................................................................75
3.10.4. La détermination de la longueur d'une chaine....................................................................................75
3.10.5. La modification de la casse d'une chaine............................................................................................75
4. La programmation orientée objet.................................................................................................................................76
4.1. Le concept de classe........................................................................................................................................76
4.1.1. La syntaxe de déclaration d'une classe..................................................................................................77
4.2. Les objets.........................................................................................................................................................77
4.2.1. La création d'un objet : instancier une classe........................................................................................77
4.2.2. La durée de vie d'un objet.....................................................................................................................79
4.2.3. La création d'objets identiques..............................................................................................................79
4.2.4. Les références et la comparaison d'objets.............................................................................................79
4.2.5. L'objet null............................................................................................................................................80
4.2.6. Les variables de classes.........................................................................................................................80
4.2.7. La variable this......................................................................................................................................80
4.2.8. L'opérateur instanceof...........................................................................................................................81
4.3. Les modificateurs d'accès................................................................................................................................81
4.3.1. Les mots clés qui gèrent la visibilité des entités...................................................................................82
4.3.2. Le mot clé static....................................................................................................................................82
4.3.3. Le mot clé final.....................................................................................................................................83
4.3.4. Le mot clé abstract................................................................................................................................84
4.3.5. Le mot clé synchronized.......................................................................................................................84
4.3.6. Le mot clé volatile.................................................................................................................................84
4.3.7. Le mot clé native...................................................................................................................................85
4.4. Les propriétés ou attributs...............................................................................................................................85
4.4.1. Les variables d'instances.......................................................................................................................85
4.4.2. Les variables de classes.........................................................................................................................85
4.4.3. Les constantes.......................................................................................................................................85

Table des matières
4. La programmation orientée objet
4.5. Les méthodes...................................................................................................................................................85
4.5.1. La syntaxe de la déclaration..................................................................................................................86
4.5.2. La transmission de paramètres..............................................................................................................87
4.5.3. L'émission de messages........................................................................................................................87
4.5.4. L'enchainement de références à des variables et à des méthodes.........................................................88
4.5.5. La surcharge de méthodes.....................................................................................................................88
4.5.6. Les constructeurs...................................................................................................................................89
4.5.7. Le destructeur........................................................................................................................................89
4.5.8. Les accesseurs.......................................................................................................................................90
4.6. L'héritage.........................................................................................................................................................90
4.6.1. Le principe de l'héritage........................................................................................................................90
4.6.2. La mise en oeuvre de l'héritage.............................................................................................................91
4.6.3. L'accès aux propriétés héritées..............................................................................................................91
4.6.4. La redéfinition d'une méthode héritée...................................................................................................91
4.6.5. Le polymorphisme................................................................................................................................91
4.6.6. Le transtypage induit par l'héritage facilite le polymorphisme.............................................................91
4.6.7. Les interfaces et l'héritage multiple......................................................................................................92
4.6.8. Des conseils sur l'héritage.....................................................................................................................93
4.7. Les packages...................................................................................................................................................94
4.7.1. La définition d'un package....................................................................................................................94
4.7.2. L'utilisation d'un package......................................................................................................................94
4.7.3. La collision de classes...........................................................................................................................95
4.7.4. Les packages et l'environnement système.............................................................................................95
4.8. Les classes internes.........................................................................................................................................95
4.8.1. Les classes internes non statiques.........................................................................................................97
4.8.2. Les classes internes locales.................................................................................................................101
4.8.3. Les classes internes anonymes............................................................................................................104
4.8.4. Les classes internes statiques..............................................................................................................104
4.9. La gestion dynamique des objets..................................................................................................................106
5. Les packages de bases...................................................................................................................................................107
5.1. Les packages selon la version du JDK..........................................................................................................107
5.2. Le package java.lang.....................................................................................................................................113
5.2.1. La classe Object..................................................................................................................................114
5.2.1.1. La méthode getClass()..............................................................................................................114
5.2.1.2. La méthode toString()...............................................................................................................114
5.2.1.3. La méthode equals()..................................................................................................................114
5.2.1.4. La méthode finalize()................................................................................................................114
5.2.1.5. La méthode clone()...................................................................................................................115
5.2.2. La classe String...................................................................................................................................115
5.2.3. La classe StringBuffer.........................................................................................................................117
5.2.4. Les wrappers.......................................................................................................................................118
5.2.5. La classe System.................................................................................................................................119
5.2.5.1. L'utilisation des flux d'entrée/sortie standard............................................................................119
5.2.5.2. Les variables d'environnement et les propriétés du système....................................................121
5.2.6. Les classes Runtime et Process...........................................................................................................123
5.3. La présentation rapide du package awt java..................................................................................................126
5.4. La présentation rapide du package java.io....................................................................................................126
5.5. Le package java.util.......................................................................................................................................126
5.5.1. La classe StringTokenizer...................................................................................................................126
5.5.2. La classe Random...............................................................................................................................127
5.5.3. Les classes Date et Calendar...............................................................................................................127
5.5.4. La classe SimpleDateFormat..............................................................................................................128
5.5.5. La classe Vector..................................................................................................................................129
5.5.6. La classe Hashtable.............................................................................................................................130
5.5.7. L'interface Enumeration......................................................................................................................130
5.5.8. La manipulation d'archives zip...........................................................................................................131
5.5.9. Les expressions régulières..................................................................................................................134

Table des matières
5. Les packages de bases
5.5.9.1. Les motifs.................................................................................................................................134
5.5.9.2. La classe Pattern.......................................................................................................................136
5.5.9.3. La classe Matcher.....................................................................................................................137
5.5.10. La classe Formatter...........................................................................................................................139
5.5.11. La classe Scanner..............................................................................................................................139
5.6. La présentation rapide du package java.net..................................................................................................140
5.7. La présentation rapide du package java.applet..............................................................................................140
6. Les fonctions mathématiques.......................................................................................................................................141
6.1. Les variables de classe..................................................................................................................................141
6.2. Les fonctions trigonométriques.....................................................................................................................141
6.3. Les fonctions de comparaisons.....................................................................................................................142
6.4. Les arrondis...................................................................................................................................................142
6.4.1. La méthode round(n)...........................................................................................................................142
6.4.2. La méthode rint(double)......................................................................................................................143
6.4.3. La méthode floor(double)...................................................................................................................143
6.4.4. La méthode ceil(double).....................................................................................................................143
6.4.5. La méthode abs(x)...............................................................................................................................144
6.5. La méthode IEEEremainder(double, double)................................................................................................144
6.6. Les Exponentielles et puissances..................................................................................................................144
6.6.1. La méthode pow(double, double).......................................................................................................144
6.6.2. La méthode sqrt(double).....................................................................................................................145
6.6.3. La méthode exp(double).....................................................................................................................145
6.6.4. La méthode log(double)......................................................................................................................145
6.7. La génération de nombres aléatoires.............................................................................................................145
6.8. La classe BigDecimal....................................................................................................................................146
7. La gestion des exceptions.............................................................................................................................................152
7.1. Les mots clés try, catch et finally..................................................................................................................153
7.2. La classe Throwable......................................................................................................................................154
7.3. Les classes Exception, RunTimeException et Error.....................................................................................155
7.4. Les exceptions personnalisées.......................................................................................................................155
7.5. Les exceptions chaînées................................................................................................................................156
7.6. L'utilisation des exceptions...........................................................................................................................157
8. Le multitâche.................................................................................................................................................................159
8.1. L'interface Runnable.....................................................................................................................................159
8.2. La classe Thread............................................................................................................................................160
8.3. La création et l'exécution d'un thread............................................................................................................162
8.3.1. La dérivation de la classe Thread........................................................................................................162
8.3.2. L'implémentation de l'interface Runnable..........................................................................................163
8.3.3. La modification de la priorité d'un thread...........................................................................................164
8.4. La classe ThreadGroup..................................................................................................................................165
8.5. Un thread en tâche de fond (démon).............................................................................................................165
8.6. L'exclusion mutuelle.....................................................................................................................................166
8.6.1. La sécurisation d'une méthode............................................................................................................166
8.6.2. La sécurisation d'un bloc.....................................................................................................................166
8.6.3. La sécurisation de variables de classes...............................................................................................167
8.6.4. La synchronisation : les méthodes wait() et notify()...........................................................................167
9. JDK 1.5 (nom de code Tiger).......................................................................................................................................168
9.1. Les nouveautés du langage Java version 1.5.................................................................................................168
9.2. L'autoboxing / unboxing................................................................................................................................169
9.3. Les importations statiques.............................................................................................................................169
9.4. Les annotations ou métadonnées (Meta Data)..............................................................................................170
9.5. Les arguments variables (varargs).................................................................................................................170
9.6. Les generics...................................................................................................................................................172
9.7. Les boucles pour le parcours des collections................................................................................................175

Table des matières
9. JDK 1.5 (nom de code Tiger)
9.8. Les énumérations (type enum)......................................................................................................................177
9.8.1. La définition d'une énumération.........................................................................................................178
9.8.2. L'utilisation d'une énumération...........................................................................................................179
9.8.3. L'enrichissement de l'énumération......................................................................................................180
9.8.4. La personnalisation de chaque élément..............................................................................................183
9.8.5. Les limitations dans la mise en oeuvre des énumérations..................................................................185
10. Les annotations...........................................................................................................................................................186
10.1. La présentation des annotations..................................................................................................................186
10.2. La mise en oeuvre des annotations..............................................................................................................187
10.3. L'utilisation des annotations........................................................................................................................188
10.3.1. La documentation..............................................................................................................................189
10.3.2. L'utilisation par le compilateur.........................................................................................................189
10.3.3. La génération de code.......................................................................................................................189
10.3.4. La génération de fichiers...................................................................................................................189
10.3.5. Les API qui utilisent les annotations.................................................................................................189
10.4. Les annotations standards............................................................................................................................190
10.4.1. L'annotation @Deprecated................................................................................................................190
10.4.2. L'annotation @Override....................................................................................................................191
10.4.3. L'annotation @SuppressWarning......................................................................................................192
10.5. Les annotations communes (Common Annotations)..................................................................................193
10.5.1. L'annotation @Generated..................................................................................................................194
10.5.2. Les annotations @Resource et @Resources.....................................................................................194
10.5.3. Les annotations @PostConstruct et @PreDestroy............................................................................195
10.6. Les annotations personnalisées...................................................................................................................195
10.6.1. La définition d'une annotation...........................................................................................................195
10.6.2. Les annotations pour les annotations................................................................................................197
10.6.2.1. L'annotation @Target.............................................................................................................197
10.6.2.2. L'annotation @Retention........................................................................................................198
10.6.2.3. L'annotation @Documented...................................................................................................198
10.6.2.4. L'annotation @Inherited.........................................................................................................199
10.7. L'exploitation des annotations.....................................................................................................................199
10.7.1. L'exploitation des annotations dans un Doclet..................................................................................199
10.7.2. L'exploitation des annotations avec l'outil Apt.................................................................................200
10.7.3. L'exploitation des annotations par introspection...............................................................................206
10.7.4. L'exploitation des annotations par le compilateur Java....................................................................208
10.8. L'API Pluggable Annotation Processing.....................................................................................................208
10.8.1. Les processeurs d'annotations...........................................................................................................209
10.8.2. L'utilisation des processeurs par le compilateur...............................................................................211
10.8.3. La création de nouveaux fichiers......................................................................................................211
10.9. Les ressources relatives aux annotations.....................................................................................................213
11. Java SE 7, le projet Coin............................................................................................................................................214
11.1. Les entiers exprimés en binaire (Binary Literals).......................................................................................215
11.2. Utilisation des underscores dans les entiers littéraux..................................................................................215
11.3. Utilisation des strings dans l'instruction switch..........................................................................................216
11.4. L'opérateur diamant.....................................................................................................................................217
11.5. L'instruction try-with-resources..................................................................................................................219
11.6. Des types plus précis lorsqu'une exception est relevée dans une clause catch...........................................227
11.7. Multiples exceptions dans une clause catch................................................................................................230
Partie 2 : Développement des interfaces graphiques.....................................................................................................233
12. Le graphisme...............................................................................................................................................................234
12.1. Les opérations sur le contexte graphique....................................................................................................234
12.1.1. Le tracé de formes géométriques......................................................................................................234
12.1.2. Le tracé de texte................................................................................................................................235
12.1.3. L'utilisation des fontes......................................................................................................................235

Table des matières
12. Le graphisme
12.1.4. La gestion de la couleur....................................................................................................................236
12.1.5. Le chevauchement de figures graphiques.........................................................................................236
12.1.6. L'effacement d'une aire.....................................................................................................................236
12.1.7. La copie d'une aire rectangulaire......................................................................................................236
13. Les éléments d'interfaces graphiques de l'AWT......................................................................................................237
13.1. Les composants graphiques.........................................................................................................................238
13.1.1. Les étiquettes.....................................................................................................................................238
13.1.2. Les boutons.......................................................................................................................................239
13.1.3. Les panneaux.....................................................................................................................................239
13.1.4. Les listes déroulantes (combobox)....................................................................................................239
13.1.5. La classe TextComponent.................................................................................................................241
13.1.6. Les champs de texte..........................................................................................................................241
13.1.7. Les zones de texte multilignes..........................................................................................................242
13.1.8. Les listes............................................................................................................................................244
13.1.9. Les cases à cocher.............................................................................................................................247
13.1.10. Les boutons radio............................................................................................................................248
13.1.11. Les barres de défilement.................................................................................................................248
13.1.12. La classe Canvas.............................................................................................................................250
13.2. La classe Component..................................................................................................................................250
13.3. Les conteneurs.............................................................................................................................................252
13.3.1. Le conteneur Panel............................................................................................................................253
13.3.2. Le conteneur Window.......................................................................................................................253
13.3.3. Le conteneur Frame..........................................................................................................................253
13.3.4. Le conteneur Dialog..........................................................................................................................255
13.4. Les menus....................................................................................................................................................255
13.4.1. Les méthodes de la classe MenuBar.................................................................................................257
13.4.2. Les méthodes de la classe Menu.......................................................................................................258
13.4.3. Les méthodes de la classe MenuItem................................................................................................258
13.4.4. Les méthodes de la classe CheckboxMenuItem...............................................................................258
13.5. La classe java.awt.Desktop.........................................................................................................................258
14. La création d'interfaces graphiques avec AWT......................................................................................................260
14.1. Le dimensionnement des composants.........................................................................................................260
14.2. Le positionnement des composants.............................................................................................................261
14.2.1. La mise en page par flot (FlowLayout).............................................................................................262
14.2.2. La mise en page bordure (BorderLayout).........................................................................................263
14.2.3. La mise en page de type carte (CardLayout)....................................................................................264
14.2.4. La mise en page GridLayout.............................................................................................................265
14.2.5. La mise en page GridBagLayout......................................................................................................266
14.3. La création de nouveaux composants à partir de Panel..............................................................................268
14.4. L'activation ou la désactivation des composants.........................................................................................268
15. L'interception des actions de l'utilisateur.................................................................................................................270
15.1. L'interception des actions de l'utilisateur avec Java version 1.0.................................................................270
15.2. L'interception des actions de l'utilisateur avec Java version 1.1.................................................................270
15.2.1. L'interface ItemListener....................................................................................................................272
15.2.2. L'interface TextListener....................................................................................................................273
15.2.3. L'interface MouseMotionListener.....................................................................................................274
15.2.4. L'interface MouseListener.................................................................................................................274
15.2.5. L'interface WindowListener..............................................................................................................275
15.2.6. Les différentes implémentations des Listeners.................................................................................276
15.2.6.1. Une classe implémentant elle même le listener......................................................................276
15.2.6.2. Une classe indépendante implémentant le listener.................................................................277
15.2.6.3. Une classe interne...................................................................................................................278
15.2.6.4. Une classe interne anonyme....................................................................................................278
15.2.7. Résumé..............................................................................................................................................279

Table des matières
16. Le développement d'interfaces graphiques avec SWING.......................................................................................280
16.1. La présentation de Swing............................................................................................................................280
16.2. Les packages Swing....................................................................................................................................281
16.3. Un exemple de fenêtre autonome................................................................................................................281
16.4. Les composants Swing................................................................................................................................282
16.4.1. La classe JFrame...............................................................................................................................283
16.4.1.1. Le comportement par défaut à la fermeture............................................................................285
16.4.1.2. La personnalisation de l'icône.................................................................................................286
16.4.1.3. Centrer une JFrame à l'écran...................................................................................................286
16.4.1.4. Les événements associées à un JFrame..................................................................................287
16.4.2. Les étiquettes : la classe JLabel........................................................................................................287
16.4.3. Les panneaux : la classe JPanel.........................................................................................................290
16.5. Les boutons.................................................................................................................................................290
16.5.1. La classe AbstractButton..................................................................................................................290
16.5.2. La classe JButton..............................................................................................................................292
16.5.3. La classe JToggleButton...................................................................................................................293
16.5.4. La classe ButtonGroup......................................................................................................................293
16.5.5. Les cases à cocher : la classe JCheckBox.........................................................................................294
16.5.6. Les boutons radio : la classe JRadioButton......................................................................................295
16.6. Les composants de saisie de texte...............................................................................................................299
16.6.1. La classe JTextComponent...............................................................................................................299
16.6.2. La classe JTextField..........................................................................................................................300
16.6.3. La classe JPasswordField..................................................................................................................301
16.6.4. La classe JFormattedTextField.........................................................................................................302
16.6.5. La classe JEditorPane........................................................................................................................302
16.6.6. La classe JTextPane..........................................................................................................................303
16.6.7. La classe JTextArea..........................................................................................................................303
16.7. Les onglets...................................................................................................................................................305
16.8. Le composant JTree....................................................................................................................................306
16.8.1. La création d'une instance de la classe JTree....................................................................................306
16.8.2. La gestion des données de l'arbre......................................................................................................309
16.8.2.1. L'interface TreeNode..............................................................................................................310
16.8.2.2. L'interface MutableTreeNode.................................................................................................311
16.8.2.3. La classe DefaultMutableTreeNode.......................................................................................311
16.8.3. La modification du contenu de l'arbre...............................................................................................312
16.8.3.1. Les modifications des noeuds fils...........................................................................................312
16.8.3.2. Les événements émis par le modèle........................................................................................313
16.8.3.3. L'édition d'un noeud................................................................................................................314
16.8.3.4. Les éditeurs personnalisés.......................................................................................................315
16.8.3.5. La définition des noeuds éditables..........................................................................................315
16.8.4. La mise en oeuvre d'actions sur l'arbre.............................................................................................316
16.8.4.1. Etendre ou refermer un noeud.................................................................................................316
16.8.4.2. La détermination du noeud sélectionné..................................................................................317
16.8.4.3. Le parcours des noeuds de l'arbre...........................................................................................317
16.8.5. La gestion des événements................................................................................................................318
16.8.5.1. La classe TreePath..................................................................................................................319
16.8.5.2. La gestion de la sélection d'un noeud.....................................................................................320
16.8.5.3. Les événements lies à la sélection de noeuds.........................................................................321
16.8.5.4. Les événements lorsqu'un noeud est étendu ou refermé.........................................................323
16.8.5.5. Le contrôle des actions pour étendre ou refermer un noeud...................................................324
16.8.6. La personnalisation du rendu............................................................................................................324
16.8.6.1. Personnaliser le rendu des noeuds..........................................................................................325
16.8.6.2. Les bulles d'aides (Tooltips)...................................................................................................328
16.9. Les menus....................................................................................................................................................328
16.9.1. La classe JMenuBar..........................................................................................................................331
16.9.2. La classe JMenuItem.........................................................................................................................333
16.9.3. La classe JPopupMenu......................................................................................................................333
16.9.4. La classe JMenu................................................................................................................................335
16.9.5. La classe JCheckBoxMenuItem........................................................................................................336

Table des matières
16. Le développement d'interfaces graphiques avec SWING
16.9.6. La classe JRadioButtonMenuItem....................................................................................................336
16.9.7. La classe JSeparator..........................................................................................................................336
16.10. L'affichage d'une image dans une application...........................................................................................337
17. Le développement d'interfaces graphiques avec SWT............................................................................................342
17.1. La présentation de SWT..............................................................................................................................342
17.2. Un exemple très simple...............................................................................................................................344
17.3. La classe SWT.............................................................................................................................................345
17.4. L'objet Display............................................................................................................................................345
17.5. L'objet Shell.................................................................................................................................................345
17.6. Les composants...........................................................................................................................................347
17.6.1. La classe Control...............................................................................................................................347
17.6.2. Les contrôles de base........................................................................................................................347
17.6.2.1. La classe Button......................................................................................................................348
17.6.2.2. La classe Label........................................................................................................................348
17.6.2.3. La classe Text.........................................................................................................................349
17.6.3. Les contrôles de type liste.................................................................................................................350
17.6.3.1. La classe Combo.....................................................................................................................350
17.6.3.2. La classe List...........................................................................................................................351
17.6.4. Les contrôles pour les menus............................................................................................................351
17.6.4.1. La classe Menu.......................................................................................................................351
17.6.4.2. La classe MenuItem................................................................................................................352
17.6.5. Les contrôles de sélection ou d'affichage d'une valeur.....................................................................353
17.6.5.1. La classe ProgressBar.............................................................................................................353
17.6.5.2. La classe Scale........................................................................................................................354
17.6.5.3. La classe Slider.......................................................................................................................354
17.6.6. Les contrôles de type « onglets »......................................................................................................355
17.6.6.1. La classe TabFolder................................................................................................................355
17.6.6.2. La classe TabItem...................................................................................................................356
17.6.7. Les contrôles de type « tableau »......................................................................................................356
17.6.7.1. La classe Table........................................................................................................................356
17.6.7.2. La classe TableColumn...........................................................................................................358
17.6.7.3. La classe TableItem................................................................................................................358
17.6.8. Les contrôles de type « arbre ».........................................................................................................359
17.6.8.1. La classe Tree.........................................................................................................................359
17.6.8.2. La classe TreeItem..................................................................................................................360
17.6.9. La classe ScrollBar............................................................................................................................360
17.6.10. Les contrôles pour le graphisme.....................................................................................................360
17.6.10.1. La classe Canvas...................................................................................................................360
17.6.10.2. La classe GC.........................................................................................................................361
17.6.10.3. La classe Color......................................................................................................................362
17.6.10.4. La classe Font.......................................................................................................................362
17.6.10.5. La classe Image.....................................................................................................................363
17.7. Les conteneurs.............................................................................................................................................364
17.7.1. Les conteneurs de base......................................................................................................................364
17.7.1.1. La classe Composite...............................................................................................................364
17.7.1.2. La classe Group.......................................................................................................................366
17.7.2. Les contrôles de type « barre d'outils ».............................................................................................366
17.7.2.1. La classe ToolBar...................................................................................................................366
17.7.2.2. La classe ToolItem..................................................................................................................367
17.7.2.3. Les classes CoolBar et Cooltem.............................................................................................369
17.8. La gestion des erreurs..................................................................................................................................370
17.9. Le positionnement des contrôles.................................................................................................................370
17.9.1. Le positionnement absolu.................................................................................................................371
17.9.2. Le positionnement relatif avec les LayoutManager..........................................................................371
17.9.2.1. FillLayout................................................................................................................................371
17.9.2.2. RowLayout..............................................................................................................................372
17.9.2.3. GridLayout..............................................................................................................................373

Table des matières
17. Le développement d'interfaces graphiques avec SWT
17.9.2.4. FormLayout............................................................................................................................376
17.10. La gestion des événements........................................................................................................................376
17.10.1. L'interface KeyListener...................................................................................................................377
17.10.2. L'interface MouseListener...............................................................................................................379
17.10.3. L'interface MouseMoveListener.....................................................................................................380
17.10.4. L'interface MouseTrackListener.....................................................................................................381
17.10.5. L'interface ModifyListener.............................................................................................................381
17.10.6. L'interface VerifyText()..................................................................................................................382
17.10.7. L'interface FocusListener................................................................................................................383
17.10.8. L'interface TraverseListener...........................................................................................................383
17.10.9. L'interface PaintListener.................................................................................................................384
17.11. Les boîtes de dialogue...............................................................................................................................385
17.11.1. Les boîtes de dialogue prédéfinies..................................................................................................386
17.11.1.1. La classe MessageBox..........................................................................................................386
17.11.1.2. La classe ColorDialog...........................................................................................................387
17.11.1.3. La classe FontDialog.............................................................................................................387
17.11.1.4. La classe FileDialog..............................................................................................................388
17.11.1.5. La classe DirectoryDialog.....................................................................................................389
17.11.1.6. La classe PrintDialog............................................................................................................390
17.11.2. Les boites de dialogue personnalisées............................................................................................391
18. JFace............................................................................................................................................................................393
18.1. La présentation de JFace.............................................................................................................................393
18.2. La structure générale d'une application.......................................................................................................394
18.3. Les boites de dialogue.................................................................................................................................395
18.3.1. L'affichage des messages d'erreur.....................................................................................................395
18.3.2. L'affichage des messages d'information à l'utilisateur......................................................................396
18.3.3. La saisie d'une valeur par l'utilisateur...............................................................................................398
18.3.4. La boîte de dialogue pour afficher la progression d'un traitement....................................................399
Partie 3 : Les API avancées..............................................................................................................................................403
19. Les collections..............................................................................................................................................................405
19.1. Présentation du framework collection.........................................................................................................405
19.2. Les interfaces des collections......................................................................................................................406
19.2.1. L'interface Collection........................................................................................................................407
19.2.2. L'interface Iterator.............................................................................................................................408
19.3. Les listes......................................................................................................................................................409
19.3.1. L'interface List..................................................................................................................................409
19.3.2. Les listes chaînées : la classe LinkedList..........................................................................................410
19.3.3. L'interface ListIterator.......................................................................................................................411
19.3.4. Les tableaux redimensionnables : la classe ArrayList......................................................................411
19.4. Les ensembles.............................................................................................................................................412
19.4.1. L'interface Set...................................................................................................................................412
19.4.2. L'interface SortedSet.........................................................................................................................412
19.4.3. La classe HashSet..............................................................................................................................413
19.4.4. La classe TreeSet..............................................................................................................................413
19.5. Les collections gérées sous la forme clé/valeur..........................................................................................414
19.5.1. L'interface Map.................................................................................................................................414
19.5.2. L'interface SortedMap.......................................................................................................................415
19.5.3. La classe Hashtable...........................................................................................................................415
19.5.4. La classe TreeMap............................................................................................................................416
19.5.5. La classe HashMap...........................................................................................................................416
19.6. Le tri des collections...................................................................................................................................417
19.6.1. L'interface Comparable.....................................................................................................................417
19.6.2. L'interface Comparator.....................................................................................................................417
19.7. Les algorithmes...........................................................................................................................................417
19.8. Les exceptions du framework.....................................................................................................................419

Table des matières
20. Les flux.........................................................................................................................................................................420
20.1. La présentation des flux..............................................................................................................................420
20.2. Les classes de gestion des flux....................................................................................................................420
20.3. Les flux de caractères..................................................................................................................................422
20.3.1. La classe Reader................................................................................................................................423
20.3.2. La classe Writer................................................................................................................................424
20.3.3. Les flux de caractères avec un fichier...............................................................................................424
20.3.3.1. Les flux de caractères en lecture sur un fichier.......................................................................424
20.3.3.2. Les flux de caractères en écriture sur un fichier.....................................................................425
20.3.4. Les flux de caractères tamponnés avec un fichier.............................................................................425
20.3.4.1. Les flux de caractères tamponnés en lecture avec un fichier..................................................425
20.3.4.2. Les flux de caractères tamponnés en écriture avec un fichier................................................426
20.3.4.3. La classe PrintWriter...............................................................................................................427
20.4. Les flux d'octets...........................................................................................................................................429
20.4.1. Les flux d'octets avec un fichier........................................................................................................429
20.4.1.1. Les flux d'octets en lecture sur un fichier...............................................................................430
20.4.1.2. Les flux d'octets en écriture sur un fichier..............................................................................430
20.4.2. Les flux d'octets tamponnés avec un fichier.....................................................................................432
20.5. La classe File...............................................................................................................................................432
20.6. Les fichiers à accès direct............................................................................................................................434
20.7. La classe java.io.Console............................................................................................................................436
21. NIO 2............................................................................................................................................................................437
21.1. Les entrées/sorties avec Java.......................................................................................................................438
21.2. Les principales classes et interfaces............................................................................................................438
21.3. L'interface Path............................................................................................................................................439
21.3.1. L'obtention d'une instance de type Path............................................................................................440
21.3.2. L'obtention d'éléments du chemin.....................................................................................................440
21.3.3. La manipulation d'un chemin............................................................................................................442
21.3.4. La comparaison de chemins..............................................................................................................443
21.3.5. La conversion d'un chemin...............................................................................................................444
21.4. Glob.............................................................................................................................................................445
21.5. La classe Files.............................................................................................................................................447
21.5.1. Les vérifications sur un fichier ou un répertoire...............................................................................447
21.5.2. La création d'un fichier ou d'un répertoire........................................................................................449
21.5.3. La copie d'un fichier ou d'un répertoire............................................................................................451
21.5.4. Le déplacement d'un fichier ou d'un répertoire.................................................................................453
21.5.5. La suppression d'un fichier ou d'un répertoire..................................................................................455
21.5.6. L'obtention du type de fichier...........................................................................................................456
21.6. Le parcourt du contenu de répertoires.........................................................................................................457
21.6.1. Le parcourt d'un répertoire................................................................................................................457
21.6.2. Le parcourt d'une hiérarchie de répertoires.......................................................................................460
21.6.3. Les opérations récursives..................................................................................................................462
21.7. L'utilisation de systèmes de gestion de fichiers..........................................................................................463
21.7.1. La classe FileSystems.......................................................................................................................463
21.7.2. La classe FileSystem.........................................................................................................................464
21.7.3. La création d'une implémentation de FileSystem.............................................................................464
21.7.4. Une implémentation de FileSystem pour les fichiers Zip.................................................................465
21.8. La lecture et l'écriture dans un fichier.........................................................................................................466
21.8.1. Les options d'ouverture d'un fichier..................................................................................................467
21.8.2. La lecture et l'écriture de l'intégralité d'un fichier.............................................................................468
21.8.3. La lecture et l'écriture bufférisée d'un fichier....................................................................................469
21.8.4. La lecture et l'écriture d'un flux d'octets...........................................................................................470
21.8.5. La lecture et l'écriture d'un fichier avec un channel..........................................................................471
21.9. Les liens et les liens symboliques...............................................................................................................472
21.9.1. La création d'un lien physique..........................................................................................................473
21.9.2. La création d'un lien symbolique......................................................................................................473
21.9.3. L'utilisation des liens et des liens symboliques.................................................................................474
21.10. La gestion des attributs..............................................................................................................................474

Table des matières
21. NIO 2
21.10.1. La gestion individuelle des attributs...............................................................................................474
21.10.2. La gestion de plusieurs attributs......................................................................................................475
21.10.3. L'utilisation des vues.......................................................................................................................477
21.10.4. La gestion des permissions DOS....................................................................................................478
21.10.5. La gestion des permissions Posix....................................................................................................479
21.11. La gestion des unités de stockages............................................................................................................481
21.12. Les notifications de changements dans un répertoire................................................................................482
21.12.1. La surveillance d'un répertoire........................................................................................................482
21.12.2. L'obtention des événements............................................................................................................484
21.12.3. Le traitement des événements.........................................................................................................485
21.12.4. Un exemple complet.......................................................................................................................486
21.12.5. L'utilisation et les limites de l'API WatchService...........................................................................488
21.13. La gestion des erreurs et la libération des ressources................................................................................488
21.14. L'interopérabilité avec le code existant.....................................................................................................490
21.14.1. L'équivalence des fonctionnalités entre java.io et NIO2.................................................................491
22. La sérialisation............................................................................................................................................................493
22.1. Les classes et les interfaces de la sérialisation............................................................................................493
22.1.1. L'interface Serializable......................................................................................................................493
22.1.2. La classe ObjectOuputStream...........................................................................................................494
22.1.3. La classe ObjectInputStream............................................................................................................495
22.2. Le mot clé transient.....................................................................................................................................496
22.3. La sérialisation personnalisée......................................................................................................................497
22.3.1. L'interface Externalizable.................................................................................................................497
23. L'interaction avec le réseau.......................................................................................................................................498
23.1. L'introduction aux concepts liés au réseau..................................................................................................498
23.2. Les adresses internet....................................................................................................................................499
23.2.1. La classe InetAddress........................................................................................................................499
23.3. L'accès aux ressources avec une URL.........................................................................................................500
23.3.1. La classe URL...................................................................................................................................501
23.3.2. La classe URLConnection................................................................................................................501
23.3.3. La classe URLEncoder......................................................................................................................502
23.3.4. La classe HttpURLConnection.........................................................................................................503
23.4. L'utilisation du protocole TCP....................................................................................................................504
23.4.1. La classe SocketServer......................................................................................................................504
23.4.2. La classe Socket................................................................................................................................506
23.5. L'utilisation du protocole UDP....................................................................................................................507
23.5.1. La classe DatagramSocket................................................................................................................507
23.5.2. La classe DatagramPacket................................................................................................................508
23.5.3. Un exemple de serveur et de client...................................................................................................508
23.6. Les exceptions liées au réseau.....................................................................................................................510
23.7. Les interfaces de connexions au réseau.......................................................................................................510
24. La gestion dynamique des objets et l'introspection.................................................................................................512
24.1. La classe Class............................................................................................................................................513
24.1.1. L'obtention d'un objet de type Class.................................................................................................513
24.1.1.1. La détermination de la classe d'un objet.................................................................................513
24.1.1.2. L'obtention d'un objet Class à partir d'un nom de classe........................................................513
24.1.1.3. Une troisième façon d'obtenir un objet Class.........................................................................514
24.1.2. Les méthodes de la classe Class........................................................................................................514
24.2. La recherche des informations sur une classe.............................................................................................515
24.2.1. La recherche de la classe mère d'une classe......................................................................................515
24.2.2. La recherche des modificateurs d'une classe.....................................................................................515
24.2.3. La recherche des interfaces implémentées par une classe................................................................516
24.2.4. La recherche des champs publics......................................................................................................516
24.2.5. La recherche des paramètres d'une méthode ou d'un constructeur...................................................517
24.2.6. La recherche des constructeurs de la classe......................................................................................518

Table des matières
24. La gestion dynamique des objets et l'introspection
24.2.7. La recherche des méthodes publiques...............................................................................................519
24.2.8. La recherche de toutes les méthodes.................................................................................................520
24.3. La définition dynamique d'objets................................................................................................................520
24.3.1. La création d'objets grâce à la classe Class.......................................................................................520
24.3.2. La création d'objets grâce à la classe Constructor.............................................................................521
24.4. L'exécution dynamique d'une méthode.......................................................................................................523
25. L'appel de méthodes distantes : RMI.......................................................................................................................524
25.1. La présentation et l'architecture de RMI.....................................................................................................524
25.2. Les différentes étapes pour créer un objet distant et l'appeler avec RMI....................................................524
25.3. Le développement coté serveur...................................................................................................................525
25.3.1. La définition d'une interface qui contient les méthodes de l'objet distant........................................525
25.3.2. L'écriture d'une classe qui implémente cette interface......................................................................525
25.3.3. L'écriture d'une classe pour instancier l'objet et l'enregistrer dans le registre...................................526
25.3.3.1. La mise en place d'un security manager.................................................................................526
25.3.3.2. L'instanciation d'un objet de la classe distante........................................................................527
25.3.3.3. L'enregistrement dans le registre de noms RMI.....................................................................527
25.3.3.4. Le lancement dynamique du registre de noms RMI...............................................................527
25.4. Le développement coté client......................................................................................................................528
25.4.1. La mise en place d'un security manager............................................................................................528
25.4.2. L'obtention d'une référence sur l'objet distant à partir de son nom...................................................529
25.4.3. L'appel à la méthode à partir de la référence sur l'objet distant........................................................529
25.4.4. L'appel d'une méthode distante dans une applet...............................................................................530
25.5. La génération de la classe stub....................................................................................................................530
25.6. La mise en oeuvre des objets RMI..............................................................................................................531
25.6.1. Le lancement du registre RMI..........................................................................................................531
25.6.2. L'instanciation et l'enregistrement de l'objet distant.........................................................................531
25.6.3. Le lancement de l'application cliente................................................................................................531
26. L'internationalisation.................................................................................................................................................534
26.1. Les objets de type Locale............................................................................................................................534
26.1.1. La création d'un objet Locale............................................................................................................534
26.1.2. L'obtention de la liste des Locales disponibles.................................................................................535
26.1.3. L'utilisation d'un objet Locale...........................................................................................................536
26.2. La classe ResourceBundle...........................................................................................................................536
26.2.1. La création d'un objet ResourceBundle............................................................................................536
26.2.2. Les sous classes de ResourceBundle................................................................................................537
26.2.2.1. L'utilisation de PropertyResourceBundle...............................................................................537
26.2.2.2. L'utilisation de ListResourceBundle.......................................................................................537
26.2.3. L'obtention d'un texte d'un objet ResourceBundle............................................................................538
26.3. Un guide pour réaliser la localisation..........................................................................................................538
26.3.1. L'utilisation d'un ResourceBundle avec un fichier propriétés...........................................................538
26.3.2. Des exemples de classes utilisant PropertiesResourceBundle..........................................................539
26.3.3. L'utilisation de la classe ListResourceBundle...................................................................................540
26.3.4. Des exemples de classes utilisant ListResourceBundle....................................................................541
26.3.5. La création de sa propre classe fille de ResourceBundle..................................................................543
27. Les composants Java beans........................................................................................................................................547
27.1. La présentation des Java beans....................................................................................................................547
27.2. Les propriétés..............................................................................................................................................548
27.2.1. Les propriétés simples.......................................................................................................................548
27.2.2. Les propriétés indexées (indexed properties)....................................................................................549
27.2.3. Les propriétés liées (Bound properties)............................................................................................549
27.2.4. Les propriétés liées avec contraintes (Constrained properties).........................................................551
27.3. Les méthodes...............................................................................................................................................553
27.4. Les événements...........................................................................................................................................553
27.5. L'introspection.............................................................................................................................................553
27.5.1. Les modèles (design patterns)...........................................................................................................554

Développez en java

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (10)

Similaire à Développez en java

Similaire à Développez en java (20)

Dernier

Dernier (20)

Développez en java