Thinking in Java, 3rd ed. Revision 4.0

Preface
Préface
Préface à la 3ème édition
Java 2, JDK 1.4
Introduction
Introduction
Prérequis
Apprendre Java
Buts
La documentation HTML du JDK
Chapitres
Exercices
Le CD ROM
Le Code Source
Typographie et style de code
Versions Java
Erreurs
Note sur la conception de la couverture
Remerciements
Chapitre 1
1. Introduction aux Objets
1.1. Les bienfaits de l'abstraction
1.2. Un objet a une interface
1.3. Un objet fournit des services
1.4. L'implémentation cachée
1.5. Réutilisation de l'implémentation
1.6. Héritage : réutilisation de l'interface
1.6.1. Relations est-un versus relations est-comme-un
1.7. Objets interchangeables par polymorphisme
1.7.1. Classes mères abstraites et interfaces
1.8. Création des objets, utilisation et cycle de vie
1.8.1. Collections et itérateurs
1.8.2. La hiérarchie à racine unique
1.8.3. Transtypage descendant vs. modèles/génériques
1.8.4. Assurer un nettoyage approprié
1.8.5. Ramasses-miettes vs. efficacité et flexibilité
1.9. Traitement des exceptions : gérer les erreurs
1.10. Concurrence
1.11. Persistance
1.12. Java et Internet
1.12.1. What is the Web?
1.12.1.1. Client/Server computing
1.12.1.2. The Web as a giant server
1.12.2. Client-side programming
1.12.2.1. Plug-ins
1.12.2.2. Scripting languages
1.12.2.3. Java
1.12.2.4. .NET and C#
1.12.2.5. Security
1.12.2.6. Internet vs. intranet
1.12.3. Programmation côté serveur
1.12.4. Applications
1.13. Les raisons du succès de Java
1.13.1. Les systèmes sont plus faciles à décrire et comprendre
1.13.2. Puissance maximale grâce aux bibliothèques
1.13.3. Traitement des erreurs
1.13.4. La programmation à grande échelle
1.14. Java vs. C++ ?
1.15. Résumé
Chapitre 2
2. Tout est objet
2.1. Les objets sont manipulés via des références
2.2. Vous devez créer tous les objets
2.2.1. Où réside la mémoire
2.2.2. Cas particulier: les types primitifs
2.2.2.1. Les nombres de haute précision
2.2.3. Les tableaux en Java
2.3. Vous n'avez jamais besoin de détruire un objet
2.3.1. La portée
2.3.2. Portée des objets
2.4. Créer de nouveaux types de données : class
2.4.1. Champs et méthodes
2.4.1.1. Valeurs par défaut des attributs
2.5. Méthodes, paramètres et valeurs de retour
2.5.1. La liste de paramètres
2.6. Construction d'un programme Java
2.6.1. Visibilité des noms
2.6.2. Utilisation d'autres composantes
2.6.3. Le mot-clef static
2.7. Votre premier programme Java
2.7.1. Compilation et exécution
2.8. Commentaires et documentation intégrée
2.8.1. Commentaires de documentation
2.8.2. Syntaxe
2.8.3. HTML intégré
2.8.4. Des exemples de tags
2.8.4.1. @see: faire référence aux autres classes
2.8.4.2. {@link package.class#member label}
2.8.4.3. {@docRoot}
2.8.4.4. {@inheritDoc} 
2.8.4.5. @version
2.8.4.6. @author
2.8.4.7. @since
2.8.4.8. @param
2.8.4.9. @return
2.8.4.10. @throws
2.8.4.11. @deprecated
2.8.5. Exemple de documentation
2.9. Style de programmation
2.10. Sommaire
2.11. Exercices
Chapitre 3
3. Contrôle du Flux de Programme
3.1. Utilisation des opérateurs Java
3.1.1. Priorité
3.1.2. L'affectation
3.1.2.1. L'aliasing pendant l'appel des méthodes
3.1.3. Opérateurs mathématiques
3.1.3.1. Expressions régulières
3.1.3.2. Les opérateurs unaires moins et plus
3.1.4. Incrémentation et décrémentation automatique
3.1.5. Opérateurs relationnels
3.1.5.1. Tester l'équivalence entre objet
3.1.6. Opérateurs logiques
3.1.6.1. Court circuit
3.1.7. Les opérateurs bit à bit
3.1.8. Les opérateurs de décalage
3.1.9. Opérateur ternaire if-else
3.1.10. L'opérateur virgule
3.1.11. String opérateur +
3.1.12. Pièges courants lors de l'utilisation d'opérateurs
3.1.13. Les opérateurs de transtypage
3.1.13.1. Les littéraux
3.1.13.2. La promotion
3.1.14. Java n'a pas d'opérateur sizeof()
3.1.15. Retour sur la priorité des opérateurs
3.1.16. Résumé sur les opérateurs
3.2. Le contrôle d'exécution
3.2.1. true et false
3.2.2. if-else
3.2.3. return
3.2.4. Itération
3.2.5. do-while
3.2.6. for
3.2.6.1. L'opérateur virgule
3.2.7. break et continue
3.2.7.1. L'infâme « goto »
3.2.8. switch
3.2.8.1. Détails de calcul
3.3. Résumé
3.4. Exercices
Chapitre 4
4. Initialisation et nettoyage
4.1. Garantie de l'initialisation avec le constructeur
4.2. La surcharge de méthodes
4.2.1. Différencier les méthodes surchargées
4.2.2. Surcharge avec des types primitifs
4.2.3. Surcharge pour les valeurs retour
4.2.4. Constructeurs par défaut
4.2.5. Le mot clé this
4.2.5.1. Appeler un constructeur à partir d'un constructeur
4.2.5.2. La signification de static
4.3. Nettoyage : finalisation et ramasse-miettes
4.3.1. A quoi sert finalize( ) ?
4.3.2. Le nettoyage est impératif
4.3.3. La condition de fin
4.3.4. Comment fonctionne un ramasse-miettes ?
4.4. Initialisation de membre
4.4.1. Spécifier l'initialisation
4.4.2. Initialisation par constructeur
4.4.2.1. Ordre d'initialisation
4.4.2.2. Initialisation de données statiques
4.4.2.3. Initialisation statique explicite
4.4.2.4. Initialisation d'instance non statique
4.5. Initialisation des tableaux
4.5.1. Tableaux multidimensionnels
4.6. Résumé
4.7. Exercices
Chapitre 5
5. Cacher l'implémentation
5.1. package: the library unit
5.1.1. Créer des noms de packages uniques
5.1.1.1. Collisions
5.1.2. Une bibliothèque d'outils personnalisée
5.1.3. Utilisation des imports pour modifier le comportement
5.1.4. Mise en garde sur les packages
5.2. Les spécificateurs d'accès Java
5.2.1. Accès package
5.2.2. public : accès d'interface
5.2.2.1. Le package par défaut
5.2.3. private : ne pas toucher !
5.2.4. protected: accès pour l'héritage
5.3. Interface et implémentation
5.4. L'accès aux classes
5.5. Résumé
5.6. Exercices
Chapitre 6
6. Réutiliser les classes
6.1. Syntaxe de la composition
6.2. La syntaxe de l'héritage
6.2.1. Initialiser la classe de base
6.2.1.1. Constructeurs avec arguments
6.2.1.2. Attraper les exceptions du constructeur de base
6.3. Combiner composition et héritage
6.3.1. Garantir un nettoyage propre
6.3.2. Cacher les noms
6.4. Choisir entre la composition et l'héritage
6.5. protected
6.6. Développement incrémental
6.7. Transtypage ascendant
6.7.1. Pourquoi le transtypage ascendant ?
6.7.1.1. Composition à la place de l'héritage revisité
6.8. Le mot-clé final
6.8.1. Les variables final
6.8.1.1. Final vides
6.8.1.2. Les arguments final
6.8.2. Les méthodes final
6.8.2.1. final et private
6.8.3. Les classes Final
6.8.4. Avertissement sur l'utilisation du mot clé final
6.9. Initialisation et chargement de classes
6.9.1. Initialisation avec héritage
6.10. Résumé
6.11. Exercices
Chapitre 7
7. Polymorphisme
7.1. Upcasting revisité
7.1.1. Oubliant le type d'objet
7.2. Le twist
7.2.1. Liaison entre l'appel de méthode et la méthode
7.2.2. Produire le bon comportement
7.2.3. Extensibilité
7.2.4. Piège: redéfinition de méthodes privées
7.3. Classes et méthodes abstraites
7.4. Constructeurs et polymorphisme
7.4.1. Ordre d'appel des constructeurs
7.4.2. Héritage et nettoyage
7.4.3. Comportement des méthodes polymorphes dans les constructeurs
7.5. Concevoir avec l'héritage
7.5.1. Héritage pur vs. extension
7.5.2. Transtypage descendant et identification du type à l'exécution
7.6. Résumé
7.7. Exercices
Chapitre 8
8. Interfaces et classes internes
8.1. Interfaces
8.1.1. « Héritage multiple » en Java
8.1.1.1. Combinaison d'interfaces et collisions de noms
8.1.2. Etendre une interface avec l'héritage
8.1.3. Groupes de constantes
8.1.4. Initialisation des champs dans les interfaces
8.1.5. Interfaces imbriquées
8.2. Classes internes
8.2.1. Classes internes et transtypage ascendant
8.2.2. Classes internes dans les méthodes et les domaines d'application
8.2.3. Anonymous inner classes
8.2.4. Le lien vers la classe externe
8.2.5. Nested classes
8.2.6. Se référer à l'objet de la classe externe
8.2.7. Classe interne à plusieurs niveaux d'imbrication
8.2.8. Hériter d'une classe interne
8.2.9. Les classes internes peuvent-elles redéfinies ?
8.2.10. Les classes internes locales
8.2.11. Identifiants des classes internes
8.3. Raison d'être des classes internes
8.3.1. Fermetures & callbacks
8.3.2. Inner classes & control frameworks
8.4. Summary
8.5. Exercices
Chapitre 9
9. Gestion des erreurs avec les Exceptions
9.1. Les exceptions de base
9.1.1. Les paramètres des Exceptions
9.2. Attraper une exception
9.2.1. Le bloc try
9.2.2. Les gestionnaires d'exception
9.2.2.1. Terminaison contre Restauration
9.3. Créer vos propres exceptions
9.4. La spécification des exceptions
9.5. Attraper n'importe quelle exception
9.5.1. Relancer une exception
9.5.2. Enchaînement d'exceptions
9.6. Exceptions Java standards
9.6.1. Le cas particulier RuntimeException
9.7. Effectuer le ménage avec finally
9.7.1. A quoi sert finally ?
9.7.2. Piège: l'exception perdue
9.8. Exception restrictions
9.9. Constructors
9.10. Exception matching
9.11. Alternative approaches
9.11.1. History
9.11.2. Perspectives
9.11.3. Passing exceptions to the console
9.11.4. Converting checked to unchecked exceptions
9.12. Conseils pour les exceptions
9.13. Summary
9.14. Exercices
Chapitre 10
10. Détecter les types
10.1. The need for RTTI
10.1.1. The Class object
10.1.1.1. Class literals
10.1.2. Checking before a cast
10.1.2.1. Using class literals
10.1.2.2. A dynamic instanceof
10.1.2.3. instanceof vs. Class equivalence
10.2. RTTI syntax
10.3. Reflection: run time class information
10.3.1. A class method extractor
10.4. Summary
10.5. Exercises
Chapitre 11
11. Collections d'Objets
11.1. Arrays
11.1.1. Les tableaux sont des objets
11.1.1.1. Conteneurs de type primitif
11.1.2. Renvoyer un tableau
11.1.3. La classe Arrays
11.1.4. Remplir un tableau
11.1.5. Copier un tableau
11.1.6. Comparer des tableaux
11.1.7. Comparaison d'éléments d'un tableau
11.1.8. Trier un tableau
11.1.9. Rechercher dans un tableau trié
11.1.10. Résumé sur les tableaux
11.2. Introduction sur les conteneurs
11.2.1. Afficher les conteneurs
11.2.2. Remplir les conteneurs
11.3. L'inconvénient des conteneurs : le type est inconnu
11.3.1. Quelquefois ça marche quand même
11.3.2. Créer une ArrayList consciente du type
11.3.2.1. Types paramétrés
11.4. Iterators
11.4.1. Récursion indésirable
11.5. Classification des conteneurs
11.6. Fonctionnalités des Collection
11.7. Fonctionnalités des List
11.7.1. Réaliser une pile à partir d'une LinkedList
11.7.2. Réaliser une file à partir d'une LinkedList
11.8. Fonctionnalités des Sets
11.8.1. Ensemble trié : SortedSet
11.9. Fonctionnalités des Maps
11.9.1. SortedMap
11.9.2. LinkedHashMap
11.9.3. Hashing and hash codes
11.9.3.1. Understanding hashCode( )
11.9.3.2. HashMap performance factors
11.9.4. Surcharger hashCode( )
11.10. Holding references
11.10.1. The WeakHashMap
11.11. Les itérateurs revisités
11.12. Choisir une implémentation
11.12.1. Choisir entre les Lists
11.12.2. Choisir entre les Sets
11.12.3. Choisir entre les Maps
11.13. Trier et rechercher dans les Lists
11.14. Utilitaires
11.14.1. Rendre une Collection ou une Map non-modifiable
11.14.2. Synchroniser une Collection ou une Map
11.14.2.1. Echec rapide
11.15. Opérations non supportées
11.16. Les conteneurs Java 1.0 / 1.1
11.16.1. Vector & Enumeration
11.16.2. Hashtable
11.16.3. Stack
11.16.4. BitSet
11.17. Résumé
11.18. Exercices
Chapitre 12
12. Le système d'E/S de Java
12.1. La classe File
12.1.1. Lister un répertoire
12.1.1.1. Les classes internes anonymes
12.1.2. Vérification et création de répertoires
12.2. Entrée et sortie
12.2.1. Les types d'InputStream
12.2.2. Les types d'OutputStream
12.3. Ajouter des attributs et des interfaces utiles
12.3.1. Lire depuis un InputStream avec FilterInputStream
12.3.2. Écrire vers un OutputStream avec FilterOutputStream
12.4. Lecteurs & écrivains [ Readers & Writers ]
12.4.1. Les sources et les réceptacles de données
12.4.2. Modifier le comportement du flux
12.4.3. Les classes inchangées
12.5. Et bien sûr : L'accès aléatoire aux fichiers (RandomAccessFile)
12.6. L'usage typique des flux d'E/S
12.6.1. Flux d'Entrée
12.6.1.1. Entrée de fichier avec tampon [Buffered input file] (1)
12.6.1.2. Entrée depuis la mémoire (2)
12.6.1.3. Entrée de mémoire formatée (3)
12.6.1.4. Sortie de Fichier (4)
12.6.2. Flux de sortie
12.6.2.1. Stocker et récupérer des données (5)
12.6.2.2. Accés aléatoire en lecture et écriture aux fichiers (6)
12.6.3. Flux redirigé
12.7. Utilitaires de lecture et d'écriture de fichiers
12.8. E/S Standard
12.8.1. Lire depuis l'entrée standard
12.8.2. Modifier System.out en un PrintWriter
12.8.3. Rediriger les E/S standards
12.9. New I/O
12.9.1. Converting data
12.9.2. Fetching primitives
12.9.3. View buffers
12.9.3.1. Endians
12.9.4. Data manipulation with buffers
12.9.5. Buffer details
12.9.6. Memory-mapped files
12.9.6.1. Performance
12.9.7. File locking
12.9.7.1. Locking portions of a mapped file
12.10. Compression
12.10.1. Compression simple avec GZIP
12.10.2. Stockage de fichiers multiples avec Zip
12.10.3. Java ARchives (JARs)
12.11. Object serialization
12.11.1. Finding the class
12.11.2. Controlling serialization
12.11.2.1. The transient keyword
12.11.2.2. An alternative to Externalizable
12.11.2.3. Versioning
12.11.3. Using persistence
12.12. Preferences
12.13. Regular expressions
12.13.1. Creating regular expressions
12.13.2. Quantifiers
12.13.2.1. CharSequence
12.13.3. Pattern and Matcher
12.13.3.1. find( )
12.13.3.2. Groups
12.13.3.3. start( ) and end( )
12.13.3.4. Pattern flags
12.13.4. split( )
12.13.5. Replace operations
12.13.6. reset( )
12.13.7. Regular expressions and Java I/O
12.13.8. Is StringTokenizer needed?
12.14. Summary
12.15. Exercises
Chapitre 13
13. Concurrence
13.1. Motivation
13.2. Threads simples
13.2.1. Cession de priorité
13.2.2. Endormissement
13.2.3. Priorités
13.2.4. Les threads démons
13.2.5. Rattachement à un thread
13.2.6. Variantes d'écriture du code
13.2.7. Création d'interfaces utilisateurs réagissant bien
13.3. Partage de ressources limitées
13.3.1. Accès incorrect aux ressources
13.3.1.1. Un framework qui teste les ressources
13.3.2. Colliding over resources
13.3.3. Resolving shared resource contention
13.3.3.1. Synchronizing the EvenGenerator
13.3.3.2. Atomic operations
13.3.3.3. Fixing Semaphore
13.3.4. Critical sections
13.4. Thread states
13.4.1. Becoming blocked
13.5. Cooperation between threads
13.5.1. Wait and notify
13.5.2. Using Pipes for I/O between threads
13.5.3. More sophisticated cooperation
13.6. Deadlock
13.7. The proper way to stop
13.8. Interrupting a blocked thread
13.9. Thread groups
13.10. Summary
13.11. Exercises
Chapitre 14
14. Creating Windows & Applets
14.1. The basic applet
14.1.1. Applet restrictions
14.1.2. Applet advantages
14.1.3. Application frameworks
14.1.4. Running applets inside a Web browser
14.1.5. Using Appletviewer
14.1.6. Testing applets
14.2. Running applets from the command line
14.2.1. A display framework
14.3. Making a button
14.4. Capturing an event
14.5. Text areas
14.6. Controlling layout
14.6.1. BorderLayout
14.6.2. FlowLayout
14.6.3. GridLayout
14.6.4. GridBagLayout
14.6.5. Absolute positioning
14.6.6. BoxLayout
14.6.7. The best approach?
14.7. The Swing event model
14.7.1. Event and listener types
14.7.1.1. Using listener adapters for simplicity
14.7.2. Tracking multiple events
14.8. A catalog of Swing components
14.8.1. Buttons
14.8.1.1. Button groups
14.8.2. Icons
14.8.3. Tool tips
14.8.4. Text fields
14.8.5. Borders
14.8.6. JScrollPanes
14.8.7. A mini-editor
14.8.8. Check boxes
14.8.9. Radio buttons
14.8.10. Combo boxes (drop-down lists)
14.8.11. List boxes
14.8.12. Tabbed panes
14.8.13. Message boxes
14.8.14. Menus
14.8.15. Pop-up menus
14.8.16. Drawing
14.8.17. Dialog Boxes
14.8.18. File dialogs
14.8.19. HTML on Swing components
14.8.20. Sliders and progress bars
14.8.21. Trees
14.8.22. Tables
14.8.23. Selecting Look & Feel
14.8.24. The clipboard
14.9. Packaging an applet into a JAR file
14.10. Signing applets
14.11. JNLP and Java Web Start
14.12. Programming techniques
14.12.1. Binding events dynamically
14.12.2. Separating business logic from UI logic
14.12.3. A canonical form
14.13. Concurrency & Swing
14.13.1. Runnable revisited
14.13.2. Managing concurrency
14.14. Visual programming and JavaBeans
14.14.1. Qu'est-ce qu'un JavaBean ?
14.14.2. Extraction du BeanInfo avec l'Introspector
14.14.3. Un Bean plus sophistiqué
14.14.4. JavaBeans et synchronisation
14.14.5. Packager un Bean
14.14.6. Fonctionalités avancées des Beans
14.14.7. Davantage sur les Beans
14.15. Résumé
14.16. Exercises
Chapitre 15
15. Découvrir les problèmes
15.1. Test unitaire
15.1.1. Un Framework de Test Simple
15.1.2. JUnit
15.2. Améliorer la fiabilité avec les assertions
15.2.1. Syntaxe de l'assertion
15.2.2. Utiliser les assertions pour la Conception par Contrat
15.2.2.1. Vérifier les instructions
15.2.2.2. Préconditions
15.2.2.3. Postconditions
15.2.2.4. Invariants
15.2.2.5. Affaiblir la CPC
15.2.3. Exemple: CPC + test unitaire boîte blanche
15.3. Construire avec Ant
15.3.1. Tout automatiser
15.3.2. Les problèmes avec make
15.3.3. Ant : le standard de facto
15.3.3.1. Les extensions de Ant
15.3.4. Contrôle de version avec CVS
15.3.5. Construire quotidiennement
15.4. Loguer
15.4.1. Les niveaux de logue
15.4.2. Enregistrements de logue
15.4.3. Gestionnaires
15.4.3.1. Gestionnaires Multiples
15.4.3.2. Ecrire ses propres Gestionnaires
15.4.4. Filtres
15.4.5. Formateurs
15.4.6. Exemple: Envoyez un rapport de logue par email
15.4.7. Contrôler les Niveaux de Logue par les Espaces de Noms
15.4.8. Pratiques de Logue pour de Grands Projets
15.4.8.1. Fichiers de configuration
15.4.8.2. Fichiers de logue rotatifs
15.4.8.3. Pratiques recommandées
15.4.9. Résumé
15.5. Déboguer
15.5.1. Déboguer avec JDB
15.5.2. Débogueurs graphiques
15.6. Profiler et optimiser
15.6.1. Tracer la consommation mémoire
15.6.2. Tracer l'usage de la CPU
15.6.3. Couverture de test
15.6.4. Interface de profilage de la JVM
15.6.5. Utiliser HPROF
15.6.6. Performance des thread
15.6.7. Guide d'optimisation
15.7. Les doclets
15.8. Résumé
15.9. Exercices
Chapitre 16
16. Analyse et Design
16.1. Méthodologie
16.2. Phase 0: Make a plan
16.2.1. The mission statement
16.3. Phase 1: What are we making?
16.4. Phase 2: How will we build it?
16.4.1. Five stages of object design
16.4.2. Guidelines for object development
16.5. Phase 3: Build the core
16.6. Phase 4: Iterate the use cases
16.7. Phase 5: Evolution
16.8. Plans pay off
16.9. Extreme Programming
16.9.1. Write tests first
16.9.2. Pair programming
16.10. Strategies for transition
16.10.1. Guidelines
16.10.1.1. 1. Training
16.10.1.2. 2. Low-risk project
16.10.1.3. 3. Model from success
16.10.1.4. 4. Use existing class libraries
16.10.1.5. 5. Don't rewrite existing code in Java
16.10.2. Management obstacles
16.10.2.1. Startup costs
16.10.2.2. Performance issues
16.10.2.3. Common design errors
16.11. Summary
Appendix A
A. Passing & Returning Objects
A.1. Passing references around
A.1.1. Aliasing
A.2. Making local copies
A.2.1. Pass by value
A.2.2. Cloning objects
A.2.3. Adding cloneability to a class
A.2.3.1. Using a trick with protected
A.2.3.2. Implementing the Cloneable interface
A.2.4. Successful cloning
A.2.5. The effect of Object.clone( )
A.2.6. Cloning a composed object
A.2.7. A deep copy with ArrayList
A.2.8. Deep copy via serialization
A.2.9. Adding cloneability farther down a hierarchy
A.2.10. Why this strange design?
A.3. Controlling cloneability
A.3.1. The copy constructor
A.3.1.1. Why does it work in C++ and not Java?
A.4. Read-only classes
A.4.1. Creating read-only classes
A.4.2. The drawback to immutability
A.4.3. Immutable Strings
A.4.3.1. Implicit constants
A.4.3.2. Overloading '+' and the StringBuffer
A.4.4. The String and StringBuffer classes
A.4.5. Strings are special
A.5. Summary
A.6. Exercises
A.7. Appendix
Appendix B
B. Java Programming Guidelines
B.1. Design
B.2. Implementation
Appendix C
C. Supplements
C.1. Foundations for Java seminar-on-CD
C.2. Thinking in Java seminar
C.3. Hands-On Java seminar-on-CD 3rd edition
C.4. Designing Objects & Systems seminar
C.5. Thinking in Enterprise Java
C.6. The J2EE seminar
C.7. Thinking in Patterns (with Java)
C.8. Thinking in Patterns seminar
C.9. Design consulting and reviews
Appendix D
D. Resources
D.1. Software
D.2. Books
D.2.1. Analysis & design
D.2.2. Python
D.2.3. My own list of books
Appendix E
E. Index