Table des matières

• Préface
• • Préface à la 2ème édition
  • • Java 2
  • Le CD ROM

• Introduction
• • Prérequis
  • Apprendre Java
  • Buts
  • Documentation en ligne
  • Les chapitres
  • Exercices
  • Le CD ROM Multimédia
  • Le Code Source
  • • Typographie et style de code
  • Les versions de Java
  • Seminars and mentoring
  • Errors
  • À propos de la conception de la couverture du livre
  • Remerciements
  • • Collaborateurs Internet

• 1) Introduction sur les Objets
• • Les bienfaits de l'abstraction
  • Un objet dispose d'une interface
  • L'implémentation cachée
  • Réutilisation de l'implémentation
  • Héritage : réutilisation de l'interface
  • • Les relations est-un vs. est-comme-un 
  • Polymorphisme : des objets interchangeables
  • • Classes de base abstraites et interfaces
  • Environnement et durée de vie des objets
  • • Collections et itérateurs
    • La hiérarchie de classes unique
    • Bibliothèques de collections et support pour l'utilisation aisée des collections
    • • Transtypages descendants vs. patrons génériques
    • Le dilemme du nettoyage : qui en est responsable ?
    • • Ramasse-miettes vs. efficacité et flexibilité
  • Traitement des exceptions : gérer les erreurs
  • Multithreading
  • Persistance
  • Java et l'Internet
  • • Qu'est-ce que le Web ?
    • • Le concept Client/Serveur
      • Le Web en tant que serveur géant
    • La programmation côté client
    • • Les plug-ins
      • Les langages de script
      • Java
      • ActiveX
      • La sécurité
      • Internet vs. intranet
    • La programmation côté serveur
    • Une scène séparée : les applications
  • Analyse et conception
  • • Phase 0 : Faire un plan
    • • L'exposé de la mission
    • Phase 1 : Que construit-on ?
    • Phase 2 : Comment allons-nous le construire ?
    • • Les cinq étapes de la conception d'un objet
      • Indications quant au développement des objets
    • Phase 3 : Construire le coeur du système
    • Phase 4 : Itérer sur les cas d'utilisation
    • Phase 5 : Evolution
    • Les plans sont payants
  • Programmation Extrême
  • • Commencer par écrire les tests
    • Programmation en binôme
  • Les raisons du succès de Java
  • • Les systèmes sont plus faciles à exprimer et comprendre
    • Puissance maximale grâce aux bibliothèques
    • Traitement des erreurs
    • Mise en oeuvre de gros projets
  • Stratégies de transition
  • • Règles de base
    • • 1. Cours
      • 2. Projet à faible risque
      • 3. S'inspirer de bonnes conceptions
      • 4. Utiliser les bibliothèques de classes existantes
      • 5. Ne pas traduire du code existant en Java
    • Les obstacles au niveau du management
    • • Coûts de mise en oeuvre
      • Problèmes de performances
      • Erreurs classiques de conception
  • Java vs. C++ ?
  • Résumé

• 2 : Tout est Objet
• • Les objets sont manipulés avec des références
  • Vous devez créer tous les objets
  • • Où réside la mémoire ?
    • Cas particulier : les types primitifs
    • • Nombres de grande précision
    • Tableaux en Java
  • Vous n'avez jamais besoin de détruire un objet
  • • Notion de portée
    • Portée des objets
  • Créer de nouveaux types de données : class
  • • Champs et méthodes
    • • Valeurs par défaut des membres primitifs
  • Méthodes, paramètres et valeurs de retour
  • • La liste de paramètres
  • Construction d'un programme Java
  • • Visibilité des noms
    • Utilisation d'autres composantes
    • Le mot-clef static
  • Votre premier programme Java
  • • Compilation et exécution
  • Commentaires et documentation intégrée
  • • Commentaires de documentation
    • Syntaxe
    • HTML intégré
    • @see : faire référence aux autres classes
    • Class documentation tags
    • • @version
      • @author
      • @since
    • Les onglets de documentation de variables
    • Les onglets de documentation de méthodes
    • • @param
      • @return
      • @throws
      • @deprecated
    • Exemple de documentation
  • Style de programmation
  • Sommaire
  • Exercices

• 3 : Contrôle du Flux de Programme
• • Utilisation des opérateurs Java
  • • Priorité
    • L'affectation
    • • L'aliasing pendant l'appel des méthodes
    • Les opérateurs mathématiques
    • • Les opérateurs unaires (à un opérande) moins et plus
    • Incrémentation et décrémentation automatique
    • Les opérateurs relationnels
    • • Tester l'équivalence des objets
    • Les opérateurs logiques
    • • « Court-circuit  »
    • Les opérateurs bit à bit
    • Les opérateurs de décalage
    • Opérateur ternaire if-else
    • L'opérateur virgule
    • L'opérateur + pour les String
    • Les pièges classiques dans l'utilisation des opérateurs
    • Les opérateurs de transtypage
    • • Les littéraux
      • La promotion
    • Java n'a pas de « sizeof »
    • Retour sur la priorité des opérateurs
    • Résumé sur les opérateurs
  • Le Contrôle d'exécution
  • • true et false
    • if-else
    • • return
    • Itération
    • do-while
    • for
    • • L'opérateur virgule
    • break et continue
    • • L'infâme « goto »
    • switch
    • • Détails de calcul :
  • Résumé
  • Exercices

• 4: Initialisation & Nettoyage
• • Garantie d'initialisation grâce au constructeur
  • Surcharge de méthodes
  • • Différencier les méthodes surchargées
    • Surcharge avec types de base
    • Surcharge sur la valeur de retour
    • Constructeurs par défaut
    • Le mot-clé this
    • • Appeler un constructeur depuis un autre constructeur
      • La signification de static
  • Nettoyage : finalisation et ramasse-miettes
  • • A quoi sert finalize( ) ?
    • Le nettoyage est impératif
    • La «death condition»
    • Comment fonctionne un ramasse-miettes ?
  • Initialisation de membre
  • • Spécifier une initialisation
    • Initialisation par constructeur
    • • Ordre d'initialisation
      • Initialisation de données statiques
      • Initialisation statique explicite
      • Initialisation d'instance non statique
  • Initialisation des tableaux
  • • Tableaux multidimensionels
  • Résumé
  • Exercices

• 5 : Cacher l'Implémentation
• • package : l'unité de bibliothèque
  • • Créer des noms de packages uniques
    • • Collisions
    • Une bibliothèque d'outils personnalisée
    • Utilisation des imports pour modifier le comportement
    • Avertissement sur les packages
  • Les spécificateurs d'accès Java
  • • « Friendly »
    • public : accès d'interface
    • • Le package par défaut
    • private : ne pas toucher !
    • protected : « sorte d'amical »
  • Interface et implémentation
  • L'accès aux classes
  • Résumé
  • Exercices

• 6 : Réutiliser les classes
• • Syntaxe de composition
  • La syntaxe de l'héritage
  • • Initialiser la classe de base
    • • Constructeurs avec paramètres
      • Attraper les exceptions du constructeur de base.
  • Combiner composition et héritage.
  • • Garantir un nettoyage propre
    • • L'ordre du ramasse-miettes
    • Cacher les noms
  • Choisir la composition à la place de l'héritage
  • protected
  • Développement incrémental
  • Transtypage ascendant
  • • Pourquoi le transtypage ascendant ? 
    • • Composition à la place de l'héritage revisité
  • Le mot clé final
  • • Données finales
    • • Finals sans initialisation
      • Arguments final
    • Méthodes final
    • • final et private
    • Classes final
    • Attention finale
  • Initialisation et chargement de classes
  • • Initialisation avec héritage
  • Résumé
  • Exercices

• 7: Polymorphisme
• • Upcasting
  • • Pourquoi utiliser l'upcast?
  • The twist
  • • Liaison de l'appel de méthode
    • Produire le bon comportement
    • Extensibilité
  • Redéfinition et Surcharge
  • Classes et méthodes abstraites
  • Constructeurs et polymorphisme
  • • Ordre d'appel des constructeurs
    • La méthode finalize() et l'héritage
    • Comportement des méthodes polymorphes dans les constructeursname="Index722">
  • Concevoir avec l'héritage
  • • Héritage pur contre extensionname="Index739">
    • Downcasting et identification du type à l'exécution
  • Résumé
  • Exercices

• 8 : Interfaces & Classes Internes
• • Interfaces
  • • « Héritage multiple » en Java
    • • Combinaison d'interfaces et collisions de noms 
    • Etendre une interface avec l'héritage
    • Groupes de constantes
    • Initialisation des données membres des interfaces
    • Interfaces imbriquées
  • Classes internes
  • • Classes internes et transtypage ascendant
    • Classes internes définies dans des méthodes et autres portées
    • Classes internes anonymes
    • Lien vers la classe externe
    • Classes internes static
    • Se référer à l'objet de la classe externe
    • Classe interne à plusieurs niveaux d'imbrication
    • Dériver une classe interne
    • Les classes internes peuvent-elles redéfinies ?
    • Identifiants des classes internes
    • Raison d'être des classes internes
    • • Fermetures & callbacks
    • Classes internes & structures de contrôle
  • Résumé
  • Exercices

• 9 : Stockage des objets
• • Les tableaux
  • • Les tableaux sont des objets
    • • Conteneurs de scalaires
    • Renvoyer un tableau
    • La classe Arrays
    • Remplir un tableau
    • Copier un tableau
    • Comparer des tableaux
    • Comparaison d'éléments de tableau
    • Trier un tableau
    • Effectuer une recherche sur un tableau trié
    • Résumé sur les tableaux
  • Introduction sur les  conteneurs
  • • Imprimer les conteneurs
    • Remplir les conteneurs
  • L'inconvénient des conteneurs : le type est inconnu
  • • Quelquefois ça marche quand même
    • Créer une ArrayList consciente du type
    • • Types paramétrés
  • Itérateurs
  • • Récursion indésirable
  • Classification des conteneurs
  • Fonctionnalités des Collections
  • Fonctionnalités des Lists
  • • Réaliser une pile à partir d'une LinkedList
    • Réaliser une file à partir d'une LinkedList
  • Fonctionnalités des Sets
  • • Sets triés : les SortedSets
  • Fonctionnalités des Maps
  • • Maps triées : les SortedMaps
    • Hachage et codes de hachage
    • • Comprendre hashCode()
      • Facteurs de performance d'un HashMap
    • Redéfinir hashCode()
  • Stocker des références
  • • Le WeakHashMap
  • Les itérateurs revisités
  • Choisir une implémentation
  • • Choisir entre les Lists
    • Choisir entre les Sets
    • Choisir entre les Maps
  • Trier et rechercher dans les Lists
  • Utilitaires
  • • Rendre une Collection ou une Map non-modifiable
    • Synchroniser une Collection ou une Map
    • • Echec rapide
  • Opérations non supportées
  • Les conteneurs Java 1.0 / 1.1
  • • Vector & Enumeration
    • Hashtable
    • Stack
    • BitSet
  • Résumé
  • Exercices

• 11: Le système d'E/S de Java
• • La classe File
  • • Lister un répertoire
    • • Les classes internes anonymes
    • Vérification et création de répertoires
  • Entrée et sortie
  • • Les types d'InputStream
    • Les types d'OutputStream
  • Ajouter des attributs et des interfaces utiles
  • • Lire depuis un InputStream avec FilterInputStream
    • Écrire vers un OutputStream avec FilterOutputStream
  • Lecteurs & écrivains [ Loaders & Writers ]
  • • Les sources et les réceptacles de données
    • Modifier le comportement du flux
    • Les classes inchangées
  • Et bien sûr : L'accès aléatoire aux fichiers (RandomAccessFile)
  • L'usage typique des flux d'E/S
  • • Flux d'Entrée
    • • 1. Entrée en tampon du fichier [Buffered input file]
      • 2. Entrée depuis la mémoire
      • 3. Entrée de mémoire formatée
      • 4. Sortie de Fichier
    • Flux de sortie
    • • 5. Stocker et récupérer des données
      • 6. Accés aléatoire en lecture et écriture aux fichiers
    • Un bogue ?
    • Flux Piped
  • Standard E/S
  • • Lire depuis une entrée standard
    • Modifier System.out en un PrintWriter
    • Réorienter l'E/S standard
  • Compression
  • • Compression simple avec GZIP
    • Stockage de fichiers multiples avec Zip
    • ARchives Java (JARs)
  • La sérialisation objet
  • • Trouver la classe
    • Contrôler la sérialisation
    • • Le mot-clé « transient »
      • Une alternative à Externalizable
      • Versioning
    • Utiliser la persistence
  • Tokenizer l'entrée
  • • StreamTokenizer
    • StringTokenizer
    • Vérifier le style de capitalization
  • Résumé
  • Exercices

• 12: Identification dynamique de type
• • Le besoin de RTTI
  • • L'objet Class
    • • Les littéraux Class
    • Vérifier avant de transtyper
    • • Utiliser les littéraux de classe
      • Un instanceof dynamique
      • instanceof vs. équivalence de classe
  • La syntaxe du RTTI
  • Réflexion : information de classe dynamique 
  • • Un extracteur de méthodes de classe
  • Résumé
  • Exercices

• 13: Création de Fenêtres et Applets
• • L'applet de base
  • • Les restrictions des applets
    • Les avantages d'une applet
    • Les squelettes d'applications
    • Exécuter des applets dans un navigateur Web
    • Utilisation de Appletviewer
    • Tester les applets
  • Exécuter des applets depuis la ligne de commande
  • • Un squelette d'affichage
    • Utilisation de l'Explorateur Windows
  • Création d'un bouton
  • Capture d'un événement
  • Zones de texte
  • Contrôle de la disposition
  • • BorderLayout
    • FlowLayout
    • GridLayout
    • GridBagLayout
    • Positionnement absolu
    • BoxLayout
    • La meilleure approche ?
  • Le modèle d'événements de Swing
  • • Evénements et types de listeners
    • • Utilisation de listener adapters pour simplifier
    • Surveiller plusieurs événements
  • Un catalogue de composants Swing
  • • Boutons
    • • Groupes de boutons
    • Icones
    • Infobulles [Tooltips]
    • Champs de texte [Text Fields]
    • Bordures
    • JScrollPanes
    • Un mini-éditeur
    • Boîtes à cocher [Check boxes]
    • Boutons radio
    • Boîtes combo (listes à ouverture vers le bas) [combo boxes (drop-down lists)]
    • Listes [List boxes]
    • Panneaux à tabulations [Tabbed panes]
    • Boîtes de messages
    • Menus
    • Menus pop-up
    • Dessiner
    • Boîtes de dialogue
    • Dialogues pour les fichiers [File dialogs]
    • HTML sur des composants Swing
    • Curseurs [sliders] et barres de progression [progress bars]
    • Arbres [Trees]
    • Tables
    • Sélection de l'aspect de l'interface [Look & Feel]
    • Le presse-papier [clipboard]
  • Empaquetage d'une applet dans un fichier JAR
  • Techniques de programmation
  • • Lier des événements dynamiquement
    • Séparation entre la logique applicative [business logic] et la logique de l'interface utilisateur [UI logic]
    • Une forme canonique
  • Programmation visuelle et Beans
  • • Qu'est-ce qu'un Bean ?
    • Extraction des informations sur les Beans [BeanInfo] à l'aide de l'introspecteur [Introspector]
    • Un Bean plus complexe
    • Empaquetage d'un Bean
    • Un support des Beans plus sophistiqué
    • Davantage sur les Beans
  • Résumé
  • Exercices

• 14) Les Threads multiples
• • Interfaces utilisateurs dynamiques [Responsive user interfaces]
  • • Héritage de Thread
    • Threading pour une une interface réactive
    • Combiner le thread avec la classe principale
    • Créer plusieurs threads
    • Threads démons
  • Partager des ressources limitées
  • • Des ressources accédées improprement
    • Comment Java partage les ressources
    • • Synchroniser les compteurs
      • Efficacité de la synchronisation
    • JavaBeans revisités
  • Blocage [Blocking]
  • • Passer à l'état bloqué
    • • Dormant (Sleeping)
      • Suspension et reprise
      • Attendre et notifier
      • Bloqué sur I/O
      • Tester
    • Interblocage [Deadlock]
    • • La dépréciation de stop(), suspend(), resume(), et destroy() en Java 2
  • Priorités
  • • Lire et changer les priorités
    • Les groupes de threads
    • • Controller les groupes de threads
  • Runnable revisité
  • • Trop de threads
  • Résumé
  • Exercices

• 15 : Informatique Distribuée
• • La programmation réseau
  • • Identifier une machine
    • • Serveurs et clients
      • Tester les programmes hors réseau
      • Les Ports  : un emplacement unique dans la machine
    • Les sockets
    • • Un serveur et un client vraiment simples
    • Servir des clients multiples
    • Les Datagrammes
    • Utiliser des URLs depuis un applet
    • • Lire un fichier depuis un serveur
    • En savoir plus sur le travail en réseau
  • Se connecter aux bases de données : Java Database Connectivity (JDBC)
  • • Faire fonctionner l'exemple
    • • Étape 1 : Trouver le Driver JDBC
      • Étape 2 : Configurer la base de données
      • Étape 3 : Tester la configuration
      • Étape 4 : Générer votre requête SQL
      • Étape 5 : Modifier et insérer votre requête
    • Une version GUI du programme de recherche
    • Pourquoi l'API JDBC paraît si complexe
    • Un exemple plus sophistiqué
  • Les Servlets
  • • Le servlet de base
    • Les Servlets et le multithreading
    • Gérer des sessions avec les servlets
    • • La classe Cookie
      • La classe Session
    • Faire fonctionner les exemples de servlet
  • Les Pages Java Serveur - Java Server Pages
  • • Les objets implicites
    • Les directives JSP
    • Les éléments de scripting JSP
    • Extraire des champs et des valeurs
    • Attributs et visibilité d'une page JSP
    • Manipuler les sessions en JSP
    • Créer et modifier des cookies
    • Résumé sur les JSP
  • RMI (Remote Method Invocation) : Invocation de méthodes distantes
  • • Interfaces Remote
    • Implémenter l'interface distante
    • • Mise en place du registre
    • Création des stubs et des skeletons
    • Utilisation de l'objet distant
  • Introduction à CORBA
  • • Principes de base de CORBA
    • • CORBA Interface Definition Language (IDL - Langage de Définition d'Interface)
      • Le service de nommage (naming service)
    • Un exemple
    • • Écrire le source IDL
      • Création des stubs et des skeletons
      • Implémentation du serveur et du client
      • Quelques services CORBA
      • Activation du processus du service de nommage
      • Activation du serveur et du client
    • Les Applets Java et CORBA
    • CORBA face à RMI
  • Enterprise Java Beans
  • • JavaBeans contre EJBs
    • Que définit la spécification des EJBs ?
    • • Les rôles
      • Composants EJB
      • • Conteneur d'EJB
        • Serveur EJB
        • Java Naming and Directory Interface (JNDI)
        • Java Transaction API / Java Transaction Service (JTA/JTS)
        • CORBA et RMI/IIOP
    • Qu'est-ce qui compose un composant EJB ?
    • • Enterprise Bean
      • Interface Home
      • Interface Remote
      • Descripteur de Déploiement
      • Fichier EJB-Jar
    • Comment travaille un EJB ?
    • Types d'EJBs
    • • Session Beans
      • • Les Session Beans non-persistants
        • Les Session Beans persistants
      • Entity Beans
      • • Gestion de la persistance par le conteneur (CMP - Container Managed Persistence)
        • Gestion de la persistence par le Bean (BMP - Bean Managed Persistence)
    • Développer un Enterprise Java Bean
    • En résumé
  • Jini : services distribués
  • • Contexte de Jini
    • Qu'est-ce que Jini ?
    • Comment fonctionne Jini
    • Le processus de découverte
    • Le processus de jonction
    • Le processus de recherche
    • Séparation de l'interface et de l'implémentation
    • Abstraction des systèmes distribués
  • Résumé
  • Exercices

• A : Passage & et Retour d'Objets
• • Passage de références
  • • Aliasing
  • Création de copies locales
  • • Passage par valeur
    • Clonage d'objets
    • Rendre une classe cloneable
    • • Utilisation d'une astuce avec protected
      • Implémenter l'interface Cloneable
    • Pour un clonage réussi
    • Le mécanisme de Object.clone( )
    • Cloner un objet composé
    • Copie profonde d'une ArrayList
    • Copie profonde via la sérialisation
    • Supporter le clonage plus bas dans la hiérarchie
    • Pourquoi cet étrange design ?
  • Contrôler la clonabilité
  • • Le constructeur de copie
    • • Pourquoi cela fonctionne-t-il en C++ et pas en Java ?
  • Classes en lecture seule
  • • Créer des classes en lecture seule
    • L'inconvénient de l'immuabilité
    • Chaînes immuables
    • • Constantes implicites
      • Surcharge de l'opérateur « + » et les StringBuffer
    • Les classes String et StringBuffer
    • Les Strings sont spéciales
  • Résumé
  • Exercises

• B: L'Interface Native Java [Java Native Interface] (JNI)
• • Appeler une méthode native
  • • Le générateur d'entête [ header file generator] : javah
    • Les conventions de nommage [name mangling]et les signatures de fonctions
    • Implémenter votre DLL
  • Accéder à des fonctions JNI : l'argument JNIEnv
  • Accéder à des chaînes Java
  • Passer et utiliser des objets Java
  • JNI et les exceptions Java
  • JNI et le threading
  • Utiliser une base de code préexistantes
  • Information complémentaire

• C : Conseils pour une programmation stylée en Java
• • Conception
  • Implémentation

• D : Ressources
• • Logicielles
  • Livres
  • • Analyse & conception
    • Python
    • La liste de mes livres