Développons en JavaJean Michel DOUDOUX

Table des matièresDéveloppons en Java.............................................................................................................................................................1

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

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

1. Présentation.......................................................................................................................................................................71.1. Les caractéristiques...........................................................................................................................................71.2. Bref historique de Java......................................................................................................................................81.3. Les différentes éditions et versions de Java......................................................................................................9

1.3.1. Java 1.0....................................................................................................................................................91.3.2. Java 1.1....................................................................................................................................................91.3.3. Java 1.2..................................................................................................................................................101.3.4. J2SE 1.3................................................................................................................................................101.3.5. J2SE 1.4 (nom de code Merlin)............................................................................................................101.3.6. J2SE 5.0 (nom de code Tiger)...............................................................................................................111.3.7. Les futurs versions de Java...................................................................................................................111.3.8. Le résumé des différentes versions.......................................................................................................121.3.9. Les extensions du JDK..........................................................................................................................12

1.4. Un rapide tour d'horizon des API et de quelques outils..................................................................................121.5. Les différences entre Java et JavaScript..........................................................................................................141.6. L'installation du JDK.......................................................................................................................................14

1.6.1. L'installation de la version 1.3 DU JDK de Sun sous Windows 9x......................................................141.6.2. L'installation de la documentation de Java 1.3 sous Windows.............................................................161.6.3. La configuration des variables système sous Windows 9x...................................................................171.6.4. Les éléments du JDK 1.3 sous Windows..............................................................................................181.6.5. L'installation de la version 1.4.2 du JDK de Sun sous Windows..........................................................181.6.6. L'installation de la version 1.5 beta 1 du JDK de Sun sous Windows..................................................191.6.7. Installation JDK 1.4.2 sous Linux Mandrake 10..................................................................................20

2. Les techniques de base de programmation en Java....................................................................................................242.1. La compilation d'un code source.....................................................................................................................242.2. L'exécution d'un programme et d'une applet...................................................................................................24

2.2.1. L'exécution d'un programme.................................................................................................................242.2.2. L'exécution d'une applet........................................................................................................................25

3. La syntaxe et les éléments de bases de Java.................................................................................................................263.1. Les règles de base............................................................................................................................................263.2. Les identificateurs...........................................................................................................................................263.3. Les commentaires............................................................................................................................................273.4. La déclaration et l'utilisation de variables.......................................................................................................27

3.4.1. La déclaration de variables...................................................................................................................273.4.2. Les types élémentaires..........................................................................................................................283.4.3. Le format des types élémentaires..........................................................................................................293.4.4. L'initialisation des variables..................................................................................................................303.4.5. L'affectation..........................................................................................................................................303.4.6. Les comparaisons..................................................................................................................................31

3.5. Les opérations arithmétiques...........................................................................................................................313.5.1. L'arithmétique entière...........................................................................................................................313.5.2. L'arithmétique en virgule flottante........................................................................................................323.5.3. L'incrémentation et la décrémentation..................................................................................................33

3.6. La priorité des opérateurs................................................................................................................................333.7. Les structures de contrôles..............................................................................................................................34

3.7.1. Les boucles............................................................................................................................................34

Développons en Java

Table des matières3. La syntaxe et les éléments de bases de Java

3.7.2. Les branchements conditionnels...........................................................................................................353.7.3. Les débranchements..............................................................................................................................36

3.8. Les tableaux.....................................................................................................................................................363.8.1. La déclaration des tableaux...................................................................................................................363.8.2. L'initialisation explicite d'un tableau....................................................................................................373.8.3. Le parcours d'un tableau.......................................................................................................................37

3.9. Les conversions de types.................................................................................................................................383.9.1. La conversion d'un entier int en chaîne de caractère String..................................................................383.9.2. La conversion d'une chaîne de caractères String en entier int..............................................................393.9.3. La conversion d'un entier int en entier long..........................................................................................39

3.10. La manipulation des chaînes de caractères...................................................................................................393.10.1. Les caractères spéciaux dans les chaines............................................................................................403.10.2. L'addition de chaines...........................................................................................................................403.10.3. La comparaison de deux chaines........................................................................................................403.10.4. La détermination de la longueur d'une chaine....................................................................................403.10.5. La modification de la casse d'une chaine............................................................................................41

4. La programmation orientée objet.................................................................................................................................424.1. Le concept de classe........................................................................................................................................42

4.1.1. La syntaxe de déclaration d'une classe..................................................................................................424.2. Les objets.........................................................................................................................................................43

4.2.1. La création d'un objet : instancier une classe........................................................................................434.2.2. La durée de vie d'un objet.....................................................................................................................454.2.3. La création d'objets identiques..............................................................................................................454.2.4. Les références et la comparaison d'objets.............................................................................................454.2.5. L'objet null............................................................................................................................................464.2.6. Les variables de classes.........................................................................................................................464.2.7. La variable this......................................................................................................................................464.2.8. L'opérateur instanceof...........................................................................................................................47

4.3. Les modificateurs d'accès................................................................................................................................474.3.1. Les mots clés qui gèrent la visibilité des entités...................................................................................484.3.2. Le mot clé static....................................................................................................................................484.3.3. Le mot clé final.....................................................................................................................................494.3.4. Le mot clé abstract................................................................................................................................504.3.5. Le mot clé synchronized.......................................................................................................................504.3.6. Le mot clé volatile.................................................................................................................................504.3.7. Le mot clé native...................................................................................................................................50

4.4. Les propriétés ou attributs...............................................................................................................................514.4.1. Les variables d'instances.......................................................................................................................514.4.2. Les variables de classes.........................................................................................................................514.4.3. Les constantes.......................................................................................................................................51

4.5. Les méthodes...................................................................................................................................................514.5.1. La syntaxe de la déclaration..................................................................................................................524.5.2. La transmission de paramètres..............................................................................................................534.5.3. L'emmission de messages.....................................................................................................................534.5.4. L'enchainement de références à des variables et à des méthodes.........................................................544.5.5. La surcharge de méthodes.....................................................................................................................544.5.6. Les constructeurs...................................................................................................................................554.5.7. Le destructeur........................................................................................................................................554.5.8. Les accesseurs.......................................................................................................................................56

4.6. L'héritage.........................................................................................................................................................564.6.1. Le principe de l'héritage........................................................................................................................564.6.2. La mise en oeuvre de l'héritage.............................................................................................................574.6.3. L'accès aux propriétés héritées..............................................................................................................574.6.4. La redéfinition d'une méthode héritée...................................................................................................574.6.5. Le polymorphisme................................................................................................................................574.6.6. Le transtypage induit par l'héritage facilitent le polymorphisme..........................................................574.6.7. Les interfaces et l'héritage multiple......................................................................................................58

Développons en Java

Table des matières4. La programmation orientée objet

4.6.8. Des conseils sur l'héritage.....................................................................................................................594.7. Les packages...................................................................................................................................................60

4.7.1. La définition d'un package....................................................................................................................604.7.2. L'utilisation d'un package......................................................................................................................604.7.3. La collision de classes...........................................................................................................................614.7.4. Les packages et l'environnement système.............................................................................................61

4.8. Les classes internes.........................................................................................................................................614.8.1. Les classes internes non statiques.........................................................................................................634.8.2. Les classes internes locales...................................................................................................................674.8.3. Les classes internes anonymes..............................................................................................................704.8.4. Les classes internes statiques................................................................................................................71

4.9. La gestion dynamique des objets....................................................................................................................72

5. Les packages de bases.....................................................................................................................................................735.1. Liste des packages selon la version du JDK...................................................................................................735.2. Le package java.lang.......................................................................................................................................77

5.2.1. La classe Object....................................................................................................................................785.2.1.1. La méthode getClass()................................................................................................................785.2.1.2. La méthode toString().................................................................................................................785.2.1.3. La méthode equals()....................................................................................................................785.2.1.4. La méthode finalize()..................................................................................................................785.2.1.5. La méthode clone().....................................................................................................................79

5.2.2. La classe String.....................................................................................................................................795.2.3. La classe StringBuffer...........................................................................................................................805.2.4. Les wrappers.........................................................................................................................................815.2.5. La classe System...................................................................................................................................82

5.2.5.1. L'utilisation des flux d'entrée/sortie standard..............................................................................825.2.5.2. Les variables d'environnement et les propriétés du système......................................................84

5.2.6. La classe Runtime.................................................................................................................................855.3. Présentation rapide du package awt java.........................................................................................................865.4. Présentation rapide du package java.io...........................................................................................................865.5. Le package java.util.........................................................................................................................................86

5.5.1. La classe StringTokenizer.....................................................................................................................865.5.2. La classe Random.................................................................................................................................875.5.3. Les classes Date et Calendar.................................................................................................................875.5.4. La classe Vector....................................................................................................................................885.5.5. La classe Hashtable...............................................................................................................................895.5.6. L'interface Enumeration........................................................................................................................905.5.7. Les expressions régulières....................................................................................................................91

5.5.7.1. Les motifs...................................................................................................................................915.5.7.2. La classe Pattern.........................................................................................................................935.5.7.3. La classe Matcher.......................................................................................................................93

5.5.8. La classe Formatter...............................................................................................................................965.5.9. La classe Scanner..................................................................................................................................96

5.6. Présentation rapide du package java.net.........................................................................................................975.7. Présentation rapide du package java.applet.....................................................................................................97

6. Les fonctions mathématiques.........................................................................................................................................986.1. Les variables de classe....................................................................................................................................986.2. Les fonctions trigonométriques.......................................................................................................................986.3. Les fonctions de comparaisons.......................................................................................................................996.4. Les arrondis.....................................................................................................................................................99

6.4.1. La méthode round(n).............................................................................................................................996.4.2. La méthode rint(double)......................................................................................................................1006.4.3. La méthode floor(double)...................................................................................................................1006.4.4. La méthode ceil(double).....................................................................................................................1006.4.5. La méthode abs(x)...............................................................................................................................101

6.5. La méthode IEEEremainder(double, double)................................................................................................101

Développons en Java

Table des matières6. Les fonctions mathématiques

6.6. Les Exponentielles et puissances..................................................................................................................1016.6.1. La méthode pow(double, double).......................................................................................................1026.6.2. La méthode sqrt(double).....................................................................................................................1026.6.3. La méthode exp(double).....................................................................................................................1026.6.4. La méthode log(double)......................................................................................................................102

6.7. La génération de nombres aléatoires.............................................................................................................1036.7.1. La méthode random()..........................................................................................................................103

7. La gestion des exceptions.............................................................................................................................................1047.1. Les mots clés try, catch et finally..................................................................................................................1057.2. La classe Throwable......................................................................................................................................1067.3. Les classes Exception, RunTimeException et Error.....................................................................................1077.4. Les exceptions personnalisées.......................................................................................................................107

8. Le multitâche.................................................................................................................................................................1098.1. L'interface Runnable.....................................................................................................................................1098.2. La classe Thread............................................................................................................................................1108.3. La création et l'exécution d'un thread............................................................................................................112

8.3.1. La dérivation de la classe Thread........................................................................................................1128.3.2. Implémentation de l'interface Runnable.............................................................................................1138.3.3. Modification de la priorité d'un thread................................................................................................114

8.4. La classe ThreadGroup..................................................................................................................................1158.5. Thread en tâche de fond (démon)..................................................................................................................1158.6. Exclusion mutuelle........................................................................................................................................116

8.6.1. Sécurisation d'une méthode.................................................................................................................1168.6.2. Sécurisation d'un bloc.........................................................................................................................1168.6.3. Sécurisation de variables de classes....................................................................................................1178.6.4. La synchronisation : les méthodes wait() et notify()...........................................................................117

9. JDK 1.5 (nom de code Tiger).......................................................................................................................................1189.1. Les nouveautés du langage Java version 1.5.................................................................................................1189.2. Autoboxing / unboxing..................................................................................................................................1189.3. Static import..................................................................................................................................................1199.4. Les méta données (Meta Data)......................................................................................................................1209.5. Les arguments variables (varargs).................................................................................................................1209.6. Les generics...................................................................................................................................................1229.7. Amélioration des boucles pour les collections..............................................................................................1259.8. Les énumérations (type enum)......................................................................................................................127

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

10. Le graphisme...............................................................................................................................................................13210.1. Les opérations sur le contexte graphique....................................................................................................132

10.1.1. Le tracé de formes géométriques......................................................................................................13210.1.2. Le tracé de texte................................................................................................................................13310.1.3. L'utilisation des fontes......................................................................................................................13310.1.4. La gestion de la couleur....................................................................................................................13410.1.5. Le chevauchement de figures graphiques.........................................................................................13410.1.6. L'effacement d'une aire.....................................................................................................................13410.1.7. La copier une aire rectangulaire........................................................................................................134

11. Les éléments d'interfaces graphiques de l'AWT......................................................................................................13511.1. Les composants graphiques.........................................................................................................................136

11.1.1. Les étiquettes.....................................................................................................................................13611.1.2. Les boutons.......................................................................................................................................13711.1.3. Les panneaux.....................................................................................................................................13711.1.4. Les listes déroulantes (combobox)....................................................................................................13711.1.5. La classe TextComponent.................................................................................................................139

Développons en Java

Table des matières11. Les éléments d'interfaces graphiques de l'AWT

11.1.6. Les champs de texte..........................................................................................................................13911.1.7. Les zones de texte multilignes..........................................................................................................14011.1.8. Les listes............................................................................................................................................14111.1.9. Les cases à cocher.............................................................................................................................14411.1.10. Les boutons radio............................................................................................................................14511.1.11. Les barres de défilement.................................................................................................................14611.1.12. La classe Canvas.............................................................................................................................147

11.2. La classe Component..................................................................................................................................14711.3. Les conteneurs.............................................................................................................................................149

11.3.1. Le conteneur Panel............................................................................................................................15011.3.2. Le conteneur Window.......................................................................................................................15011.3.3. Le conteneur Frame..........................................................................................................................15011.3.4. Le conteneur Dialog..........................................................................................................................152

11.4. Les menus....................................................................................................................................................15311.4.1. Les méthodes de la classe MenuBar.................................................................................................15411.4.2. Les méthodes de la classe Menu.......................................................................................................15511.4.3. Les méthodes de la classe MenuItem................................................................................................15511.4.4. Les méthodes de la classe CheckboxMenuItem...............................................................................155

12. La création d'interfaces graphiques avec AWT......................................................................................................15712.1. Le dimensionnement des composants.........................................................................................................15712.2. Le positionnement des composants.............................................................................................................158

12.2.1. La mise en page par flot (FlowLayout).............................................................................................15912.2.2. La mise en page bordure (BorderLayout).........................................................................................16012.2.3. La mise en page de type carte (CardLayout)....................................................................................16112.2.4. La mise en page GridLayout.............................................................................................................16212.2.5. La mise en page GridBagLayout......................................................................................................164

12.3. La création de nouveaux composants à partir de Panel..............................................................................16512.4. Activer ou desactiver des composants........................................................................................................16612.5. Afficher une image dans une application....................................................................................................166

13. L'interception des actions de l'utilisateur.................................................................................................................16713.1. Intercepter les actions de l'utilisateur avec Java version 1.0.......................................................................16713.2. Intercepter les actions de l'utilisateur avec Java version 1.1.......................................................................167

13.2.1. L'interface ItemListener....................................................................................................................16913.2.2. L'interface TextListener....................................................................................................................17013.2.3. L'interface MouseMotionListener.....................................................................................................17113.2.4. L'interface MouseListener.................................................................................................................17113.2.5. L'interface WindowListener..............................................................................................................17213.2.6. Les différentes implémentations des Listener...................................................................................173

13.2.6.1. Une classe implémentant elle même le listener......................................................................17313.2.6.2. Une classe indépendante implémentant le listener.................................................................17413.2.6.3. Une classe interne...................................................................................................................17513.2.6.4. Une classe interne anonyme....................................................................................................175

13.2.7. Résumé..............................................................................................................................................176

14. Le développement d'interfaces graphiques avec SWING.......................................................................................17714.1. Présentation de Swing.................................................................................................................................17714.2. Les packages Swing....................................................................................................................................17814.3. Un exemple de fenêtre autonome................................................................................................................17814.4. Les composants Swing................................................................................................................................179

14.4.1. La classe JFrame...............................................................................................................................17914.4.1.1. Le comportement par défaut à la fermeture............................................................................18214.4.1.2. La personnalisation de l'icône.................................................................................................18314.4.1.3. Centrer une JFrame à l'écran...................................................................................................18314.4.1.4. Les évenements associées à un JFrame..................................................................................184

14.4.2. Les étiquettes : la classe JLabel........................................................................................................18414.4.3. Les panneaux : la classe Jpanel.........................................................................................................187

Développons en Java

Table des matières14. Le développement d'interfaces graphiques avec SWING

14.5. Les boutons.................................................................................................................................................18714.5.1. La classe AbstractButton..................................................................................................................18714.5.2. La classe JButton..............................................................................................................................18914.5.3. La classe JToggleButton...................................................................................................................19014.5.4. La classe ButtonGroup......................................................................................................................19014.5.5. Les cases à cocher : la classe JCheckBox.........................................................................................19114.5.6. Les boutons radio : la classe JRadioButton......................................................................................192

14.6. Les composants de saisie de texte...............................................................................................................19214.6.1. La classe JTextComponent...............................................................................................................19314.6.2. La classe JTextField..........................................................................................................................19414.6.3. La classe JPasswordField..................................................................................................................19414.6.4. La classe JFormattedTextField.........................................................................................................19614.6.5. La classe JEditorPane........................................................................................................................19614.6.6. La classe JTextPane..........................................................................................................................19714.6.7. La classe JTextArea..........................................................................................................................197

14.7. Les onglets...................................................................................................................................................19914.8. Le composant JTree....................................................................................................................................200

14.8.1. La création d'une instance de la classe JTree....................................................................................20014.8.2. La gestion des données de l'arbre......................................................................................................203

14.8.2.1. L'interface TreeNode..............................................................................................................20414.8.2.2. L'interface MutableTreeNode.................................................................................................20414.8.2.3. La classe DefaultMutableTreeNode.......................................................................................205

14.8.3. La modification du contenu de l'arbre...............................................................................................20614.8.3.1. Les modifications des noeuds fils...........................................................................................20614.8.3.2. Les événements émis par le modèle........................................................................................20714.8.3.3. L'édition d'un noeud................................................................................................................20814.8.3.4. Les éditeurs personnalisés.......................................................................................................20814.8.3.5. 3.5 Définir les noeuds éditables..............................................................................................209

14.8.4. La mise en oeuvre d'actions sur l'arbre.............................................................................................21014.8.4.1. Etendre ou refermer un noeud.................................................................................................21014.8.4.2. Déterminer le noeud sélectionné.............................................................................................21114.8.4.3. Parcourir les noeuds de l'arbre................................................................................................211

14.8.5. La gestion des événements................................................................................................................21214.8.5.1. La classe TreePath..................................................................................................................21314.8.5.2. La gestion de la sélection d'un noeud.....................................................................................21414.8.5.3. Les événements lies à la selection de noeuds.........................................................................21614.8.5.4. Les événements lorsqu'un noeud est étendu ou refermé.........................................................21714.8.5.5. Le contrôle des actions pour étendre ou refermer un noeud...................................................218

14.8.6. La personnalisation du rendu............................................................................................................21814.8.6.1. Personnaliser le rendu des noeuds..........................................................................................21914.8.6.2. Les bulles d'aides (Tooltips)...................................................................................................222

15. Le développement d'interfaces graphiques avec SWT............................................................................................22315.1. Présentation.................................................................................................................................................22315.2. Un exemple très simple...............................................................................................................................22515.3. La classe SWT.............................................................................................................................................22515.4. L'objet Display............................................................................................................................................22615.5. L'objet Shell.................................................................................................................................................22615.6. Les composants...........................................................................................................................................228

15.6.1. La classe Control...............................................................................................................................22815.6.2. Les contrôles de base........................................................................................................................228

15.6.2.1. La classe Button......................................................................................................................22815.6.2.2. La classe Label........................................................................................................................22915.6.2.3. La classe Text.........................................................................................................................230

15.6.3. Les contrôles de type liste.................................................................................................................23115.6.3.1. La classe Combo.....................................................................................................................23115.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ères15. Le développement d'interfaces graphiques avec SWT

15.6.4.1. La classe Menu.......................................................................................................................23215.6.4.2. La classe MenuItem................................................................................................................233

15.6.5. Les contrôles de sélection ou d'affichage d'une valeur.....................................................................23415.6.5.1. La classe ProgressBar.............................................................................................................23415.6.5.2. La classe Scale........................................................................................................................23415.6.5.3. La classe Slider.......................................................................................................................235

15.6.6. Les contrôles de type « onglets »......................................................................................................23615.6.6.1. La classe TabFolder................................................................................................................23615.6.6.2. La classe TabItem...................................................................................................................236

15.6.7. Les contrôles de type « tableau »......................................................................................................23715.6.7.1. La classe Table........................................................................................................................23715.6.7.2. La classe TableColumn...........................................................................................................23815.6.7.3. La classe TableItem................................................................................................................239

15.6.8. Les contrôles de type « arbre ».........................................................................................................23915.6.8.1. La classe Tree.........................................................................................................................23915.6.8.2. La classe TreeItem..................................................................................................................240

15.6.9. La classe ScrollBar............................................................................................................................24115.6.10. Les contrôles pour le graphisme.....................................................................................................241

15.6.10.1. La classe Canvas...................................................................................................................24115.6.10.2. La classe GC.........................................................................................................................24115.6.10.3. La classe Color......................................................................................................................24215.6.10.4. La classe Font.......................................................................................................................24315.6.10.5. La classe Image.....................................................................................................................244

15.7. 1.7 Les conteneurs.......................................................................................................................................24515.7.1. Les conteneurs de base......................................................................................................................245

15.7.1.1. La classe Composite...............................................................................................................24515.7.1.2. La classe Group.......................................................................................................................246

15.7.2. Les contrôles de type « barre d'outils ».............................................................................................24715.7.2.1. La classe ToolBar...................................................................................................................24715.7.2.2. La classe ToolItem..................................................................................................................24815.7.2.3. Les classes CoolBar et Cooltem.............................................................................................250

15.8. La gestion des erreurs..................................................................................................................................25115.9. Le positionnement des contrôles.................................................................................................................251

15.9.1. 1.9.1 Le positionnement absolu........................................................................................................25215.9.2. 1.9.2 La positionnement relatif avec les LayoutManager.................................................................252

15.9.2.1. 1.9.2.1 FillLayout....................................................................................................................25215.9.2.2. 1.9.2.2 RowLayout..................................................................................................................25315.9.2.3. GridLayout..............................................................................................................................25415.9.2.4. FormLayout............................................................................................................................257

15.10. La gestion des événements........................................................................................................................25715.10.1. L'interface KeyListener...................................................................................................................25815.10.2. L'interface MouseListener...............................................................................................................26015.10.3. L'interface MouseMoveListener.....................................................................................................26115.10.4. L'interface MouseTrackListener.....................................................................................................26215.10.5. L'interface ModifyListener.............................................................................................................26215.10.6. L'interface VerifyText()..................................................................................................................26315.10.7. L'interface FocusListener................................................................................................................26415.10.8. L'interface TraverseListener...........................................................................................................26515.10.9. L'interface PaintListener.................................................................................................................266

15.11. Les boîtes de dialogue...............................................................................................................................26715.11.1. Les boîtes de dialogues prédéfinies................................................................................................267

15.11.1.1. La classe MessageBox..........................................................................................................26715.11.1.2. La classe ColorDialog...........................................................................................................26815.11.1.3. La classe FontDialog.............................................................................................................26915.11.1.4. La classe FileDialog..............................................................................................................27015.11.1.5. La classe DirectoryDialog.....................................................................................................27115.11.1.6. La classe PrintDialog............................................................................................................271

15.11.2. Les boites de dialogues personnalisées...........................................................................................272

Développons en Java

Table des matières16. JFace............................................................................................................................................................................274

17. Les applets...................................................................................................................................................................27517.1. L'intégration d'applets dans une page HTML.............................................................................................27517.2. Les méthodes des applets............................................................................................................................276

17.2.1. La méthode init()...............................................................................................................................27617.2.2. La méthode start().............................................................................................................................27617.2.3. La méthode stop().............................................................................................................................27617.2.4. La méthode destroy()........................................................................................................................27617.2.5. La méthode update().........................................................................................................................27617.2.6. La méthode paint()............................................................................................................................27717.2.7. Les méthodes size() et getSize().......................................................................................................27717.2.8. Les méthodes getCodeBase() et getDocumentBase().......................................................................27817.2.9. La méthode showStatus()..................................................................................................................27817.2.10. La méthode getAppletInfo()............................................................................................................27817.2.11. La méthode getParameterInfo()......................................................................................................27917.2.12. La méthode getGraphics()...............................................................................................................27917.2.13. La méthode getAppletContext()......................................................................................................27917.2.14. La méthode setStub()......................................................................................................................279

17.3. Les interfaces utiles pour les applets...........................................................................................................27917.3.1. L'interface Runnable.........................................................................................................................27917.3.2. L'interface ActionListener.................................................................................................................28017.3.3. L'interface MouseListener pour répondre à un clic de souris...........................................................280

17.4. La transmission de paramètres à une applet................................................................................................28017.5. Applet et le multimédia...............................................................................................................................281

17.5.1. Insertion d'images.............................................................................................................................28117.5.2. Insertion de sons................................................................................................................................28217.5.3. Animation d'un logo..........................................................................................................................283

17.6. Applet et application (applet pouvant s'exécuter comme application)........................................................28417.7. Les droits des applets..................................................................................................................................285

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

18. Les collections..............................................................................................................................................................28818.1. Présentation du framework collection.........................................................................................................28818.2. Les interfaces des collections......................................................................................................................289

18.2.1. L'interface Collection........................................................................................................................29018.2.2. L'interface Iterator.............................................................................................................................291

18.3. Les listes......................................................................................................................................................29218.3.1. L'interface List..................................................................................................................................29218.3.2. Les listes chaînées : la classe LinkedList..........................................................................................29218.3.3. L'interface ListIterator.......................................................................................................................29318.3.4. Les tableaux redimensionnables : la classe ArrayList......................................................................294

18.4. Les ensembles.............................................................................................................................................29518.4.1. L'interface Set...................................................................................................................................29518.4.2. L'interface SortedSet.........................................................................................................................29518.4.3. La classe HashSet..............................................................................................................................29618.4.4. La classe TreeSet..............................................................................................................................296

18.5. Les collections gérées sous la forme clé/valeur..........................................................................................29718.5.1. L'interface Map.................................................................................................................................29718.5.2. L'interface SortedMap.......................................................................................................................29818.5.3. La classe Hashtable...........................................................................................................................29818.5.4. La classe TreeMap............................................................................................................................29918.5.5. La classe HashMap...........................................................................................................................299

18.6. Le tri des collections...................................................................................................................................29918.6.1. L'interface Comparable.....................................................................................................................30018.6.2. L'interface Comparator.....................................................................................................................300

18.7. Les algorithmes...........................................................................................................................................30018.8. Les exceptions du framework.....................................................................................................................301

Développons en Java

Table des matières19. Les flux.........................................................................................................................................................................303

19.1. Présentation des flux...................................................................................................................................30319.2. Les classes de gestion des flux....................................................................................................................30319.3. Les flux de caractères..................................................................................................................................305

19.3.1. La classe Reader................................................................................................................................30619.3.2. La classe Writer................................................................................................................................30719.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.......................................................................30719.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.............................................................................30819.3.4.1. Les flux de caractères tamponnés en lecture avec un fichier..................................................30819.3.4.2. Les flux de caractères tamponnés en écriture avec un fichier................................................30919.3.4.3. La classe PrintWriter...............................................................................................................310

19.4. Les flux d'octets...........................................................................................................................................31219.4.1. Les flux d'octets avec un fichier........................................................................................................312

19.4.1.1. Les flux d'octets en lecture sur un fichier...............................................................................31219.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.....................................................................................31419.5. La classe File...............................................................................................................................................31519.6. Les fichiers à accès direct............................................................................................................................317

20. La sérialisation............................................................................................................................................................31920.1. Les classes et les interfaces de la sérialisation............................................................................................319

20.1.1. L'interface Serializable......................................................................................................................31920.1.2. La classe ObjectOuputStream...........................................................................................................32020.1.3. La classe ObjectInputStream............................................................................................................321

20.2. Le mot clé transient.....................................................................................................................................32220.3. La sérialisation personnalisée......................................................................................................................323

20.3.1. L'interface Externalizable.................................................................................................................323

21. L'interaction avec le réseau.......................................................................................................................................32421.1. Introduction.................................................................................................................................................32421.2. Les adresses internet....................................................................................................................................325

21.2.1. La classe InetAddress........................................................................................................................32521.3. L'accès aux ressources avec une URL.........................................................................................................326

21.3.1. La classe URL...................................................................................................................................32621.3.2. La classe URLConnection................................................................................................................32721.3.3. La classe URLEncoder......................................................................................................................32821.3.4. La classe HttpURLConnection.........................................................................................................329

21.4. Utilisation du protocole TCP.......................................................................................................................32921.4.1. La classe SocketServer......................................................................................................................33021.4.2. La classe Socket................................................................................................................................331

21.5. Utilisation du protocole UDP......................................................................................................................33321.5.1. La classe DatagramSocket................................................................................................................33321.5.2. La classe DatagramPacket................................................................................................................33421.5.3. Un exemple de serveur et de client...................................................................................................334

21.6. Les exceptions liées au réseau.....................................................................................................................33621.7. Les interfaces de connexions au réseau.......................................................................................................336

22. L'accès aux bases de données : JDBC.......................................................................................................................33822.1. Les outils nécessaires pour utiliser JDBC...................................................................................................33822.2. Les types de pilotes JDBC..........................................................................................................................33822.3. Enregistrer une base de données dans ODBC sous Windows 9x ou XP....................................................33922.4. Présentation des classes de l'API JDBC......................................................................................................34122.5. La connexion à une base de données..........................................................................................................341

22.5.1. Le chargement du pilote....................................................................................................................34122.5.2. L'établissement de la connection.......................................................................................................342

22.6. Accéder à la base de données......................................................................................................................34322.6.1. L'execution de requêtes SQL............................................................................................................343

Développons en Java

Table des matières22. L'accès aux bases de données : JDBC

22.6.2. La classe ResultSet............................................................................................................................34422.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........................................................................................34722.7.1. La classe ResultSetMetaData............................................................................................................34722.7.2. La classe DatabaseMetaData............................................................................................................348

22.8. L'utilisation d'un objet PreparedStatement..................................................................................................34822.9. L'utilisation des transactions.......................................................................................................................35022.10. Les procédures stockées............................................................................................................................35022.11. Le traitement des erreurs JDBC................................................................................................................35122.12. JDBC 2.0...................................................................................................................................................352

22.12.1. Les fonctionnalités de l'objet ResultSet..........................................................................................35222.12.2. Les mises à jour de masse (Batch Updates)....................................................................................35522.12.3. Le package javax.sql.......................................................................................................................35522.12.4. La classe DataSource......................................................................................................................35622.12.5. Les pools de connexion...................................................................................................................35622.12.6. Les transactions distribuées............................................................................................................35622.12.7. L'API RowSet.................................................................................................................................357

22.13. JDBC 3.0...................................................................................................................................................35722.14. MySQL et Java..........................................................................................................................................357

22.14.1. Installation sous Windows..............................................................................................................35722.14.2. Opérations de base avec MySQL....................................................................................................35822.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.................................36022.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.................................................................................................36623.1. La classe Class............................................................................................................................................366

23.1.1. Obtenir un objet de la classe Class....................................................................................................36723.1.1.1. Connaître la classe d'un objet..................................................................................................36723.1.1.2. Obtenir un objet Class à partir d'un nom de classe.................................................................36723.1.1.3. Une troisième façon d'obtenir un objet Class.........................................................................368

23.1.2. Les méthodes de la classe Class........................................................................................................36823.2. Rechercher des informations sur une classe................................................................................................368

23.2.1. Rechercher la classe mère d'une classe.............................................................................................36923.2.2. Rechercher les modificateurs d'une classe........................................................................................36923.2.3. Rechercher les interfaces implémentées par une classe....................................................................37023.2.4. Rechercher les champs publics.........................................................................................................37023.2.5. Rechercher les paramètres d'une méthode ou d'un constructeur.......................................................37123.2.6. Rechercher les constructeurs de la classe.........................................................................................37223.2.7. Rechercher les méthodes publiques..................................................................................................37323.2.8. Rechercher toutes les méthodes........................................................................................................373

23.3. Définir dynamiquement des objets..............................................................................................................37423.3.1. Définir des objets grâce à la classe Class..........................................................................................37423.3.2. Exécuter dynamiquement une méthode............................................................................................374

24. L'appel de méthodes distantes : RMI .......................................................................................................................37524.1. Présentation et architecture de RMI............................................................................................................37524.2. Les différentes étapes pour créer un objet distant et l'appeler avec RMI....................................................37524.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........................................37624.3.2. L'écriture d'une classe qui implémente cette interface......................................................................37624.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.................................................................................37724.3.3.2. L'instanciation d'un objet de la classe distante........................................................................37724.3.3.3. L'enregistrement dans le registre de nom RMI en lui donnant un nom..................................37824.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ères24. L'appel de méthodes distantes : RMI

24.4.1. La mise en place d'un security manager............................................................................................37924.4.2. L'obtention d'une référence sur l'objet distant à partir de son nom...................................................37924.4.3. L'appel à la méthode à partir de la référence sur l'objet distant........................................................38024.4.4. L'appel d'une méthode distante dans une applet...............................................................................380

24.5. La génération des classes stub et skeleton..................................................................................................38124.6. La mise en oeuvre des objets RMI..............................................................................................................381

24.6.1. Le lancement du registre RMI..........................................................................................................38124.6.2. L'instanciation et l'enregistrement de l'objet distant.........................................................................38124.6.3. Le lancement de l'application cliente................................................................................................382

25. L'internationalisation.................................................................................................................................................38325.1. Les objets de type Locale............................................................................................................................383

25.1.1. Création d'un objet Locale................................................................................................................38325.1.2. Obtenir la liste des Locales disponibles............................................................................................38425.1.3. L'utilisation d'un objet Locale...........................................................................................................385

25.2. La classe ResourceBundle...........................................................................................................................38525.2.1. La création d'un objet ResourceBundle............................................................................................38525.2.2. Les sous classes de ResourceBundle................................................................................................386

25.2.2.1. L'utilisation de PropertyResourceBundle...............................................................................38625.2.2.2. L'utilisation de ListResourceBundle.......................................................................................386

25.2.3. Obtenir un texte d'un objet ResourceBundle.....................................................................................38725.3. Chemins guidés pour réaliser la localisation...............................................................................................387

25.3.1. L'utilisation d'un ResourceBundle avec un fichier propriétés...........................................................38725.3.2. Exemples de classes utilisant PropertiesResourceBundle................................................................38825.3.3. L'utilisation de la classe ListResourceBundle...................................................................................38925.3.4. Exemples de classes utilisant ListResourceBundle..........................................................................39025.3.5. La création de sa propre classe fille de ResourceBundle..................................................................39225.3.6. Exemple de classes utilisant une classe fille de ResourceBundle.....................................................393

26. Les composants java beans....................................................