Programmer en Java 3e édition

Table des matières......Page 7
Avant-propos......Page 26
1. Petit historique du langage......Page 30
2.1 Les concepts d’objet et d’encapsulation......Page 31
2.4 Java est presque un pur langage de P.O.O.......Page 32
3.1.1 Les programmes à interface console......Page 33
3.2.1 Cas d’une interface console......Page 34
3.3.3 On peut disposer d’une interface console en Java......Page 35
4. Java et la portabilité......Page 36
1. Premier exemple de programme Java......Page 38
1.1 Structure générale du programme......Page 39
1.2 Contenu du programme......Page 40
2. Exécution d’un programme Java......Page 41
3. Quelques instructions de base......Page 43
4. Lecture d’informations au clavier......Page 45
4.2 Utilisation de cette classe......Page 46
5. Boucles et choix......Page 47
6.1 Les identificateurs......Page 50
6.3 Les séparateurs......Page 51
6.4 Le format libre......Page 52
6.5.2 Les commentaires de fin de ligne......Page 53
6.6 Emploi du code Unicode dans le programme source......Page 54
1. La notion de type......Page 56
2.1.2 Cas d’un nombre négatif......Page 57
2.2 Les différents types d’entiers......Page 58
3.1 Les différents types et leur représentation en mémoire......Page 59
3.2 Notation des constantes flottantes......Page 61
4.2 Ecriture des constantes de type caractère......Page 62
6.1 Initialisation d’une variable......Page 65
6.3.1 Le mot clé final......Page 66
6.3.3 L’initialisation d’une variable final peut être différée......Page 67
1. Originalité des notions d’opérateur et d’expression......Page 70
2.1 Présentation des opérateurs......Page 72
2.2 Les priorités relatives des opérateurs......Page 73
2.3.2 Cas des flottants......Page 74
3.1 Notion d'expression mixte......Page 75
3.3 Les promotions numériques......Page 76
3.4 Conséquences des règles de conversion......Page 77
3.5 Le cas du type char......Page 78
4.1 Présentation générale......Page 79
4.4 Cas particulier des opérateurs == et !=......Page 81
5.1 Généralités......Page 82
5.3 Priorités......Page 83
6.1 Restrictions......Page 84
6.3.1 Généralités......Page 85
6.3.2 Quelques conséquences......Page 86
6.3.3 Cas particulier des expressions constantes......Page 87
7.1 Leur rôle......Page 88
7.3.1 Alléger l’écriture......Page 89
8.1 Présentation générale......Page 90
8.2 Conversions forcées......Page 91
9.1 Présentation générale......Page 92
9.2 Conversions autorisées par cast......Page 93
9.3 Règles exactes des conversions numériques......Page 94
10.1Présentation générale......Page 95
10.2Les opérateurs bit à bit......Page 96
10.3Les opérateurs de décalage......Page 97
10.4Exemples d'utilisation des opérateurs de bits......Page 98
11. L’opérateur conditionnel......Page 99
12. Récapitulatif des priorités des opérateurs......Page 100
5 - Les instructions de contrôle de Java......Page 102
1.1 Blocs d'instructions......Page 103
1.3 Exemples......Page 104
1.4 Imbrication des instructions if......Page 105
2.1.1 Premier exemple......Page 106
2.1.2 L'étiquette default......Page 108
2.1.3 Un exemple plus général......Page 109
2.2 Syntaxe de l'instruction switch......Page 110
3.1 Exemple d'introduction......Page 111
3.2 Syntaxe de l'instruction do... while......Page 112
4.2 Syntaxe de l’instruction while......Page 114
5.1 Exemple d'introduction......Page 115
5.2 L’instruction for en général......Page 116
5.3 Syntaxe de l’instruction for......Page 117
6.1 L’instruction break ordinaire......Page 120
6.2 L’instruction break avec étiquette......Page 121
6.3 L’instruction continue ordinaire......Page 122
6.4 L’instruction continue avec étiquette......Page 124
6 - Les classes et les objets......Page 126
1.1 Définition d’une classe Point......Page 127
1.1.2 Définition des méthodes......Page 128
1.2.1 La démarche......Page 130
1.2.2 Exemple......Page 131
1.3.1 Un fichier source par classe......Page 132
1.3.2 Plusieurs classes dans un même fichier source......Page 133
2.2 Exemple de classe comportant un constructeur......Page 135
2.3 Quelques règles concernant les constructeurs......Page 137
2.4.1 Initialisation par défaut des champs d’un objet......Page 138
2.4.3 Appel du constructeur......Page 139
2.4.4 Cas des champs déclarés avec l’attribut final......Page 140
3.1 Les notions de contrat et d’implémentation......Page 142
3.2 Typologie des méthodes d’une classe......Page 143
4.1 Premier exemple......Page 144
4.2 Second exemple......Page 145
4.3 Initialisation de référence et référence nulle......Page 146
4.4 La notion de clone......Page 147
5. Le ramasse-miettes......Page 148
6.1 Méthodes fonction......Page 150
6.2.2 Conversion des arguments effectifs......Page 151
6.3 Propriétés des variables locales......Page 152
7.1.1 Présentation......Page 154
7.1.2 Exemple......Page 155
7.2.2 Exemple......Page 157
7.2.3 Autres utilisations des méthodes de classe......Page 158
7.3.2 Bloc d’initialisation statique......Page 159
8.1 Exemple introductif......Page 160
8.2 En cas d’ambiguïté......Page 161
8.3 Règles générales......Page 162
8.4 Surdéfinition de constructeurs......Page 163
8.5 Surdéfinition et droits d’accès......Page 164
9. Echange d’informations avec les méthodes......Page 165
9.2 Conséquences pour les types primitifs......Page 166
9.3.1 L’unité d’encapsulation est la classe......Page 167
9.3.2 Conséquences de la transmission de la référence d’un objet......Page 169
9.4 Cas de la valeur de retour......Page 171
9.5.2 Exemples d’utilisation de this......Page 173
9.5.3 Appel d’un constructeur au sein d’un autre constructeur......Page 174
10. La récursivité des méthodes......Page 175
11. Les objets membres......Page 177
12.1Imbrication de définitions de classe......Page 180
12.2Lien entre objet interne et objet externe......Page 181
12.3Exemple complet......Page 183
13.1Attribution d’une classe à un paquetage......Page 186
13.2Utilisation d’une classe d’un paquetage......Page 187
13.4.1 Droits d’accès aux classes......Page 188
13.4.2 Droits d’accès aux membres d’une classe......Page 189
1.1 Introduction......Page 192
1.2 Déclaration de tableaux......Page 193
1.3.2 Utilisation d’un initialiseur......Page 194
2.1 Accès individuel aux éléments d’un tableau......Page 195
2.2 Affectation de tableaux......Page 196
2.4 Exemple de tableau d’objets......Page 198
3. Tableau en argument ou en retour......Page 199
4. Les tableaux à plusieurs indices......Page 200
4.1 Présentation générale......Page 201
4.2 Initialisation......Page 202
4.3 Exemple......Page 203
4.4 Cas particulier des tableaux réguliers......Page 204
8 - L’héritage......Page 206
1. La notion d’héritage......Page 207
2.1 Une classe dérivée n’accède pas aux membres privés......Page 209
2.2 Elle accède aux membres publics......Page 210
2.3 Exemple de programme complet......Page 211
3.1.1 Exemple introductif......Page 213
3.1.2 Cas général......Page 216
3.2 Initialisation d’un objet dérivé......Page 218
4. Dérivations successives......Page 219
5.2 La notion de redéfinition de méthode......Page 220
5.3 Redéfinition de méthode et dérivations successives......Page 222
5.4 Surdéfinition et héritage......Page 223
5.5 Utilisation simultanée de surdéfinition et de redéfinition......Page 224
5.6.1 Valeur de retour......Page 225
5.7 Règles générales de redéfinition et de surdéfinition......Page 226
5.8 Duplication de champs......Page 227
6. Le polymorphisme......Page 228
6.1 Les bases du polymorphisme......Page 229
6.2 Généralisation à plusieurs classes......Page 232
6.3 Autre situation où l’on exploite le polymorphisme......Page 233
6.4 Polymorphisme, redéfinition et surdéfinition......Page 236
6.5.1 Cas d’une méthode non surdéfinie......Page 237
6.5.2 Cas d’une méthode surdéfinie......Page 238
6.7 Les conversions explicites de références......Page 239
6.8 Le mot clé super......Page 240
6.9 Limites de l’héritage et du polymorphisme......Page 241
7.1 Utilisation d’une référence de type Object......Page 242
7.2.1 La méthode toString......Page 243
7.2.2 La méthode equals......Page 244
8. Les membres protégés......Page 245
10. Classes et méthodes finales......Page 246
11.1Présentation......Page 247
11.2 Quelques règles......Page 248
11.3 Intérêt des classes abstraites......Page 249
11.4 Exemple......Page 250
12.1.1 Définition d’une interface......Page 251
12.2 Variables de type interface et polymorphisme......Page 252
12.4 Interfaces et constantes......Page 254
12.6 Conflits de noms......Page 255
12.7 L’interface Cloneable......Page 256
13. Les classes enveloppes......Page 257
14.2 Relations entre classes......Page 258
14.3 Différences entre interface et héritage......Page 259
15.1 Exemple de classe anonyme......Page 260
15.2.2 Utilisation de la référence à une classe anonyme......Page 261
9 - Les chaînes de caractères......Page 264
1.2 Un objet de type String n’est pas modifiable......Page 265
1.3 Entrées-sorties de chaînes......Page 266
1.5 Accès aux caractères d’une chaîne : charAt......Page 267
1.6 Concaténation de chaînes......Page 268
1.7 Conversions des opérandes de l’opérateur +......Page 269
1.9 Ecriture des constantes chaînes......Page 270
2. Recherche dans une chaîne......Page 271
3.2 La méthode equals......Page 273
3.3 La méthode compareTo......Page 274
4. Modification de chaînes......Page 275
5. Tableaux de chaînes......Page 276
6.1 Conversion d’un type primitif en une chaîne......Page 277
6.2 Les conversions d’une chaîne en un type primitif......Page 279
7. Conversions entre chaînes et tableaux de caractères......Page 281
8. Les arguments de la ligne de commande......Page 282
9. La classe StringBuffer......Page 283
10 - La gestion des exceptions......Page 286
1.1 Comment déclencher une exception avec throw......Page 287
1.3 Le programme complet......Page 288
1.4 Premières propriétés de la gestion d’exception......Page 289
2. Gestion de plusieurs exceptions......Page 291
3.1 Par l’objet fourni à l’instruction throw......Page 293
3.2 Par le constructeur de la classe exception......Page 294
4. Le mécanisme de gestion des exceptions......Page 295
4.1 Poursuite de l’exécution......Page 296
4.2 Choix du gestionnaire d’exception......Page 297
4.4 La clause throws......Page 299
4.5 Redéclenchement d’une exception......Page 300
4.6 Le bloc finally......Page 302
5. Les exceptions standard......Page 304
11 - Les threads......Page 306
1. Exemple introductif......Page 307
2. Utilisation de l’interface Runnable......Page 309
3.1 Démarche usuelle d’interruption par un autre thread......Page 312
3.2 Threads démons et arrêt brutal......Page 314
4.1 Méthodes synchronisées......Page 316
4.2 Exemple......Page 317
4.3 Notion de verrou......Page 319
4.5 Interblocage......Page 320
4.6 Attente et notification......Page 321
5. Etats d’un thread......Page 325
6. Priorités des threads......Page 326
12 - Les bases de la programmation graphique......Page 328
1.1 La classe JFrame......Page 329
1.3 Création d’une classe fenêtre personnalisée......Page 331
1.4 Action sur les caractéristiques d’une fenêtre......Page 332
2.1 Implémentation de l’interface MouseListener......Page 334
2.2 Utilisation de l’information associée à un événement......Page 337
2.3 La notion d’adaptateur......Page 338
2.4 La gestion des événements en général......Page 340
3.2 Affichage du bouton : la notion de gestionnaire de mise en forme......Page 341
3.3 Gestion du bouton avec un écouteur......Page 344
4. Gestion de plusieurs composants......Page 345
4.1.1 Tous les boutons déclenchent la même réponse......Page 346
4.1.2 La méthode getSource......Page 347
4.1.3 La méthode getActionCommand......Page 349
4.2.1 Une classe écouteur pour chaque bouton......Page 351
4.2.2 Une seule classe écouteur pour les deux boutons......Page 352
4.3 Dynamique des composants......Page 354
5. Premier dessin......Page 357
5.1 Création d’un panneau......Page 358
5.2 Dessin dans le panneau......Page 359
5.3 Forcer le dessin......Page 361
5.4 Ne pas redéfinir inutilement paintComponent......Page 363
6. Dessiner à la volée......Page 364
7.2 Connaître les dimensions d’un composant......Page 367
7.3 Imposer une taille à un composant......Page 368
13 - Les contrôles usuels......Page 372
1.2.1 Réaction à l’action sur une case à cocher......Page 373
1.3 Exemple......Page 374
2.1 Généralités......Page 376
2.2.1 Réaction à l’action sur un bouton radio......Page 377
2.3 Exemples......Page 378
3.2 Exemple......Page 382
4.2 Exploitation usuelle d’un champ de texte......Page 384
4.3 Exploitation fine d’un champ de texte......Page 389
5.1 Généralités......Page 390
5.2.1 Accès aux informations sélectionnées......Page 392
5.2.2 Événements générés par les boîtes de liste......Page 393
5.3 Exemple......Page 394
6.1.1 La boîte combo pour l’utilisateur du programme......Page 396
6.2 Exploitation d’une boîte combo......Page 397
6.2.2 Les événements générés par une boîte combo......Page 398
6.2.3 Exemple......Page 399
6.3.2 Exemple......Page 400
7. Exemple d’application......Page 402
1. Les boîtes de message......Page 406
1.1 La boîte de message usuelle......Page 407
1.2 Autres possibilités......Page 408
2.1 La boîte de confirmation usuelle......Page 409
2.2 Autres possibilités......Page 411
3.1 La boîte de saisie usuelle......Page 412
3.2 Autres possibilités......Page 413
4. Les boîtes d’options......Page 414
5.1.1 Construction......Page 416
5.1.3 Exemple......Page 417
5.1.4 Utilisation d’une classe dérivée de JDialog......Page 418
5.2.1 Introduction des composants......Page 419
5.2.2 Gestion du dialogue......Page 420
5.2.5 Exemple complet......Page 421
5.3 Canevas général d’utilisation d’une boîte de dialogue modale......Page 424
6. Exemple d’application......Page 425
15 - Les menus, les actions et les barres d’outils......Page 430
1.1 Création......Page 431
1.3 Exemple......Page 432
2. Les différentes sortes d’options......Page 434
3. Les menus surgissants......Page 437
4.1 Les caractères mnémoniques......Page 440
4.2 Les accélérateurs......Page 441
4.3 Exemple......Page 442
5. Les bulles d’aide......Page 443
6.1 Exemple avec des menus déroulants usuels......Page 444
6.2 Exemple avec un menu surgissant......Page 445
7.1 Activation et désactivation d’options......Page 446
8. Les actions......Page 447
8.1.3 Gestion des événements associés à une action......Page 448
8.1.4 Exemple complet......Page 449
8.2 Association d’une même action à plusieurs composants......Page 450
8.3 Cas des boutons......Page 452
8.4.1 Informations associées à la classe AbstractAction......Page 454
9. Les barres d’outils......Page 455
9.1 Généralités......Page 456
9.2 Barrres d’outils flottantes ou intégrées......Page 457
9.4 Association d’actions à une barre d’outils......Page 458
10. Exemple d’application......Page 459
16 - Les événements de bas niveau......Page 464
1.1 Gestion de l’appui et du relâchement des boutons......Page 465
1.2 Identification du bouton et clics multiples......Page 467
1.3 Gestion des déplacements de la souris......Page 469
1.4 Exemple de sélection de zone......Page 471
2.1 Les événements générés......Page 473
2.2 Identification des touches......Page 474
2.3 Exemple......Page 476
2.4 Etat des touches modificatrices......Page 477
2.6.1 Capture par la fenêtre......Page 478
2.6.2 Capture par des actions......Page 479
2.7 Exemple combinant clavier et souris......Page 481
3.1 Généralités......Page 483
4.1 Généralités......Page 484
4.2 Forcer le focus......Page 485
4.3 Exemple......Page 486
17 - Les gestionnaires de mise en forme......Page 488
1. Le gestionnaire BorderLayout......Page 489
2. Le gestionnaire FlowLayout......Page 491
3. Le gestionnaire CardLayout......Page 493
4. Le gestionnaire GridLayout......Page 496
5.1 Généralités......Page 497
5.2 Exemple de box horizontal......Page 498
5.3 Exemple de box vertical......Page 499
5.4 Modifier l’espacement avec strut et glue......Page 501
6.1 Présentation générale......Page 503
6.2 Exemple......Page 504
18 - Textes et graphiques......Page 508
1.1 Deux textes consécutifs sur une même ligne......Page 509
1.2 Affichage de deux lignes consécutives......Page 511
1.3 Les différentes informations relatives à une fonte......Page 512
2. Choix de fontes......Page 513
2.1 Les fontes logiques......Page 514
2.2 Les fontes physiques......Page 516
3.2 Construction d’un objet couleur......Page 519
4.1 Généralités......Page 520
4.2 Lignes droites, rectangles et ellipses......Page 521
4.3 Rectangles à coins arrondis......Page 522
4.4 Polygones et lignes brisées......Page 523
4.5 Tracés d’arcs......Page 525
5. Remplissage de formes......Page 526
6. Mode de dessin......Page 528
7.2 Charger une image et l’afficher......Page 531
7.2.1 Chargement d’une image avec attente......Page 532
7.2.2 Chargement d’une image sans attente......Page 534
1. Première applet......Page 536
2.1 Généralités......Page 538
2.2 Fichier HTML de lancement d’une applet......Page 539
3.1 Généralités......Page 540
3.2 Exemple......Page 541
4. Différents stades de la vie d’une applet......Page 542
5. Transmission d’informations à une applet......Page 544
7. Transformation d’une application graphique en une applet......Page 546
20 - Les flux et les fichiers......Page 552
1.1 Généralités......Page 553
1.2 Exemple de programme......Page 554
2.2 Exemple de programme......Page 556
3.2 Exemple d’accès direct à un fichier existant......Page 559
3.3 Les possibilités de l’accès direct......Page 560
3.4.2 Positionnement hors fichier......Page 561
4.1 Introduction......Page 563
4.2.1 Généralités......Page 564
4.2.2 Exemple......Page 565
4.3 Exemple de lecture d’un fichier texte......Page 566
4.3.1 Accès aux lignes d’un fichier texte......Page 567
4.3.2 La classe StringTokenizer......Page 568
5.1 Création d’un objet de type File......Page 571
5.2.2 Création et suppression......Page 573
5.2.5 Accès aux membres d’un répertoire......Page 574
6.1 Généralités......Page 575
6.2 Les flux binaires de sortie......Page 576
6.3 Les flux binaires d’entrée......Page 578
6.5 Les flux texte de sortie......Page 579
6.6 Les flux texte d’entrée......Page 581
21 - Les collections et les algorithmes......Page 582
1.2 Ordre des éléments d’une collection......Page 583
1.2.1 Utilisation de la méthode compareTo......Page 584
1.3 Egalité d’éléments d’une collection......Page 585
1.4 Les itérateurs et leurs méthodes......Page 586
1.4.1 Les itérateurs monodirectionnels : l’interface Iterator......Page 587
1.4.2 Les itérateurs bidirectionnels : l’interface ListIterator......Page 589
1.4.3 Les limitations des itérateurs......Page 591
1.6 Opérations communes à toutes les collections......Page 592
1.6.2 Modifications indépendantes d’un itérateur......Page 593
1.6.4 Autres méthodes......Page 594
2.1 Généralités......Page 595
2.2 Opérations usuelles......Page 596
2.3 Exemples......Page 597
2.4 Autres possibilités peu courantes......Page 600
3.2 Opérations usuelles......Page 601
3.3 Exemples......Page 603
3.5 Autres possibilités peu usuelles......Page 605
4.1 Généralités......Page 606
4.2 Opérations usuelles......Page 607
4.3 Exemple......Page 609
4.4 Opérations ensemblistes......Page 610
4.5.1 Notion de table de hachage......Page 612
4.5.2 La méthode hashCode......Page 613
4.5.3 Exemple......Page 614
4.6.1 Généralités......Page 615
4.6.2 Exemple......Page 616
5.1 Recherche de maximum ou de minimum......Page 617
5.2 Tris et mélanges......Page 619
6.1 Généralités......Page 620
6.3 Présentation générale des classes HashMap et TreeMap......Page 621
6.5 Autres vues associées à une table......Page 622
6.6 Exemple......Page 623
7. Vues synchronisées ou non modifiables......Page 625
22 - Programmation Java côté serveur : servlets et JSP......Page 628
1.1.1 La classe HttpServlet et la méthode doGet......Page 629
1.1.2 Construction de la réponse au client......Page 630
1.3 Installation de la servlet sur le serveur......Page 631
1.4 Test du fonctionnement d’une servlet......Page 632
2. Transmission de paramètres à une servlet......Page 633
2.1.2 Ecriture de la servlet......Page 634
2.2 Utilisation d’un formulaire HTML......Page 636
2.3 Utilisation de la méthode POST......Page 638
3. Cycle de vie d’une servlet : les méthodes init et destroy......Page 640
4. Exemple de servlet de calcul de factorielles......Page 642
5.2 Notion de scriptlet......Page 644
5.3 Exécution d’un JSP......Page 645
6. Transmission de paramètres à un JSP : l’objet request......Page 646
7.2.1 Introduction......Page 648
7.2.2 Exemples......Page 649
7.3 Commentaires......Page 650
7.4.2 Exemple de déclaration de variables d’instances (champs)......Page 651
7.5 Exemple de JSP de calcul de factorielles......Page 653
8.1.1 Utilisation d’un objet usuel dans un JSP......Page 655
8.1.2 Utilisation d’un objet de type JavaBean......Page 656
8.2 Utilisation directe de paramètres dans des JavaBeans......Page 658
8.3 Exemple d’utilisation d’une classe Point transformée en JavaBean......Page 659
8.4.1 Notion de suivi de session......Page 660
8.4.3 Les différentes portées d’un JavaBean......Page 661
9.1 Inclusion statique d’une page JSP dans une autre......Page 662
9.3 Inclusion dynamique de JSP......Page 663
Annexes......Page 664
1. Modificateurs d’accès des classes et interfaces......Page 666
2. Modificateurs d’accès pour les membres et les classes internes......Page 667
B - La classe Clavier......Page 668
C - Les constantes et fonctions mathématiques......Page 672
1.1 Exceptions explicites......Page 674
2. Paquetage java.io......Page 675
4.2 Exceptions implicites......Page 676
E - Les composants graphiques et leurs méthodes......Page 678
1. Les classes de composants......Page 679
2. Les méthodes......Page 680
F - Les événements et les écouteurs......Page 688
1. Les événements de bas niveau......Page 689
2. Les événements sémantiques......Page 690
3. Les méthodes des événements......Page 691
G - Les collections......Page 694
1. Les interfaces......Page 695
2. Les classes implémentant List......Page 697
4. Les classes implémentant Map......Page 699
5. Les algorithmes de la classe Collections......Page 700
Index......Page 702