Penser en Java - BigBozoid

Thinking in Java, 2nd edition, Revision 12
©2000 by Bruce Eckel
Penser
en
Java
Seconde édition
Bruce Eckel
President, MindView, Inc.
Traducteurs pour cette version française :
Cédric BABAULT, Phillipe BOITE, Yannis CHICHA,
Nate CULWELL-KANAREK, Jérome DANNOVILLE,
Florence DEFAIX, Armel FORTUN, Daniel LE BERRE,
Anthony PRAUD, Jérome QUELIN, RACZY,
Olivier THOMANN, Jean-Pierre VIDAL.
Table des matières
Préface........................................................................3
Préface à la 2ème édition....................................................................3
Java 2.............................................................................................3
Le CD ROM..........................................................................................4
Introduction................................................................4
Prérequis.............................................................................................4
Apprendre Java...................................................................................5
Buts.....................................................................................................5
Documentation en ligne......................................................................6
Les chapitres.......................................................................................6
Exercices.............................................................................................8
Le CD ROM Multimédia........................................................................9
Le Code Source....................................................................................9
Typographie et style de code..............................................................9
Les versions de Java..........................................................................10
Seminars and mentoring...................................................................10
Errors................................................................................................10
À propos de la conception de la couverture du livre..........................10
Remerciements.................................................................................11
Collaborateurs Internet....................................................................12
1) Introduction sur les Objets...................................13
Les bienfaits de l'abstraction.............................................................13
Un objet dispose d'une interface.......................................................14
L'implémentation cachée...................................................................15
Réutilisation de l'implémentation......................................................16
Héritage : réutilisation de l'interface.................................................16
Les relations est-un vs. est-comme-un ..............................................18
Polymorphisme : des objets interchangeables...................................19
Classes de base abstraites et interfaces..............................................21
Environnement et durée de vie des objets.........................................21
Collections et itérateurs...................................................................22
La hiérarchie de classes unique.........................................................23
Bibliothèques de collections et support pour l'utilisation aisée des
collections......................................................................................23
Transtypages descendants vs. patrons génériques.......................................23
Le dilemme du nettoyage : qui en est responsable ?............................24
Ramasse-miettes vs. efficacité et flexibilité.................................................24
Traitement des exceptions : gérer les erreurs...................................25
Multithreading...................................................................................25
Persistance........................................................................................26
Java et l'Internet...............................................................................26
Qu'est-ce que le Web ?....................................................................26
Le concept Client/Serveur.........................................................................26
Traduction de « Thinking in Java 2nd Edition - <http://penserenjava.free.fr><version_2.4> - Page 1/459

Le Web en tant que serveur géant.............................................................27
La programmation côté client............................................................27
Les plugins (modules d'extension)..............................................................28
Les langages de script..............................................................................28
Java.......................................................................................................28
ActiveX...................................................................................................29
La sécurité..............................................................................................29
Internet vs. intranet.................................................................................30
La programmation côté serveur.........................................................30
Une scène séparée : les applications..................................................30
Analyse et conception.......................................................................31
Phase 0 : Faire un plan....................................................................32
L'exposé de la mission..............................................................................32
Phase 1 : Que construit-on ?.............................................................32
Phase 2 : Comment allons-nous le construire ?....................................34
Les cinq étapes de la conception d'un objet.................................................35
Indications quant au développement des objets...........................................36
Phase 3 : Construire le coeur du système...........................................36
Phase 4 : Itérer sur les cas d'utilisation..............................................36
Phase 5 : Evolution.........................................................................37
Les plans sont payants.....................................................................37
Programmation Extrême...................................................................38
Commencer par écrire les tests.........................................................38
Programmation en binôme...............................................................38
Les raisons du succès de Java...........................................................39
Les systèmes sont plus faciles à exprimer et comprendre......................39
Puissance maximale grâce aux bibliothèques.......................................39
Traitement des erreurs....................................................................39
Mise en oeuvre de gros projets.........................................................39
Stratégies de transition.....................................................................40
Règles de base...............................................................................40
1. Cours.................................................................................................40
2. Projet à faible risque............................................................................40
3. S'inspirer de bonnes conceptions...........................................................40
4. Utiliser les bibliothèques de classes existantes.........................................40
5. Ne pas traduire du code existant en Java................................................41
Les obstacles au niveau du management............................................41
Coûts de mise en oeuvre..........................................................................41
Problèmes de performances......................................................................41
Erreurs classiques de conception...............................................................41
Java vs. C++ ?...................................................................................42
Résumé.............................................................................................42
2 : Tout est Objet.......................................................44
Les objets sont manipulés avec des références.................................44
Vous devez créer tous les objets.......................................................44
Où réside la mémoire ?....................................................................45
Cas particulier : les types primitifs.....................................................45
Nombres de grande précision....................................................................46
Tableaux en Java............................................................................46
Vous n'avez jamais besoin de détruire un objet................................46
Notion de portée.............................................................................46
Portée des objets............................................................................47
Créer de nouveaux types de données : class.....................................47
Champs et méthodes.......................................................................48
Valeurs par défaut des membres primitifs...................................................48
Méthodes, paramètres et valeurs de retour.......................................49
La liste de paramètres.....................................................................49
Construction d'un programme Java...................................................50
Visibilité des noms..........................................................................50
Utilisation d'autres composantes.......................................................50
Le mot-clef static............................................................................51
Votre premier programme Java.........................................................52
Compilation et exécution..................................................................52
Commentaires et documentation intégrée.........................................53
Commentaires de documentation......................................................53
Syntaxe.........................................................................................53
HTML intégré..................................................................................54
@see : faire référence aux autres classes...........................................54
Class documentation tags.................................................................54
@version................................................................................................54
@author.................................................................................................55
@since...................................................................................................55
Les onglets de documentation de variables.........................................55
Les onglets de documentation de méthodes........................................55
@param.................................................................................................55
@return..................................................................................................55
@throws.................................................................................................55
@deprecated...........................................................................................55
Exemple de documentation...............................................................55
Style de programmation....................................................................56
Sommaire..........................................................................................56
Exercices...........................................................................................56
3 : Contrôle du Flux de Programme...........................57
Utilisation des opérateurs Java.........................................................58
Priorité..........................................................................................58
L'affectation...................................................................................58
L'aliasing pendant l'appel des méthodes.....................................................59
Les opérateurs mathématiques.........................................................59
Les opérateurs unaires (à un opérande) moins et plus..................................60
Incrémentation et décrémentation automatique...................................60
Les opérateurs relationnels...............................................................61
Tester l'équivalence des objets..................................................................61
Les opérateurs logiques...................................................................62
« Court-circuit ».....................................................................................62
Les opérateurs bit à bit....................................................................63
Traduction de « Thinking in Java 2nd Edition - <http://penserenjava.free.fr><version_2.4> - Page 2/459

Les opérateurs de décalage..............................................................64
Opérateur ternaire if-else.................................................................65
L'opérateur virgule..........................................................................66
L'opérateur + pour les String............................................................66
Les pièges classiques dans l'utilisation des opérateurs..........................66
Les opérateurs de transtypage..........................................................67
Les littéraux............................................................................................67
La promotion...........................................................................................68
Java n'a pas de « sizeof ».................................................................68
Retour sur la priorité des opérateurs..................................................68
Résumé sur les opérateurs...............................................................68
Le Contrôle d'exécution.....................................................................73
true et false...................................................................................73
if-else............................................................................................73
return....................................................................................................74
Itération........................................................................................74
do-while........................................................................................74
for................................................................................................75
L'opérateur virgule...................................................................................75
break et continue............................................................................75
L'infâme « goto »....................................................................................76
switch...........................................................................................78
Détails de calcul :....................................................................................79
Résumé.............................................................................................80
Exercices...........................................................................................81
4: Initialisation & Nettoyage.....................................81
Garantie d'initialisation grâce au constructeur..................................82
Surcharge de méthodes.....................................................................83
Différencier les méthodes surchargées...............................................84
Surcharge avec types de base...........................................................84
Surcharge sur la valeur de retour......................................................86
Constructeurs par défaut..................................................................86
Le mot-clé this...............................................................................86
Appeler un constructeur depuis un autre constructeur..................................87
La signification de static............................................................................88
Nettoyage : finalisation et ramasse-miettes......................................88
A quoi sert finalize( ) ?.....................................................................89
Le nettoyage est impératif................................................................89
La «death condition».......................................................................91
Comment fonctionne un ramasse-miettes ?.........................................91
Initialisation de membre...................................................................93
Spécifier une initialisation.................................................................94
Initialisation par constructeur...........................................................95
Ordre d'initialisation.................................................................................95
Initialisation de données statiques..............................................................95
Initialisation statique explicite....................................................................97
Initialisation d'instance non statique...........................................................97
Initialisation des tableaux.................................................................98
Tableaux multidimensionels............................................................100
Résumé...........................................................................................101
Exercices.........................................................................................101
5 : Cacher l'Implémentation....................................103
package : l'unité de bibliothèque.....................................................103
Créer des noms de packages uniques...............................................104
Collisions..............................................................................................106
Une bibliothèque d'outils personnalisée............................................106
Utilisation des imports pour modifier le comportement........................107
Avertissement sur les packages.......................................................108
Les spécificateurs d'accès Java.......................................................108
« Friendly » .................................................................................108
public : accès d'interface................................................................108
Le package par défaut............................................................................109
private : ne pas toucher !...............................................................109
protected : « sorte d'amical » ........................................................110
Interface et implémentation............................................................111
L'accès aux classes..........................................................................111
Résumé...........................................................................................113
Exercices.........................................................................................113
6 : Réutiliser les classes..........................................114
Syntaxe de composition..................................................................115
La syntaxe de l'héritage..................................................................116
Initialiser la classe de base.............................................................117
Constructeurs avec paramètres................................................................118
Attraper les exceptions du constructeur de base........................................118
Combiner composition et héritage...................................................119
Garantir un nettoyage propre..........................................................119
L'ordre du ramasse-miettes.....................................................................121
Cacher les noms............................................................................121
Choisir la composition à la place de l'héritage.................................121
protected.........................................................................................122
Développement incrémental............................................................122
Transtypage ascendant...................................................................123
Pourquoi le transtypage ascendant ? ...............................................123
Composition à la place de l'héritage revisité..............................................123
Le mot clé final................................................................................124
Données finales.............................................................................124
Finals sans initialisation...........................................................................125
Arguments final.....................................................................................125
Méthodes final..............................................................................126
final et private.......................................................................................126
Classes final.................................................................................127
Attention finale.............................................................................127
Initialisation et chargement de classes...........................................128
Initialisation avec héritage..............................................................128
Traduction de « Thinking in Java 2nd Edition - <http://penserenjava.free.fr><version_2.4> - Page 3/459

Résumé...........................................................................................129
Exercices.........................................................................................129
7: Polymorphisme....................................................130
Upcasting........................................................................................130
Pourquoi utiliser l'upcast?...............................................................131
The twist.........................................................................................132
Liaison de l'appel de méthode.........................................................132
Produire le bon comportement........................................................132
Extensibilité..................................................................................134
Redéfinition et Surcharge................................................................135
Classes et méthodes abstraites.......................................................136
Constructeurs et polymorphisme.....................................................138
Ordre d'appel des constructeurs......................................................138
La méthode finalize() et l'héritage...................................................139
Comportement des méthodes polymorphes dans les
constructeursname="Index722">....................................................141
Concevoir avec l'héritage................................................................142
Héritage pur contre extensionname="Index739">..............................142
Downcasting et identification du type à l'exécution.............................143
Résumé...........................................................................................144
Exercices.........................................................................................145
8 : Interfaces & Classes Internes............................146
Interfaces.......................................................................................146
« Héritage multiple » en Java..........................................................147
Combinaison d'interfaces et collisions de noms .........................................149
Etendre une interface avec l'héritage................................................149
Groupes de constantes...................................................................150
Initialisation des données membres des interfaces.............................150
Interfaces imbriquées....................................................................151
Classes internes..............................................................................152
Classes internes et transtypage ascendant........................................153
Classes internes définies dans des méthodes et autres portées............154
Classes internes anonymes.............................................................155
Lien vers la classe externe..............................................................157
Classes internes static....................................................................158
Se référer à l'objet de la classe externe............................................159
Classe interne à plusieurs niveaux d'imbrication.................................159
Dériver une classe interne..............................................................159
Les classes internes peuvent-elles redéfinies ?...................................160
Identifiants des classes internes......................................................161
Raison d'être des classes internes....................................................161
Fermetures & callbacks...........................................................................162
Classes internes & structures de contrôle..........................................163
Résumé...........................................................................................167
Exercices.........................................................................................167
9 : Stockage des objets...........................................168
Les tableaux....................................................................................169
Les tableaux sont des objets...........................................................169
Conteneurs de scalaires..........................................................................171
Renvoyer un tableau......................................................................171
La classe Arrays............................................................................172
Remplir un tableau........................................................................177
Copier un tableau..........................................................................177
Comparer des tableaux..................................................................178
Comparaison d'éléments de tableau.................................................178
Trier un tableau............................................................................179
Effectuer une recherche sur un tableau trié.......................................180
Résumé sur les tableaux.................................................................181
Introduction sur les conteneurs.....................................................181
Imprimer les conteneurs................................................................182
Remplir les conteneurs...................................................................183
L'inconvénient des conteneurs : le type est inconnu........................186
Quelquefois ça marche quand même................................................187
Créer une ArrayList consciente du type.............................................187
Types paramétrés..................................................................................188
Itérateurs........................................................................................188
Récursion indésirable..............................................................................189
Classification des conteneurs..........................................................190
Fonctionnalités des Collections........................................................192
Fonctionnalités des Lists.................................................................193
Réaliser une pile à partir d'une LinkedList.........................................195
Réaliser une file à partir d'une LinkedList..........................................195
Fonctionnalités des Sets..................................................................196
Sets triés : les SortedSets..............................................................197
Fonctionnalités des Maps................................................................197
Maps triées : les SortedMaps..........................................................199
Hachage et codes de hachage.........................................................200
Comprendre hashCode().........................................................................201
Facteurs de performance d'un HashMap....................................................203
Redéfinir hashCode().....................................................................204
Stocker des références....................................................................205
Le WeakHashMap..........................................................................206
Les itérateurs revisités....................................................................207
Choisir une implémentation.............................................................207
Choisir entre les Lists.....................................................................208
Choisir entre les Sets.....................................................................209
Choisir entre les Maps....................................................................210
Trier et rechercher dans les Lists....................................................211
Utilitaires........................................................................................212
Rendre une Collection ou une Map non-modifiable..............................212
Synchroniser une Collection ou une Map...........................................213
Echec rapide..........................................................................................213
Opérations non supportées..............................................................214
Traduction de « Thinking in Java 2nd Edition - <http://penserenjava.free.fr><version_2.4> - Page 4/459

Les conteneurs Java 1.0 / 1.1.........................................................215
Vector & Enumeration....................................................................215
Hashtable.....................................................................................215
Stack...........................................................................................216
BitSet..........................................................................................216
Résumé...........................................................................................217
Exercices.........................................................................................217
Gestion des erreurs avec les exceptions .................220
Les exceptions de base ...................................................................220
Les paramètres des Exceptions .......................................................221
Attraper une exception ...................................................................221
Le bloc try ...................................................................................221
Les gestionnaires d'exceptions .......................................................221
Terminaison contre Restauration .............................................................222
Créez vos propres Exceptions .........................................................222
Spécifier des Exceptions .................................................................224
Attraper n'importe quelle exception .................................................225
Relancer une exception .................................................................225
Les exceptions Java standard .........................................................227
Le cas particulier RuntimeException ................................................228
Faire le ménage avec finally ...........................................................228
À Quoi sert le finally ? ...................................................................229
Le défaut : l'exception perdue ........................................................230
Restriction d'Exceptions .................................................................231
Les constructeurs ...........................................................................232
Indication d'Exception ....................................................................234
Recommandations pour les exceptions ............................................235
Résumé ..........................................................................................235
Exercices ........................................................................................235
11: Le système d'E/S de Java..................................237
La classe File...................................................................................237
Lister un répertoire........................................................................237
Les classes internes anonymes................................................................238
Vérification et création de répertoires...............................................239
Entrée et sortie...............................................................................240
Les types d'InputStream................................................................240
Les types d'OutputStream..............................................................241
Ajouter des attributs et des interfaces utiles...................................242
Lire depuis un InputStream avec FilterInputStream............................242
Écrire vers un OutputStream avec FilterOutputStream........................243
Lecteurs & écrivains [ Loaders & Writers ]......................................244
Les sources et les réceptacles de données.........................................244
Modifier le comportement du flux.....................................................244
Les classes inchangées...................................................................245
Et bien sûr : L'accès aléatoire aux fichiers (RandomAccessFile)......245
L'usage typique des flux d'E/S........................................................246
Flux d'Entrée................................................................................247
1. Entrée en tampon du fichier [Buffered input file]....................................247
2. Entrée depuis la mémoire....................................................................247
3. Entrée de mémoire formatée...............................................................247
4. Sortie de Fichier.................................................................................247
Flux de sortie................................................................................248
5. Stocker et récupérer des données........................................................248
6. Accés aléatoire en lecture et écriture aux fichiers...................................248
Un bogue ?...................................................................................248
Flux Piped....................................................................................249
Standard E/S...................................................................................249
Lire depuis une entrée standard......................................................249
Modifier System.out en un PrintWriter..............................................249
Réorienter l'E/S standard................................................................250
Compression....................................................................................250
Compression simple avec GZIP........................................................251
Stockage de fichiers multiples avec Zip.............................................251
ARchives Java (JARs).....................................................................252
La sérialisation objet.......................................................................253
Trouver la classe...........................................................................255
Contrôler la sérialisation.................................................................256
Le mot-clé « transient ».........................................................................258
Une alternative à Externalizable...............................................................259
Versioning.............................................................................................260
Utiliser la persistence.....................................................................260
Tokenizer l'entrée...........................................................................264
StreamTokenizer...........................................................................264
StringTokenizer.............................................................................265
Vérifier le style de capitalization......................................................266
Résumé...........................................................................................270
Exercices.........................................................................................271
12: Identification dynamique de type......................272
Le besoin de RTTI............................................................................272
L'objet Class.................................................................................273
Les littéraux Class..................................................................................274
Vérifier avant de transtyper............................................................274
Utiliser les littéraux de classe...................................................................276
Un instanceof dynamique........................................................................277
instanceof vs. équivalence de classe.........................................................277
La syntaxe du RTTI..........................................................................278
Réflexion : information de classe dynamique .................................279
Un extracteur de méthodes de classe...............................................280
Résumé...........................................................................................282
Exercices.........................................................................................283
13: Création de Fenêtres et Applets........................284
L'applet de base..............................................................................285
Les restrictions des applets.............................................................285
Traduction de « Thinking in Java 2nd Edition - <http://penserenjava.free.fr><version_2.4> - Page 5/459