Developpons en Java

afternoonhandsomelySoftware and s/w Development

Nov 17, 2012 (4 years and 7 months ago)

1,995 views

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.........................................................................................................................................................3
Notes de licence.......................................................................................................................................................3
Marques déposées....................................................................................................................................................4
Historique des versions............................................................................................................................................4
Partie 1 : les bases du langage Java....................................................................................................................................6
1. Présentation.......................................................................................................................................................................7
1.1. Les caractéristiques...........................................................................................................................................7
1.2. Bref historique de Java......................................................................................................................................8
1.3. Les différentes éditions et versions de Java......................................................................................................9
1.3.1. Java 1.0....................................................................................................................................................9
1.3.2. Java 1.1....................................................................................................................................................9
1.3.3. Java 1.2..................................................................................................................................................10
1.3.4. J2SE 1.3................................................................................................................................................10
1.3.5. J2SE 1.4 (nom de code Merlin)............................................................................................................10
1.3.6. J2SE 5.0 (nom de code Tiger)...............................................................................................................11
1.3.7. Les futurs versions de Java...................................................................................................................11
1.3.8. Le résumé des différentes versions.......................................................................................................12
1.3.9. Les extensions du JDK..........................................................................................................................12
1.4. Un rapide tour d'horizon des API et de quelques outils..................................................................................12
1.5. Les différences entre Java et JavaScript..........................................................................................................14
1.6. L'installation du JDK.......................................................................................................................................14
1.6.1. L'installation de la version 1.3 DU JDK de Sun sous Windows 9x......................................................14
1.6.2. L'installation de la documentation de Java 1.3 sous Windows.............................................................16
1.6.3. La configuration des variables système sous Windows 9x...................................................................17
1.6.4. Les éléments du JDK 1.3 sous Windows..............................................................................................18
1.6.5. L'installation de la version 1.4.2 du JDK de Sun sous Windows..........................................................18
1.6.6. L'installation de la version 1.5 beta 1 du JDK de Sun sous Windows..................................................19
1.6.7. Installation JDK 1.4.2 sous Linux Mandrake 10..................................................................................20
2. Les techniques de base de programmation en Java....................................................................................................24
2.1. La compilation d'un code source.....................................................................................................................24
2.2. L'exécution d'un programme et d'une applet...................................................................................................24
2.2.1. L'exécution d'un programme.................................................................................................................24
2.2.2. L'exécution d'une applet........................................................................................................................25
3. La syntaxe et les éléments de bases de Java.................................................................................................................26
3.1. Les règles de base............................................................................................................................................26
3.2. Les identificateurs...........................................................................................................................................26
3.3. Les commentaires............................................................................................................................................27
3.4. La déclaration et l'utilisation de variables.......................................................................................................27
3.4.1. La déclaration de variables...................................................................................................................27
3.4.2. Les types élémentaires..........................................................................................................................28
3.4.3. Le format des types élémentaires..........................................................................................................29
3.4.4. L'initialisation des variables..................................................................................................................30
3.4.5. L'affectation..........................................................................................................................................30
3.4.6. Les comparaisons..................................................................................................................................31
3.5. Les opérations arithmétiques...........................................................................................................................31
3.5.1. L'arithmétique entière...........................................................................................................................31
3.5.2. L'arithmétique en virgule flottante........................................................................................................32
3.5.3. L'incrémentation et la décrémentation..................................................................................................33
3.6. La priorité des opérateurs................................................................................................................................33
3.7. Les structures de contrôles..............................................................................................................................34
3.7.1. Les boucles............................................................................................................................................34
Développons en Java
Table des matières
3. La syntaxe et les éléments de bases de Java
3.7.2. Les branchements conditionnels...........................................................................................................35
3.7.3. Les débranchements..............................................................................................................................36
3.8. Les tableaux.....................................................................................................................................................36
3.8.1. La déclaration des tableaux...................................................................................................................36
3.8.2. L'initialisation explicite d'un tableau....................................................................................................37
3.8.3. Le parcours d'un tableau.......................................................................................................................37
3.9. Les conversions de types.................................................................................................................................38
3.9.1. La conversion d'un entier int en chaîne de caractère String..................................................................38
3.9.2. La conversion d'une chaîne de caractères String en entier int..............................................................39
3.9.3. La conversion d'un entier int en entier long..........................................................................................39
3.10. La manipulation des chaînes de caractères...................................................................................................39
3.10.1. Les caractères spéciaux dans les chaines............................................................................................40
3.10.2. L'addition de chaines...........................................................................................................................40
3.10.3. La comparaison de deux chaines........................................................................................................40
3.10.4. La détermination de la longueur d'une chaine....................................................................................40
3.10.5. La modification de la casse d'une chaine............................................................................................41
4. La programmation orientée objet.................................................................................................................................42
4.1. Le concept de classe........................................................................................................................................42
4.1.1. La syntaxe de déclaration d'une classe..................................................................................................42
4.2. Les objets.........................................................................................................................................................43
4.2.1. La création d'un objet : instancier une classe........................................................................................43
4.2.2. La durée de vie d'un objet.....................................................................................................................45
4.2.3. La création d'objets identiques..............................................................................................................45
4.2.4. Les références et la comparaison d'objets.............................................................................................45
4.2.5. L'objet null............................................................................................................................................46
4.2.6. Les variables de classes.........................................................................................................................46
4.2.7. La variable this......................................................................................................................................46
4.2.8. L'opérateur instanceof...........................................................................................................................47
4.3. Les modificateurs d'accès................................................................................................................................47
4.3.1. Les mots clés qui gèrent la visibilité des entités...................................................................................48
4.3.2. Le mot clé static....................................................................................................................................48
4.3.3. Le mot clé final.....................................................................................................................................49
4.3.4. Le mot clé abstract................................................................................................................................50
4.3.5. Le mot clé synchronized.......................................................................................................................50
4.3.6. Le mot clé volatile.................................................................................................................................50
4.3.7. Le mot clé native...................................................................................................................................50
4.4. Les propriétés ou attributs...............................................................................................................................51
4.4.1. Les variables d'instances.......................................................................................................................51
4.4.2. Les variables de classes.........................................................................................................................51
4.4.3. Les constantes.......................................................................................................................................51
4.5. Les méthodes...................................................................................................................................................51
4.5.1. La syntaxe de la déclaration..................................................................................................................52
4.5.2. La transmission de paramètres..............................................................................................................53
4.5.3. L'emmission de messages.....................................................................................................................53
4.5.4. L'enchainement de références à des variables et à des méthodes.........................................................54
4.5.5. La surcharge de méthodes.....................................................................................................................54
4.5.6. Les constructeurs...................................................................................................................................55
4.5.7. Le destructeur........................................................................................................................................55
4.5.8. Les accesseurs.......................................................................................................................................56
4.6. L'héritage.........................................................................................................................................................56
4.6.1. Le principe de l'héritage........................................................................................................................56
4.6.2. La mise en oeuvre de l'héritage.............................................................................................................57
4.6.3. L'accès aux propriétés héritées..............................................................................................................57
4.6.4. La redéfinition d'une méthode héritée...................................................................................................57
4.6.5. Le polymorphisme................................................................................................................................57
4.6.6. Le transtypage induit par l'héritage facilitent le polymorphisme..........................................................57
4.6.7. Les interfaces et l'héritage multiple......................................................................................................58
Développons en Java
Table des matières
4. La programmation orientée objet
4.6.8. Des conseils sur l'héritage.....................................................................................................................59
4.7. Les packages...................................................................................................................................................60
4.7.1. La définition d'un package....................................................................................................................60
4.7.2. L'utilisation d'un package......................................................................................................................60
4.7.3. La collision de classes...........................................................................................................................61
4.7.4. Les packages et l'environnement système.............................................................................................61
4.8. Les classes internes.........................................................................................................................................61
4.8.1. Les classes internes non statiques.........................................................................................................63
4.8.2. Les classes internes locales...................................................................................................................67
4.8.3. Les classes internes anonymes..............................................................................................................70
4.8.4. Les classes internes statiques................................................................................................................71
4.9. La gestion dynamique des objets....................................................................................................................72
5. Les packages de bases.....................................................................................................................................................73
5.1. Liste des packages selon la version du JDK...................................................................................................73
5.2. Le package java.lang.......................................................................................................................................77
5.2.1. La classe Object....................................................................................................................................78
5.2.1.1. La méthode getClass()................................................................................................................78
5.2.1.2. La méthode toString().................................................................................................................78
5.2.1.3. La méthode equals()....................................................................................................................78
5.2.1.4. La méthode finalize()..................................................................................................................78
5.2.1.5. La méthode clone().....................................................................................................................79
5.2.2. La classe String.....................................................................................................................................79
5.2.3. La classe StringBuffer...........................................................................................................................80
5.2.4. Les wrappers.........................................................................................................................................81
5.2.5. La classe System...................................................................................................................................82
5.2.5.1. L'utilisation des flux d'entrée/sortie standard..............................................................................82
5.2.5.2. Les variables d'environnement et les propriétés du système......................................................84
5.2.6. La classe Runtime.................................................................................................................................85
5.3. Présentation rapide du package awt java.........................................................................................................86
5.4. Présentation rapide du package java.io...........................................................................................................86
5.5. Le package java.util.........................................................................................................................................86
5.5.1. La classe StringTokenizer.....................................................................................................................86
5.5.2. La classe Random.................................................................................................................................87
5.5.3. Les classes Date et Calendar.................................................................................................................87
5.5.4. La classe Vector....................................................................................................................................88
5.5.5. La classe Hashtable...............................................................................................................................89
5.5.6. L'interface Enumeration........................................................................................................................90
5.5.7. Les expressions régulières....................................................................................................................91
5.5.7.1. Les motifs...................................................................................................................................91
5.5.7.2. La classe Pattern.........................................................................................................................93
5.5.7.3. La classe Matcher.......................................................................................................................93
5.5.8. La classe Formatter...............................................................................................................................96
5.5.9. La classe Scanner..................................................................................................................................96
5.6. Présentation rapide du package java.net.........................................................................................................97
5.7. Présentation rapide du package java.applet.....................................................................................................97
6. Les fonctions mathématiques.........................................................................................................................................98
6.1. Les variables de classe....................................................................................................................................98
6.2. Les fonctions trigonométriques.......................................................................................................................98
6.3. Les fonctions de comparaisons.......................................................................................................................99
6.4. Les arrondis.....................................................................................................................................................99
6.4.1. La méthode round(n).............................................................................................................................99
6.4.2. La méthode rint(double)......................................................................................................................100
6.4.3. La méthode floor(double)...................................................................................................................100
6.4.4. La méthode ceil(double).....................................................................................................................100
6.4.5. La méthode abs(x)...............................................................................................................................101
6.5. La méthode IEEEremainder(double, double)................................................................................................101
Développons en Java
Table des matières
6. Les fonctions mathématiques
6.6. Les Exponentielles et puissances..................................................................................................................101
6.6.1. La méthode pow(double, double).......................................................................................................102
6.6.2. La méthode sqrt(double).....................................................................................................................102
6.6.3. La méthode exp(double).....................................................................................................................102
6.6.4. La méthode log(double)......................................................................................................................102
6.7. La génération de nombres aléatoires.............................................................................................................103
6.7.1. La méthode random()..........................................................................................................................103
7. La gestion des exceptions.............................................................................................................................................104
7.1. Les mots clés try, catch et finally..................................................................................................................105
7.2. La classe Throwable......................................................................................................................................106
7.3. Les classes Exception, RunTimeException et Error.....................................................................................107
7.4. Les exceptions personnalisées.......................................................................................................................107
8. Le multitâche.................................................................................................................................................................109
8.1. L'interface Runnable.....................................................................................................................................109
8.2. La classe Thread............................................................................................................................................110
8.3. La création et l'exécution d'un thread............................................................................................................112
8.3.1. La dérivation de la classe Thread........................................................................................................112
8.3.2. Implémentation de l'interface Runnable.............................................................................................113
8.3.3. Modification de la priorité d'un thread................................................................................................114
8.4. La classe ThreadGroup..................................................................................................................................115
8.5. Thread en tâche de fond (démon)..................................................................................................................115
8.6. Exclusion mutuelle........................................................................................................................................116
8.6.1. Sécurisation d'une méthode.................................................................................................................116
8.6.2. Sécurisation d'un bloc.........................................................................................................................116
8.6.3. Sécurisation de variables de classes....................................................................................................117
8.6.4. La synchronisation : les méthodes wait() et notify()...........................................................................117
9. JDK 1.5 (nom de code Tiger).......................................................................................................................................118
9.1. Les nouveautés du langage Java version 1.5.................................................................................................118
9.2. Autoboxing / unboxing..................................................................................................................................118
9.3. Static import..................................................................................................................................................119
9.4. Les méta données (Meta Data)......................................................................................................................120
9.5. Les arguments variables (varargs).................................................................................................................120
9.6. Les generics...................................................................................................................................................122
9.7. Amélioration des boucles pour les collections..............................................................................................125
9.8. Les énumérations (type enum)......................................................................................................................127
Partie 2 : Développement des interfaces graphiques.....................................................................................................131
10. Le graphisme...............................................................................................................................................................132
10.1. Les opérations sur le contexte graphique....................................................................................................132
10.1.1. Le tracé de formes géométriques......................................................................................................132
10.1.2. Le tracé de texte................................................................................................................................133
10.1.3. L'utilisation des fontes......................................................................................................................133
10.1.4. La gestion de la couleur....................................................................................................................134
10.1.5. Le chevauchement de figures graphiques.........................................................................................134
10.1.6. L'effacement d'une aire.....................................................................................................................134
10.1.7. La copier une aire rectangulaire........................................................................................................134
11. Les éléments d'interfaces graphiques de l'AWT......................................................................................................135
11.1. Les composants graphiques.........................................................................................................................136
11.1.1. Les étiquettes.....................................................................................................................................136
11.1.2. Les boutons.......................................................................................................................................137
11.1.3. Les panneaux.....................................................................................................................................137
11.1.4. Les listes déroulantes (combobox)....................................................................................................137
11.1.5. La classe TextComponent.................................................................................................................139
Développons en Java
Table des matières
11. Les éléments d'interfaces graphiques de l'AWT
11.1.6. Les champs de texte..........................................................................................................................139
11.1.7. Les zones de texte multilignes..........................................................................................................140
11.1.8. Les listes............................................................................................................................................141
11.1.9. Les cases à cocher.............................................................................................................................144
11.1.10. Les boutons radio............................................................................................................................145
11.1.11. Les barres de défilement.................................................................................................................146
11.1.12. La classe Canvas.............................................................................................................................147
11.2. La classe Component..................................................................................................................................147
11.3. Les conteneurs.............................................................................................................................................149
11.3.1. Le conteneur Panel............................................................................................................................150
11.3.2. Le conteneur Window.......................................................................................................................150
11.3.3. Le conteneur Frame..........................................................................................................................150
11.3.4. Le conteneur Dialog..........................................................................................................................152
11.4. Les menus....................................................................................................................................................153
11.4.1. Les méthodes de la classe MenuBar.................................................................................................154
11.4.2. Les méthodes de la classe Menu.......................................................................................................155
11.4.3. Les méthodes de la classe MenuItem................................................................................................155
11.4.4. Les méthodes de la classe CheckboxMenuItem...............................................................................155
12. La création d'interfaces graphiques avec AWT......................................................................................................157
12.1. Le dimensionnement des composants.........................................................................................................157
12.2. Le positionnement des composants.............................................................................................................158
12.2.1. La mise en page par flot (FlowLayout).............................................................................................159
12.2.2. La mise en page bordure (BorderLayout).........................................................................................160
12.2.3. La mise en page de type carte (CardLayout)....................................................................................161
12.2.4. La mise en page GridLayout.............................................................................................................162
12.2.5. La mise en page GridBagLayout......................................................................................................164
12.3. La création de nouveaux composants à partir de Panel..............................................................................165
12.4. Activer ou desactiver des composants........................................................................................................166
12.5. Afficher une image dans une application....................................................................................................166
13. L'interception des actions de l'utilisateur.................................................................................................................167
13.1. Intercepter les actions de l'utilisateur avec Java version 1.0.......................................................................167
13.2. Intercepter les actions de l'utilisateur avec Java version 1.1.......................................................................167
13.2.1. L'interface ItemListener....................................................................................................................169
13.2.2. L'interface TextListener....................................................................................................................170
13.2.3. L'interface MouseMotionListener.....................................................................................................171
13.2.4. L'interface MouseListener.................................................................................................................171
13.2.5. L'interface WindowListener..............................................................................................................172
13.2.6. Les différentes implémentations des Listener...................................................................................173
13.2.6.1. Une classe implémentant elle même le listener......................................................................173
13.2.6.2. Une classe indépendante implémentant le listener.................................................................174
13.2.6.3. Une classe interne...................................................................................................................175
13.2.6.4. Une classe interne anonyme....................................................................................................175
13.2.7. Résumé..............................................................................................................................................176
14. Le développement d'interfaces graphiques avec SWING.......................................................................................177
14.1. Présentation de Swing.................................................................................................................................177
14.2. Les packages Swing....................................................................................................................................178
14.3. Un exemple de fenêtre autonome................................................................................................................178
14.4. Les composants Swing................................................................................................................................179
14.4.1. La classe JFrame...............................................................................................................................179
14.4.1.1. Le comportement par défaut à la fermeture............................................................................182
14.4.1.2. La personnalisation de l'icône.................................................................................................183
14.4.1.3. Centrer une JFrame à l'écran...................................................................................................183
14.4.1.4. Les évenements associées à un JFrame..................................................................................184
14.4.2. Les étiquettes : la classe JLabel........................................................................................................184
14.4.3. Les panneaux : la classe Jpanel.........................................................................................................187
Développons en Java
Table des matières
14. Le développement d'interfaces graphiques avec SWING
14.5. Les boutons.................................................................................................................................................187
14.5.1. La classe AbstractButton..................................................................................................................187
14.5.2. La classe JButton..............................................................................................................................189
14.5.3. La classe JToggleButton...................................................................................................................190
14.5.4. La classe ButtonGroup......................................................................................................................190
14.5.5. Les cases à cocher : la classe JCheckBox.........................................................................................191
14.5.6. Les boutons radio : la classe JRadioButton......................................................................................192
14.6. Les composants de saisie de texte...............................................................................................................192
14.6.1. La classe JTextComponent...............................................................................................................193
14.6.2. La classe JTextField..........................................................................................................................194
14.6.3. La classe JPasswordField..................................................................................................................194
14.6.4. La classe JFormattedTextField.........................................................................................................196
14.6.5. La classe JEditorPane........................................................................................................................196
14.6.6. La classe JTextPane..........................................................................................................................197
14.6.7. La classe JTextArea..........................................................................................................................197
14.7. Les onglets...................................................................................................................................................199
14.8. Le composant JTree....................................................................................................................................200
14.8.1. La création d'une instance de la classe JTree....................................................................................200
14.8.2. La gestion des données de l'arbre......................................................................................................203
14.8.2.1. L'interface TreeNode..............................................................................................................204
14.8.2.2. L'interface MutableTreeNode.................................................................................................204
14.8.2.3. La classe DefaultMutableTreeNode.......................................................................................205
14.8.3. La modification du contenu de l'arbre...............................................................................................206
14.8.3.1. Les modifications des noeuds fils...........................................................................................206
14.8.3.2. Les événements émis par le modèle........................................................................................207
14.8.3.3. L'édition d'un noeud................................................................................................................208
14.8.3.4. Les éditeurs personnalisés.......................................................................................................208
14.8.3.5. 3.5 Définir les noeuds éditables..............................................................................................209
14.8.4. La mise en oeuvre d'actions sur l'arbre.............................................................................................210
14.8.4.1. Etendre ou refermer un noeud.................................................................................................210
14.8.4.2. Déterminer le noeud sélectionné.............................................................................................211
14.8.4.3. Parcourir les noeuds de l'arbre................................................................................................211
14.8.5. La gestion des événements................................................................................................................212
14.8.5.1. La classe TreePath..................................................................................................................213
14.8.5.2. La gestion de la sélection d'un noeud.....................................................................................214
14.8.5.3. Les événements lies à la selection de noeuds.........................................................................216
14.8.5.4. Les événements lorsqu'un noeud est étendu ou refermé.........................................................217
14.8.5.5. Le contrôle des actions pour étendre ou refermer un noeud...................................................218
14.8.6. La personnalisation du rendu............................................................................................................218
14.8.6.1. Personnaliser le rendu des noeuds..........................................................................................219
14.8.6.2. Les bulles d'aides (Tooltips)...................................................................................................222
15. Le développement d'interfaces graphiques avec SWT............................................................................................223
15.1. Présentation.................................................................................................................................................223
15.2. Un exemple très simple...............................................................................................................................225
15.3. La classe SWT.............................................................................................................................................225
15.4. L'objet Display............................................................................................................................................226
15.5. L'objet Shell.................................................................................................................................................226
15.6. Les composants...........................................................................................................................................228
15.6.1. La classe Control...............................................................................................................................228
15.6.2. Les contrôles de base........................................................................................................................228
15.6.2.1. La classe Button......................................................................................................................228
15.6.2.2. La classe Label........................................................................................................................229
15.6.2.3. La classe Text.........................................................................................................................230
15.6.3. Les contrôles de type liste.................................................................................................................231
15.6.3.1. La classe Combo.....................................................................................................................231
15.6.3.2. La classe List...........................................................................................................................231
15.6.4. 1.6.4 Les contrôles pour les menus...................................................................................................232
Développons en Java
Table des matières
15. Le développement d'interfaces graphiques avec SWT
15.6.4.1. La classe Menu.......................................................................................................................232
15.6.4.2. La classe MenuItem................................................................................................................233
15.6.5. Les contrôles de sélection ou d'affichage d'une valeur.....................................................................234
15.6.5.1. La classe ProgressBar.............................................................................................................234
15.6.5.2. La classe Scale........................................................................................................................234
15.6.5.3. La classe Slider.......................................................................................................................235
15.6.6. Les contrôles de type « onglets »......................................................................................................236
15.6.6.1. La classe TabFolder................................................................................................................236
15.6.6.2. La classe TabItem...................................................................................................................236
15.6.7. Les contrôles de type « tableau »......................................................................................................237
15.6.7.1. La classe Table........................................................................................................................237
15.6.7.2. La classe TableColumn...........................................................................................................238
15.6.7.3. La classe TableItem................................................................................................................239
15.6.8. Les contrôles de type « arbre ».........................................................................................................239
15.6.8.1. La classe Tree.........................................................................................................................239
15.6.8.2. La classe TreeItem..................................................................................................................240
15.6.9. La classe ScrollBar............................................................................................................................241
15.6.10. Les contrôles pour le graphisme.....................................................................................................241
15.6.10.1. La classe Canvas...................................................................................................................241
15.6.10.2. La classe GC.........................................................................................................................241
15.6.10.3. La classe Color......................................................................................................................242
15.6.10.4. La classe Font.......................................................................................................................243
15.6.10.5. La classe Image.....................................................................................................................244
15.7. 1.7 Les conteneurs.......................................................................................................................................245
15.7.1. Les conteneurs de base......................................................................................................................245
15.7.1.1. La classe Composite...............................................................................................................245
15.7.1.2. La classe Group.......................................................................................................................246
15.7.2. Les contrôles de type « barre d'outils ».............................................................................................247
15.7.2.1. La classe ToolBar...................................................................................................................247
15.7.2.2. La classe ToolItem..................................................................................................................248
15.7.2.3. Les classes CoolBar et Cooltem.............................................................................................250
15.8. La gestion des erreurs..................................................................................................................................251
15.9. Le positionnement des contrôles.................................................................................................................251
15.9.1. 1.9.1 Le positionnement absolu........................................................................................................252
15.9.2. 1.9.2 La positionnement relatif avec les LayoutManager.................................................................252
15.9.2.1. 1.9.2.1 FillLayout....................................................................................................................252
15.9.2.2. 1.9.2.2 RowLayout..................................................................................................................253
15.9.2.3. GridLayout..............................................................................................................................254
15.9.2.4. FormLayout............................................................................................................................257
15.10. La gestion des événements........................................................................................................................257
15.10.1. L'interface KeyListener...................................................................................................................258
15.10.2. L'interface MouseListener...............................................................................................................260
15.10.3. L'interface MouseMoveListener.....................................................................................................261
15.10.4. L'interface MouseTrackListener.....................................................................................................262
15.10.5. L'interface ModifyListener.............................................................................................................262
15.10.6. L'interface VerifyText()..................................................................................................................263
15.10.7. L'interface FocusListener................................................................................................................264
15.10.8. L'interface TraverseListener...........................................................................................................265
15.10.9. L'interface PaintListener.................................................................................................................266
15.11. Les boîtes de dialogue...............................................................................................................................267
15.11.1. Les boîtes de dialogues prédéfinies................................................................................................267
15.11.1.1. La classe MessageBox..........................................................................................................267
15.11.1.2. La classe ColorDialog...........................................................................................................268
15.11.1.3. La classe FontDialog.............................................................................................................269
15.11.1.4. La classe FileDialog..............................................................................................................270
15.11.1.5. La classe DirectoryDialog.....................................................................................................271
15.11.1.6. La classe PrintDialog............................................................................................................271
15.11.2. Les boites de dialogues personnalisées...........................................................................................272
Développons en Java
Table des matières
16. JFace............................................................................................................................................................................274
17. Les applets...................................................................................................................................................................275
17.1. L'intégration d'applets dans une page HTML.............................................................................................275
17.2. Les méthodes des applets............................................................................................................................276
17.2.1. La méthode init()...............................................................................................................................276
17.2.2. La méthode start().............................................................................................................................276
17.2.3. La méthode stop().............................................................................................................................276
17.2.4. La méthode destroy()........................................................................................................................276
17.2.5. La méthode update().........................................................................................................................276
17.2.6. La méthode paint()............................................................................................................................277
17.2.7. Les méthodes size() et getSize().......................................................................................................277
17.2.8. Les méthodes getCodeBase() et getDocumentBase().......................................................................278
17.2.9. La méthode showStatus()..................................................................................................................278
17.2.10. La méthode getAppletInfo()............................................................................................................278
17.2.11. La méthode getParameterInfo()......................................................................................................279
17.2.12. La méthode getGraphics()...............................................................................................................279
17.2.13. La méthode getAppletContext()......................................................................................................279
17.2.14. La méthode setStub()......................................................................................................................279
17.3. Les interfaces utiles pour les applets...........................................................................................................279
17.3.1. L'interface Runnable.........................................................................................................................279
17.3.2. L'interface ActionListener.................................................................................................................280
17.3.3. L'interface MouseListener pour répondre à un clic de souris...........................................................280
17.4. La transmission de paramètres à une applet................................................................................................280
17.5. Applet et le multimédia...............................................................................................................................281
17.5.1. Insertion d'images.............................................................................................................................281
17.5.2. Insertion de sons................................................................................................................................282
17.5.3. Animation d'un logo..........................................................................................................................283
17.6. Applet et application (applet pouvant s'exécuter comme application)........................................................284
17.7. Les droits des applets..................................................................................................................................285
Partie 3 : Les API avancées..............................................................................................................................................286
18. Les collections..............................................................................................................................................................288
18.1. Présentation du framework collection.........................................................................................................288
18.2. Les interfaces des collections......................................................................................................................289
18.2.1. L'interface Collection........................................................................................................................290
18.2.2. L'interface Iterator.............................................................................................................................291
18.3. Les listes......................................................................................................................................................292
18.3.1. L'interface List..................................................................................................................................292
18.3.2. Les listes chaînées : la classe LinkedList..........................................................................................292
18.3.3. L'interface ListIterator.......................................................................................................................293
18.3.4. Les tableaux redimensionnables : la classe ArrayList......................................................................294
18.4. Les ensembles.............................................................................................................................................295
18.4.1. L'interface Set...................................................................................................................................295
18.4.2. L'interface SortedSet.........................................................................................................................295
18.4.3. La classe HashSet..............................................................................................................................296
18.4.4. La classe TreeSet..............................................................................................................................296
18.5. Les collections gérées sous la forme clé/valeur..........................................................................................297
18.5.1. L'interface Map.................................................................................................................................297
18.5.2. L'interface SortedMap.......................................................................................................................298
18.5.3. La classe Hashtable...........................................................................................................................298
18.5.4. La classe TreeMap............................................................................................................................299
18.5.5. La classe HashMap...........................................................................................................................299
18.6. Le tri des collections...................................................................................................................................299
18.6.1. L'interface Comparable.....................................................................................................................300
18.6.2. L'interface Comparator.....................................................................................................................300
18.7. Les algorithmes...........................................................................................................................................300
18.8. Les exceptions du framework.....................................................................................................................301
Développons en Java
Table des matières
19. Les flux.........................................................................................................................................................................303
19.1. Présentation des flux...................................................................................................................................303
19.2. Les classes de gestion des flux....................................................................................................................303
19.3. Les flux de caractères..................................................................................................................................305
19.3.1. La classe Reader................................................................................................................................306
19.3.2. La classe Writer................................................................................................................................307
19.3.3. Les flux de caractères avec un fichier...............................................................................................307
19.3.3.1. Les flux de caractères en lecture sur un fichier.......................................................................307
19.3.3.2. Les flux de caractères en écriture sur un fichier.....................................................................308
19.3.4. Les flux de caractères tamponnés avec un fichier.............................................................................308
19.3.4.1. Les flux de caractères tamponnés en lecture avec un fichier..................................................308
19.3.4.2. Les flux de caractères tamponnés en écriture avec un fichier................................................309
19.3.4.3. La classe PrintWriter...............................................................................................................310
19.4. Les flux d'octets...........................................................................................................................................312
19.4.1. Les flux d'octets avec un fichier........................................................................................................312
19.4.1.1. Les flux d'octets en lecture sur un fichier...............................................................................312
19.4.1.2. Les flux d'octets en écriture sur un fichier..............................................................................313
19.4.2. Les flux d'octets tamponnés avec un fichier.....................................................................................314
19.5. La classe File...............................................................................................................................................315
19.6. Les fichiers à accès direct............................................................................................................................317
20. La sérialisation............................................................................................................................................................319
20.1. Les classes et les interfaces de la sérialisation............................................................................................319
20.1.1. L'interface Serializable......................................................................................................................319
20.1.2. La classe ObjectOuputStream...........................................................................................................320
20.1.3. La classe ObjectInputStream............................................................................................................321
20.2. Le mot clé transient.....................................................................................................................................322
20.3. La sérialisation personnalisée......................................................................................................................323
20.3.1. L'interface Externalizable.................................................................................................................323
21. L'interaction avec le réseau.......................................................................................................................................324
21.1. Introduction.................................................................................................................................................324
21.2. Les adresses internet....................................................................................................................................325
21.2.1. La classe InetAddress........................................................................................................................325
21.3. L'accès aux ressources avec une URL.........................................................................................................326
21.3.1. La classe URL...................................................................................................................................326
21.3.2. La classe URLConnection................................................................................................................327
21.3.3. La classe URLEncoder......................................................................................................................328
21.3.4. La classe HttpURLConnection.........................................................................................................329
21.4. Utilisation du protocole TCP.......................................................................................................................329
21.4.1. La classe SocketServer......................................................................................................................330
21.4.2. La classe Socket................................................................................................................................331
21.5. Utilisation du protocole UDP......................................................................................................................333
21.5.1. La classe DatagramSocket................................................................................................................333
21.5.2. La classe DatagramPacket................................................................................................................334
21.5.3. Un exemple de serveur et de client...................................................................................................334
21.6. Les exceptions liées au réseau.....................................................................................................................336
21.7. Les interfaces de connexions au réseau.......................................................................................................336
22. L'accès aux bases de données : JDBC.......................................................................................................................338
22.1. Les outils nécessaires pour utiliser JDBC...................................................................................................338
22.2. Les types de pilotes JDBC..........................................................................................................................338
22.3. Enregistrer une base de données dans ODBC sous Windows 9x ou XP....................................................339
22.4. Présentation des classes de l'API JDBC......................................................................................................341
22.5. La connexion à une base de données..........................................................................................................341
22.5.1. Le chargement du pilote....................................................................................................................341
22.5.2. L'établissement de la connection.......................................................................................................342
22.6. Accéder à la base de données......................................................................................................................343
22.6.1. L'execution de requêtes SQL............................................................................................................343
Développons en Java
Table des matières
22. L'accès aux bases de données : JDBC
22.6.2. La classe ResultSet............................................................................................................................344
22.6.3. Exemple complet de mise à jour et de sélection sur une table..........................................................346
22.7. Obtenir des informations sur la base de données........................................................................................347
22.7.1. La classe ResultSetMetaData............................................................................................................347
22.7.2. La classe DatabaseMetaData............................................................................................................348
22.8. L'utilisation d'un objet PreparedStatement..................................................................................................348
22.9. L'utilisation des transactions.......................................................................................................................350
22.10. Les procédures stockées............................................................................................................................350
22.11. Le traitement des erreurs JDBC................................................................................................................351
22.12. JDBC 2.0...................................................................................................................................................352
22.12.1. Les fonctionnalités de l'objet ResultSet..........................................................................................352
22.12.2. Les mises à jour de masse (Batch Updates)....................................................................................355
22.12.3. Le package javax.sql.......................................................................................................................355
22.12.4. La classe DataSource......................................................................................................................356
22.12.5. Les pools de connexion...................................................................................................................356
22.12.6. Les transactions distribuées............................................................................................................356
22.12.7. L'API RowSet.................................................................................................................................357
22.13. JDBC 3.0...................................................................................................................................................357
22.14. MySQL et Java..........................................................................................................................................357
22.14.1. Installation sous Windows..............................................................................................................357
22.14.2. Opérations de base avec MySQL....................................................................................................358
22.14.3. Utilisation de MySQL avec Java via ODBC..................................................................................360
22.14.3.1. Déclaration d'une source de données ODBC vers la base de données.................................360
22.14.3.2. Utilisation de la source de données.......................................................................................362
22.14.4. Utilisation de MySQL avec Java via un pilote JDBC.....................................................................363
23. La gestion dynamique des objets et l'introspection.................................................................................................366
23.1. La classe Class............................................................................................................................................366
23.1.1. Obtenir un objet de la classe Class....................................................................................................367
23.1.1.1. Connaître la classe d'un objet..................................................................................................367
23.1.1.2. Obtenir un objet Class à partir d'un nom de classe.................................................................367
23.1.1.3. Une troisième façon d'obtenir un objet Class.........................................................................368
23.1.2. Les méthodes de la classe Class........................................................................................................368
23.2. Rechercher des informations sur une classe................................................................................................368
23.2.1. Rechercher la classe mère d'une classe.............................................................................................369
23.2.2. Rechercher les modificateurs d'une classe........................................................................................369
23.2.3. Rechercher les interfaces implémentées par une classe....................................................................370
23.2.4. Rechercher les champs publics.........................................................................................................370
23.2.5. Rechercher les paramètres d'une méthode ou d'un constructeur.......................................................371
23.2.6. Rechercher les constructeurs de la classe.........................................................................................372
23.2.7. Rechercher les méthodes publiques..................................................................................................373
23.2.8. Rechercher toutes les méthodes........................................................................................................373
23.3. Définir dynamiquement des objets..............................................................................................................374
23.3.1. Définir des objets grâce à la classe Class..........................................................................................374
23.3.2. Exécuter dynamiquement une méthode............................................................................................374
24. L'appel de méthodes distantes : RMI.......................................................................................................................375
24.1. Présentation et architecture de RMI............................................................................................................375
24.2. Les différentes étapes pour créer un objet distant et l'appeler avec RMI....................................................375
24.3. Le développement coté serveur...................................................................................................................376
24.3.1. La définition d'une interface qui contient les méthodes de l'objet distant........................................376
24.3.2. L'écriture d'une classe qui implémente cette interface......................................................................376
24.3.3. L'écriture d'une classe pour instancier l'objet et l'enregistrer dans le registre...................................377
24.3.3.1. La mise en place d'un security manager.................................................................................377
24.3.3.2. L'instanciation d'un objet de la classe distante........................................................................377
24.3.3.3. L'enregistrement dans le registre de nom RMI en lui donnant un nom..................................378
24.3.3.4. Lancement dynamique du registre de nom RMI.....................................................................378
24.4. Le développement coté client......................................................................................................................379
Développons en Java
Table des matières
24. L'appel de méthodes distantes : RMI
24.4.1. La mise en place d'un security manager............................................................................................379
24.4.2. L'obtention d'une référence sur l'objet distant à partir de son nom...................................................379
24.4.3. L'appel à la méthode à partir de la référence sur l'objet distant........................................................380
24.4.4. L'appel d'une méthode distante dans une applet...............................................................................380
24.5. La génération des classes stub et skeleton..................................................................................................381
24.6. La mise en oeuvre des objets RMI..............................................................................................................381
24.6.1. Le lancement du registre RMI..........................................................................................................381
24.6.2. L'instanciation et l'enregistrement de l'objet distant.........................................................................381
24.6.3. Le lancement de l'application cliente................................................................................................382
25. L'internationalisation.................................................................................................................................................383
25.1. Les objets de type Locale............................................................................................................................383
25.1.1. Création d'un objet Locale................................................................................................................383
25.1.2. Obtenir la liste des Locales disponibles............................................................................................384
25.1.3. L'utilisation d'un objet Locale...........................................................................................................385
25.2. La classe ResourceBundle...........................................................................................................................385
25.2.1. La création d'un objet ResourceBundle............................................................................................385
25.2.2. Les sous classes de ResourceBundle................................................................................................386
25.2.2.1. L'utilisation de PropertyResourceBundle...............................................................................386
25.2.2.2. L'utilisation de ListResourceBundle.......................................................................................386
25.2.3. Obtenir un texte d'un objet ResourceBundle.....................................................................................387
25.3. Chemins guidés pour réaliser la localisation...............................................................................................387
25.3.1. L'utilisation d'un ResourceBundle avec un fichier propriétés...........................................................387
25.3.2. Exemples de classes utilisant PropertiesResourceBundle................................................................388
25.3.3. L'utilisation de la classe ListResourceBundle...................................................................................389
25.3.4. Exemples de classes utilisant ListResourceBundle..........................................................................390
25.3.5. La création de sa propre classe fille de ResourceBundle..................................................................392
25.3.6. Exemple de classes utilisant une classe fille de ResourceBundle.....................................................393
26. Les composants java beans........................................................................................................................................396
26.1. Présentations des java beans.......................................................................................................................396
26.2. Les propriétés..............................................................................................................................................397
26.2.1. Les propriétés simples.......................................................................................................................397
26.2.2. les propriétés indexées (indexed properties).....................................................................................398
26.2.3. Les propriétés liées (Bound properties)............................................................................................398
26.2.4. Les propriétés liées avec contraintes (Constrained properties).........................................................400
26.3. Les méthodes...............................................................................................................................................402
26.4. Les événements...........................................................................................................................................402
26.5. L'introspection.............................................................................................................................................402
26.5.1. Les modèles (designs patterns).........................................................................................................403
26.5.2. La classe BeanInfo............................................................................................................................403
26.6. Paramétrage du bean ( Customization )......................................................................................................405
26.7. La persistance..............................................................................................................................................405
26.8. La diffusion sous forme de jar.....................................................................................................................405
26.9. Le B.D.K.....................................................................................................................................................406
27. Logging........................................................................................................................................................................407
27.1. Log4j...........................................................................................................................................................407
27.1.1. Les catégories....................................................................................................................................408
27.1.1.1. La hiérarchie dans les catégories............................................................................................409
27.1.1.2. Les priorités............................................................................................................................409