java efficace guide de programmation resume table des

JAVA EFFICACE
GUIDE DE PROGRAMMATION
JOSBUA BLOCH
RESUME
Ce guide, écrit par un expert de Sun Microsystems, présente cinquante-sept
règles de programmation
concourant à l'écriture de programmes efficaces pour la plateforme java. Fruit de
l'expérience des créateurs de java et des défis de programmation relevés au
quotidien, chaque règle illustre divers aspects du langage et de ses difficultés au
moyen de conseils, recommandations - ce qu'il faut faire; ce qu'il ne faut
pas faire - et d'exemples détaillés: son bon usage idiomatique, ses subtilités et
ses pièges,ses patterns et antipatterns. exception. »
Excédant la seule programmation java, ces règles serviront de viatique pour la
Programmation objet en
général et la production de code clair, correct, efficace, robuste et réutilisable.
Les bibliothèques java (java. lang, java. Util et dans une moindre mesure java. io)
sont également abordées,
ainsi que la sérialisation.
«J'aurais voulu avoir ce livre il y a dix ans. Certains peuvent penser que je n'ai besoin d'aucun livre sur Java, mais celui-ci fait. »
TABLE DES MATIERES
Remerciements XI
Avant-propos XIII
Préface XV
Chapitre 1 Présentation 1
Chapitre 2 Création et destruction d'objets 5
1. Privilégier des méthodes de fabrique statiques aux constructeurs 5
2. Appliquer la propriété du singleton avec un constructeur privé 10
3. Empêcher l'instanciation avec un constructeur privé 12
4. Empêcher la duplication d'objets 14
5. Eliminer les références d'objets obsolètes 18
6. Eviter les finaliseurs 21
Chapitre 3 Méthodes communes à tous les objets 25
7. Obéir au contrat général lors d'une redéfinition de la méthode equals 25
8. Toujours redéfinir hashCode lorsque equals est redéfini 36
9. Toujours redéfinir toString 42
10. Redéfinir judicieusement clone 45
11. Envisager l'implémentation de Comparable 54
Chapitre 4 Classes et Interfaces 59
12. Restreindre l'accès des classes et de leurs membres 59
13. Favoriser l'immuabilité 63
14. Préférer la composition à l'héritage 71
15. Prévoir et documenter l'héritage ou bien l'interdire 78
16. Préférer les interfaces aux classes abstraites 83
17. N'utiliser les interfaces que pour définir les types 88

17. N'utiliser les interfaces que pour définir les types 88
18. Favoriser les classes imbriquées statiques 96
Chapitre 5 Equivalents pour constructions du langage C 95
19. Remplacer les structures par des classes 95
20. Remplacer une union par une hiérarchie de classes 98
21. Remplacer les constructions enum par des classes 102
22. Remplacer les pointeurs de fonctions par des classes et des interfaces 113
Chapitre 6 Méthodes 117
23. Vérifier la validité d'un paramètre 117
24. Procéder à des recopies défensives en cas de besoin 120
25. Concevoir avec attention la signature d'une méthode 124
26. Utiliser la surcharge avec discernement 126
27. Renvoyer des tableaux vides plutôt que pull 131
28. Ecrire des commentaires de documentation pour tous les éléments exposés d'une API 133
Chapitre 7 Programmation générale 137
29. Minimiser la portée des variables locales 137
30. Connaître et utiliser les bibliothèques 141
31. Eviter float et double si un résultat exact est requis 145
32. Eviter les chaînes de caractères là où d'autres types sont plus appropriés 148
33. Attention à la performance dans la concaténation de chaînes de caractères 151
34. Faire référence à un objet via son interface 153
35. Préférer les interfaces à la réflexion 155
36. Utiliser judicieusement les méthodes natives 158
37. Optimiser judicieusement 160
38. Suivre les conventions de nommage généralement acceptées 164
Chapitre 8 Exceptions 169
39. N'utiliser une exception que dans des situations exceptionnelles 169
40. Utiliser une exception vérifiée pour une situation récupérable et une exception non vérifiée pour une
erreur de programmation 173
41. Ne pas abuser des exceptions vérifiées 175
42. Préférer l'utilisation d'une exception standard 177
43. Lever des exceptions en rapport avec l'abstraction 179
44. Documenter toutes les exceptions levées par une méthode 182
45. Inclure l'information de contexte dans les messages détaillés 184
46. Garantir l'atomicité d'une erreur 186
47. Ne pas ignorer une exception 188
Chapitre 9 Threads 189
48. Synchroniser l'accès à toute donnée partagée et muable 189
49. Eviter toute synchronisation excessive 196
50. Ne jamais invoquer wait en dehors d'une boucle 202
51. Ne pas s'appuyer sur l'ordonnanceur de threads 205
52. Documenter la sûreté des threads 209
53. Eviter les groupes de threads 213
Chapitre 10 Sérialisation 215
54. Implémenter judicieusement Serializable 215
55. Envisager l'utilisation d'une sérialisation sur mesure 221
56. Rédiger la méthode readObject de manière défensive 228
57. Fournir une méthode readResolve lorsque cela est nécessaire 235
Bibliographie 239
Index des idiomes et patterns 243
Index 245
TOP