• Forums
  • Tutoriels
  • Magazine
  • FAQs
  • Blogs
  • Projets
  • Chat
  • Newsletter
  • Études
  • Emploi
  • Club
  • Contacts
 
  • Accueil Actualités IT Pro
  • ALM Cycle de vie du logiciel
    • ALM
    • UML
    • Merise
  • Java Plateforme et langage Java
    • Java
    • Spring
    • Dév. Web Java
    • Android
    • Eclipse
    • NetBeans
  • .NET Microsoft Framework .NET
    • Microsoft DotNET
    • Visual Studio
    • ASP.NET
    • C#
    • VB.NET
    • Windows Phone
    • Windows Azure
  • Dév. Web Développement Web et Webmarketing
    • Développement Web
    • AJAX
    • Apache
    • ASP
    • CSS
    • Flash / Flex
    • JavaScript
    • PHP
    • Ruby & Rails
    • Web sémantique
    • Webmarketing
    • (X)HTML
  • EDI Environnements de Développement Intégré
    • EDI
    • 4D
    • Delphi
    • Eclipse
    • LabVIEW
    • NetBeans
    • MATLAB
    • Visual Studio
    • WinDev
    • Visual Basic 6
    • Lazarus
    • Qt Creator
  • Langages Langages de programmation applicatifs
    • Langages
    • Assembleur
    • C
    • C++
    • C#
    • Objective C
    • Pascal
    • Perl
    • Python
    • Visual Basic 6
    • VB.NET
    • XML
    • Autres
  • SGBD Systèmes de Gestion de Bases de Données
    • SGBD & SQL
    • 4D
    • Access
    • DB2
    • Firebird
    • InterBase
    • MySQL
    • NoSQL
    • Oracle
    • PostgreSQL
    • SQL-Server
    • Sybase
  • Office Bureautique pour l'entreprise
    • Microsoft Office
    • Access
    • Excel
    • Word
    • Outlook
    • PowerPoint
    • SharePoint
    • Microsoft Project
  • Solutions d'entreprise Autres logiciels pour l'entreprise
    • Solutions d'entreprise
    • Business Intelligence
    • ERP / PGI
    • CRM
    • SAS
    • Cloud Computing
    • SAP
    • Microsoft BizTalk Server
  • Applications Applications logicielles
    • Applications
    • 2D - 3D - Jeux
    • OpenOffice & LibreOffice
    • Projets
  • Mobiles Logiciels et matériels mobiles
    • Mobiles
    • Android
    • iOS
    • Windows Phone
  • Systèmes Logiciels et matériels systèmes
    • Systèmes
    • Windows
    • Linux Professionnel
    • Sécurité
    • PC
    • Mac
    • Réseau
    • Green IT
    • Virtualisation
    • Systèmes Embarqués
 
  • Java
  • Spring
  • Dév. Web Java
  • Android
  • Eclipse
  • NetBeans
 
 
Facebook
Twitter
RSS
  • FORUMS JAVA
  • FAQs JAVA
  • TUTORIELS JAVA
  • JAVASEARCH
  • SOURCES
  • LIVRES
  • OUTILS, EDI & API
  • BLOG
  • DISCUSSIONS
  • TV

Penser en Java

2nde édition

Table des matièresPlier Déplier

  • Page 1
    • I. Préface
      • I-A. Préface à la 2e édition
        • I-A-1. Java 2
      • I-B. Le CD-ROM
  • Page 2
    • II. Avant-propos
      • II-A. Prérequis
      • II-B. Apprendre Java
      • II-C. Buts
      • II-D. Documentation en ligne
      • II-E. Les chapitres
      • II-F. Exercices
      • II-G. Le CD-ROM multimédia
      • II-H. Le Code source
        • II-H-1. Typographie et style de code
      • II-I. Les versions de Java
      • II-J. Seminars and mentoring
      • II-K. Errors
      • II-L. À propos de la conception de la couverture du livre
      • II-M. Remerciements
        • II-M-1. Collaborateurs Internet
  • Page 3
    • III. Introduction sur les « objets »
      • III-A. Les bienfaits de l'abstraction
      • III-B. Un objet dispose d'une interface
      • III-C. L'implémentation cachée
      • III-D. Réutilisation de l'implémentation
      • III-E. Héritage : réutilisation de l'interface
        • III-E-1. Les relations est-un vs est-comme-un
      • III-F. Polymorphisme : des objets interchangeables
        • III-F-1. Classes de base abstraites et interfaces
      • III-G. Environnement et durée de vie des objets
        • III-G-1. Collections et itérateurs
        • III-G-2. La hiérarchie de classes unique
        • III-G-3. Bibliothèques de collections et support pour l'utilisation aisée des collections
          • III-G-3-a. Transtypages descendants vs patrons génériques
        • III-G-4. Le dilemme du nettoyage : qui en est responsable ?
          • III-G-4-a. Ramasse-miettes vs efficacité et flexibilité
      • III-H. Traitement des exceptions : gérer les erreurs
      • III-I. Multithreading
      • III-J. Persistance
      • III-K. Java et l'Internet
        • III-K-1. Qu'est-ce que le Web ?
          • III-K-1-a. Le concept Client/Serveur
          • III-K-1-b. Le Web en tant que serveur géant
        • III-K-2. La programmation côté client
          • III-K-2-a. Les plug-ins
          • III-K-2-b. Les langages de script
          • III-K-2-c. Java
          • III-K-2-d. ActiveX
          • III-K-2-e. La sécurité
        • III-K-3. La programmation côté serveur
        • III-K-4. Une scène séparée : les applications
      • III-L. Analyse et conception
        • III-L-1. Phase 0 : Faire un plan
          • III-L-1-a. L'exposé de la mission
        • III-L-2. Phase 1 : Que construit-on ?
        • III-L-3. Phase 2 : Comment allons-nous le construire ?
          • III-L-3-a. Les cinq étapes de la conception d'un objet
          • III-L-3-b. Indications quant au développement des objets
        • Phase 3 : Construire le cœur du système
        • III-L-5. Phase 4 : Itérer sur les cas d'utilisation
        • III-L-6. Phase 5 : Évolution
        • III-L-7. Les plans sont payants
        • III-L-8. Commencer par écrire les tests
        • III-L-9. Programmation en binôme
      • III-M. Les raisons du succès de Java
        • III-M-1. Les systèmes sont plus faciles à exprimer et comprendre
        • III-M-2. Puissance maximale grâce aux bibliothèques
        • III-M-3. Traitement des erreurs
        • III-M-4. Mise en œuvre de gros projets
      • III-N. Stratégies de transition
        • III-N-1. Règles de base
          • III-N-1-a. Cours
          • III-N-1-b. Projet à faible risque
          • III-N-1-c. S'inspirer de bonnes conceptions
          • III-N-1-d. Utiliser les bibliothèques de classes existantes
          • III-N-1-e. Ne pas traduire du code existant en Java
        • III-N-2. Les obstacles au niveau du management
          • III-N-2-a. Coûts de mise en œuvre
          • III-N-2-b. Problèmes de performances
          • III-N-2-c. Erreurs classiques de conception
      • III-O. Résumé
  • Page 4
    • IV. Tout est « objet »
      • IV-A. Les objets sont manipulés avec des références
      • IV-B. Vous devez créer tous les objets
        • IV-B-1. Où réside la mémoire ?
        • IV-B-2. Cas particulier : les types primitifs
          • IV-B-2-a. Nombres de grande précision
        • IV-B-3. Tableaux en Java
      • IV-C. Vous n'avez jamais besoin de détruire un objet
        • IV-C-1. Notion de portée
        • IV-C-2. Portée des objets
          • IV-C-2-a. Valeurs par défaut des membres primitifs
      • IV-D. Créer de nouveaux types de données : class
      • IV-E. Méthodes, paramètres et valeurs de retour
        • IV-E-1. La liste de paramètres
      • IV-F. Construction d'un programme Java
        • IV-F-1. Visibilité des noms
        • IV-F-2. Utilisation d'autres composantes
        • IV-F-3. Le mot-clef static
      • IV-G. Votre premier programme Java
        • IV-G-1. Compilation et exécution
      • IV-H. Commentaires et documentation intégrée
        • IV-H-1. Commentaires de documentation
        • IV-H-2. Syntaxe
        • IV-H-3. HTML intégré
        • IV-H-4. @see : faire référence aux autres classes
        • IV-H-5. Class documentation tags
          • IV-H-5-a. @version
          • IV-H-5-b. @author
          • IV-H-5-c. @since
        • IV-H-6. Les onglets de documentation de variables
        • IV-H-7. Les onglets de documentation de méthodes
          • IV-H-7-a. @param
          • IV-H-7-b. @return
          • IV-H-7-c. @throws
          • IV-H-7-d. @deprecated
        • IV-H-8. Exemple de documentation
      • IV-I. Style de programmation
      • IV-J. Exercices
  • Page 5
    • V. Contrôle du flux du programme
      • V-A. Utilisation des opérateurs Java
        • V-A-1. Priorité
        • V-A-2. L'affectation
          • V-A-2-a. L'aliasing pendant l'appel des méthodes
        • V-A-3. Les opérateurs mathématiques
          • V-A-3-a. Les opérateurs unaires (à un opérande) moins et plus
        • V-A-4. Incrémentation et décrémentation automatique
        • V-A-5. Les opérateurs relationnels
          • V-A-5-a. Tester l'équivalence des objets
        • V-A-6. Les opérateurs logiques
          • V-A-6-a. « Court-circuit  »
        • V-A-7. Les opérateurs bit à bit
        • V-A-8. Les opérateurs de décalage
        • V-A-9. L'opérateur virgule
        • V-A-10. L'opérateur + pour les String
        • V-A-11. Les pièges classiques dans l'utilisation des opérateurs
        • V-A-12. Les opérateurs de transtypage
          • V-A-12-a. Les littéraux
          • V-A-12-b. La promotion
        • V-A-13. Java n'a pas de « sizeof »
        • V-A-14. Retour sur la priorité des opérateurs
        • V-A-15. Résumé sur les opérateurs
      • V-B. Le contrôle d'exécution
        • V-B-1. true et false
        • V-B-2. if-else
          • V-B-2-a. return
        • V-B-3. Itération
        • V-B-4. do-while
        • V-B-5. for
          • V-B-5-a. L'opérateur virgule
        • V-B-6. break et continue
          • V-B-6-a. L'infâme « goto »
        • V-B-7. switch
          • V-B-7-a. Détails de calcul :
      • V-C. Résumé
      • V-D. Exercices
  • Page 6
    • VI. Initialisation et nettoyage
      • VI-A. Garantie d'initialisation grâce au constructeur
      • VI-B. Surcharge de méthodes
        • VI-B-1. Différencier les méthodes surchargées
        • VI-B-2. Surcharge avec types de base
        • VI-B-3. Surcharge sur la valeur de retour
        • VI-B-4. Constructeurs par défaut
        • VI-B-5. Le mot-clef this
          • VI-B-5-a. Appeler un constructeur depuis un autre constructeur
          • VI-B-5-b. La signification de static
      • VI-C. Nettoyage : finalisation et ramasse-miettes
        • VI-C-1. À quoi sert finalize( ) ?
        • VI-C-2. Le nettoyage est impératif
        • VI-C-3. La «death condition»
        • VI-C-4. Comment fonctionne un ramasse-miettes ?
      • VI-D. Initialisation de membre
        • VI-D-1. Spécifier une initialisation
        • VI-D-2. Initialisation par constructeur
          • VI-D-2-a. Ordre d'initialisation
          • VI-D-2-b. Initialisation de données statiques
          • VI-D-2-c. Initialisation statique explicite
          • VI-D-2-d. Initialisation d'instance non statique
      • VI-E. Initialisation des tableaux
        • VI-E-1. Tableaux multidimensionnels
      • VI-F. Résumé
      • VI-G. Exercices
  • Page 7
    • VII. Cacher l'implémentation
      • VII-A. package : l'unité de bibliothèque
        • VII-A-1. Créer des noms de packages uniques
          • VII-A-1-a. Collisions
        • VII-A-2. Une bibliothèque d'outils personnalisée
        • VII-A-3. Avertissement sur les packages
      • VII-B. Les spécificateurs d'accès Java
        • VII-B-1. « Friendly »
        • public : accès d'interface
          • VII-B-2-a. Le package par défaut
        • VII-B-3. private : ne pas toucher !
        • VII-B-4. protected : « sorte d'amical »
      • VII-C. L'accès aux classes
      • VII-D. Résumé
      • VII-E. Exercices
  • Page 8
    • VIII. Réutiliser les classes
      • VIII-A. Syntaxe de composition
      • VIII-B. La syntaxe de l'héritage
        • VIII-B-1. Initialiser la classe de base
          • VIII-B-1-a. Constructeurs avec paramètres
      • VIII-C. Combiner composition et héritage.
        • VIII-C-1. Garantir un nettoyage propre
          • VIII-C-1-a. L'ordre du ramasse-miettes
        • VIII-C-2. Cacher les noms
      • VIII-D. Choisir la composition à la place de l'héritage
      • VIII-E. protected
      • VIII-F. Développement incrémental
      • VIII-G. Transtypage ascendant
        • VIII-G-1. Pourquoi le transtypage ascendant ? 
          • VIII-G-1-a. Composition à la place de l'héritage revisité
      • VIII-H. Le mot-clef final
        • VIII-H-1. Données final
          • VIII-H-1-a. Finals sans initialisation
          • VIII-H-1-b. Arguments final
        • VIII-H-2. Méthodes final
          • VIII-H-2-a. final et private
        • VIII-H-3. Classes final
        • VIII-H-4. Attention finale
      • VIII-I. Initialisation et chargement de classes
        • VIII-I-1. Initialisation avec héritage
      • VIII-J. Résumé
      • VIII-K. Exercices
  • Page 9
    • IX. Polymorphisme
      • IX-A. Upcasting
        • IX-A-1. Pourquoi utiliser l'upcast ?
      • IX-B. The twist
        • IX-B-1. Liaison de l'appel de méthode
        • IX-B-2. Produire le bon comportement
        • IX-B-3. Extensibilité
      • IX-C. Redéfinition et surcharge
      • IX-D. Classes et méthodes abstraites
      • IX-E. Constructeurs et polymorphisme
        • IX-E-1. Ordre d'appel des constructeurs
        • IX-E-2. La méthode finalize() et l'héritage
        • IX-E-3. Comportement des méthodes polymorphes dans les constructeurs
      • IX-F. Concevoir avec l'héritage
        • IX-F-1. Héritage pur contre extension
        • IX-F-2. Downcasting et identification du type à l'exécution
      • IX-G. Résumé
      • IX-H. Exercices
  • Page 10
    • X. Interfaces et classes internes
      • X-A. Interfaces
        • X-A-1. « Héritage multiple » en Java
          • X-A-1-a. Combinaison d'interfaces et collisions de noms 
        • X-A-2. Étendre une interface avec l'héritage
        • X-A-3. Groupes de constantes
        • X-A-4. Initialisation des données membres des interfaces
        • X-A-5. Interfaces imbriquées
      • X-B. Classes internes
        • X-B-1. Classes internes et transtypage ascendant
        • X-B-2. Classes internes définies dans des méthodes et autres portées
        • X-B-3. Classes internes anonymes
        • X-B-4. Lien vers la classe externe
        • X-B-5. Classes internes static
        • X-B-6. Se référer à l'objet de la classe externe
        • X-B-7. Classe interne à plusieurs niveaux d'imbrication
        • X-B-8. Dériver une classe interne
        • X-B-9. Les classes internes peuvent-elles être redéfinies ?
        • X-B-10. Identifiants des classes internes
        • X-B-11. Raison d'être des classes internes
          • X-B-11-a. Fermetures & callbacks
        • X-B-12. Classes internes & structures de contrôle
      • X-C. Résumé
      • X-D. Exercices
  • Page 11
    • XI. Stockage des objets
      • XI-A. Les tableaux
        • XI-A-1. Les tableaux sont des objets
          • XI-A-1-a. Conteneurs de scalaires
        • XI-A-2. Renvoyer un tableau
        • XI-A-3. La classe Arrays
        • XI-A-4. Remplir un tableau
        • XI-A-5. Copier un tableau
        • XI-A-6. Comparer des tableaux
        • XI-A-7. Comparaison d'éléments de tableau
        • XI-A-8. Trier un tableau
        • XI-A-9. Effectuer une recherche sur un tableau trié
        • XI-A-10. Résumé sur les tableaux
      • XI-B. Introduction sur les  conteneurs
        • XI-B-1. Imprimer les conteneurs
        • XI-B-2. Remplir les conteneurs
      • XI-C. L'inconvénient des conteneurs : le type est inconnu
        • XI-C-1. Quelquefois ça marche quand même
        • XI-C-2. Créer une ArrayList consciente du type
          • XI-C-2-a. Types paramétrés
          • XI-C-2-b. Récursion indésirable
      • XI-D. Itérateurs
      • XI-E. Classification des conteneurs
      • XI-F. Fonctionnalités des Collections
      • XI-G. Fonctionnalités des Lists
        • XI-G-1. Réaliser une pile à partir d'une LinkedList
        • XI-G-2. Réaliser une file à partir d'une LinkedList
      • XI-H. Fonctionnalités des Sets
        • XI-H-1. Sets triés : les SortedSets
      • XI-I. Fonctionnalités des Maps
        • XI-I-1. Maps triées : les SortedMaps
        • XI-I-2. Hachage et codes de hachage
          • XI-I-2-a. Comprendre hashCode()
        • XI-I-3. Redéfinir hashCode()
      • XI-J. Stocker des références
        • XI-J-1. Le WeakHashMap
      • XI-K. Les itérateurs revisités
      • XI-L. Choisir une implémentation
        • XI-L-1. Choisir entre les Lists
        • XI-L-2. Choisir entre les Sets
        • XI-L-3. Choisir la bonne Map
      • XI-M. Trier et rechercher dans les Lists
      • XI-N. Utilitaires
        • XI-N-1. Rendre une Collection ou une Map non modifiable
        • XI-N-2. Synchroniser une Collection ou une Map
          • XI-N-2-a. Échec rapide
      • XI-O. Les conteneurs Java 1.0 / 1.1
        • XI-O-1. Vector & Enumeration
        • XI-O-2. Hashtable
        • XI-O-3. Stack
        • XI-O-4. BitSet
      • XI-P. Résumé
  • Page 12
    • XII. Gestion des erreurs avec les exceptions
      • XII-A. Les exceptions de base
      • XII-B. Attraper une exception
        • XII-B-1. Le bloc try
        • XII-B-2. Les gestionnaires d'exceptions
          • XII-B-2-a. Terminaison contre Restauration
        • XII-B-3. Créez vos propres exceptions
      • XII-C. Spécifier des exceptions
        • XII-C-1. Attraper n'importe quelle exception
        • XII-C-2. Relancer une exception
      • XII-D. Les exceptions Java standard
        • XII-D-1. Le cas particulier RuntimeException
      • XII-E. Faire le ménage avec finally
        • XII-E-1. À quoi sert le finally ?
        • XII-E-2. Le défaut : l'exception perdue
      • XII-F. Restriction d'exceptions
      • XII-G. Les constructeurs
      • XII-H. Indication d'exception
        • XII-H-1. Recommandations pour les exceptions
      • XII-I. Résumé
      • XII-J. Exercices
  • Page 13
    • XIII. Le système d'E/S de Java
      • XIII-A. La classe File
        • XIII-A-1. Lister un répertoire
          • XIII-A-1-a. Les classes internes anonymes
        • XIII-A-2. Vérification et création de répertoires
      • XIII-B. Entrée et sortie
        • XIII-B-1. Les types d'InputStream
        • XIII-B-2. Les types d'OutputStream
      • XIII-C. Ajouter des attributs et des interfaces utiles
        • XIII-C-1. Lire depuis un InputStream avec FilterInputStream
        • XIII-C-2. Écrire vers un OutputStream avec FilterOutputStream
      • XIII-D. Lecteurs et écrivains [ Loader s & Writers ]
        • XIII-D-1. Les sources et les réceptacles de données
        • XIII-D-2. Modifier le comportement du flux
        • XIII-D-3. Les classes inchangées
      • XIII-E. Et bien sûr : l'accès aléatoire aux fichiers (RandomAccessFile)
      • XIII-F. L'usage typique des flux d'E/S
        • XIII-F-1. Flux d'Entrée
          • XIII-F-1-a. 1. Entrée en tampon du fichier [Buffered input file]
          • XIII-F-1-b. 2. Entrée depuis la mémoire
          • XIII-F-1-c. 3. Entrée de mémoire formatée
        • XIII-F-2. Flux de sortie
          • XIII-F-2-a. 5. Stocker et récupérer des données
          • XIII-F-2-b. 6. Accès aléatoire en lecture et écriture aux fichiers
        • XIII-F-3. Un bogue ?
        • XIII-F-4. Flux Piped
      • XIII-G. Standard E/S
        • XIII-G-1. Lire depuis une entrée standard
        • XIII-G-2. Modifier System.out en un PrintWriter
        • XIII-G-3. Réorienter l'E/S standard
      • XIII-H. Compression
        • XIII-H-1. Compression simple avec GZIP
        • XIII-H-2. ARchives Java (JAR)
      • XIII-I. La sérialisation objet
        • XIII-I-1. Trouver la classe
        • XIII-I-2. Contrôler la sérialisation
          • XIII-I-2-a. Le mot-clef « transient »
          • XIII-I-2-b. Une alternative à Externalizable
          • XIII-I-2-c. Versioning
        • XIII-I-3. Utiliser la persistance
      • XIII-J. Tokenizer l'entrée
        • XIII-J-1. StreamTokenizer
        • XIII-J-2. StringTokenizer
        • XIII-J-3. Vérifier le style de capitalisation
      • XIII-K. Résumé
      • XIII-L. Exercices
  • Page 14
    • XIV. Identification dynamique de type
      • XIV-A. Le besoin de RTTI
        • XIV-A-1. L'objet Class
          • XIV-A-1-a. Les littéraux Class
        • XIV-A-2. Vérifier avant de transtyper
          • XIV-A-2-a. Utiliser les littéraux de classe
          • XIV-A-2-b. Un instanceof dynamique
          • XIV-A-2-c. instanceof vs. équivalence de classe
      • XIV-B. La syntaxe du RTTI
      • XIV-C. Réflexion : information de classe dynamique 
        • XIV-C-1. Un extracteur de méthodes de classe
      • XIV-D. Résumé
      • XIV-E. Exercices
  • Page 15
    • XV. Création de fenêtres et d'applets
      • XV-A. L'applet de base
        • XV-A-1. Les restrictions des applets
        • Les avantages d'une applet
        • XV-A-3. Les squelettes d'applications
        • XV-A-4. Exécuter des applets dans un navigateur Web
        • XV-A-5. Utilisation de Appletviewer
        • XV-A-6. Tester les applets
      • XV-B. Exécuter des applets depuis la ligne de commande
        • XV-B-1. Un squelette d'affichage
        • XV-B-2. Utilisation de l'Explorateur Windows
      • XV-C. Création d'un bouton
      • XV-D. Capture d'un événement
      • XV-E. Zones de texte
      • XV-F. Contrôle de la disposition
        • XV-F-1. BorderLayout
        • XV-F-2. FlowLayout
        • XV-F-3. GridLayout
        • XV-F-4. GridBagLayout
        • XV-F-5. Positionnement absolu
        • XV-F-6. BoxLayout
        • XV-F-7. La meilleure approche ?
      • XV-G. Le modèle d'événements de Swing
        • XV-G-1. Événements et types de listeners
          • XV-G-1-a. Utilisation de listener adapters pour simplifier
        • XV-G-2. Surveiller plusieurs événements
      • XV-H. Un catalogue de composants Swing
        • XV-H-1. Boutons
          • XV-H-1-a. Groupes de boutons
        • XV-H-2. Icônes
        • XV-H-3. Infobulles [Tooltips]
        • XV-H-4. Champs de texte [Text Fields]
        • XV-H-5. Bordures
        • XV-H-6. JScrollPanes
        • XV-H-7. Un miniéditeur
        • XV-H-8. Boîtes à cocher [Check boxes]
        • XV-H-9. Boutons radio
        • XV-H-10. Boîtes combo (listes à ouverture vers le bas) [combo boxes (drop-down lists)]
        • XV-H-11. Listes [List boxes]
        • XV-H-12. Panneaux à tabulations [Tabbed panes]
        • XV-H-13. Boîtes de messages
        • XV-H-14. Menus
        • XV-H-15. Menus pop-up
        • XV-H-16. Dessiner
        • XV-H-17. Boîtes de dialogue
        • XV-H-18. Dialogues pour les fichiers [File dialogs]
        • XV-H-19. HTML sur des composants Swing
        • XV-H-20. Curseurs [sliders] et barres de progression [progress bars]
        • XV-H-21. Arbres [Trees]
        • XV-H-22. Tables
        • XV-H-23. Sélection de l'aspect de l'interface [Look & Feel]
        • XV-H-24. Le presse-papier [clipboard]
      • XV-I. Empaquetage d'une applet dans un fichier JAR
      • XV-J. Techniques de programmation
        • XV-J-1. Lier des événements dynamiquement
        • XV-J-2. Séparation entre la logique applicative [business logic] et la logique de l'interface utilisateur [UI logic]
        • XV-J-3. Une forme canonique
        • XV-J-4. Qu'est-ce qu'un Bean ?
        • XV-J-5. Extraction des informations sur les Beans [BeanInfo] à l'aide de l'introspecteur [Introspector]
        • XV-J-6. Un Bean plus complexe
        • XV-J-7. Empaquetage d'un Bean
        • XV-J-8. Un support des Beans plus sophistiqué
        • Davantage sur les Beans
      • XV-K. Résumé
      • XV-L. Exercices
  • Page 16
    • XVI. Les threads multiples
      • XVI-A. Interfaces utilisateur dynamiques [Responsive user interfaces]
        • XVI-A-1. Héritage de Thread
        • XVI-A-2. Threading pour une interface réactive
        • XVI-A-3. Créer plusieurs threads
        • XVI-A-4. Threads démons
      • XVI-B. Partager des ressources limitées
        • XVI-B-1. Comment Java partage les ressources
          • XVI-B-1-a. Efficacité de la synchronisation
        • XVI-B-2. JavaBeans revisités
      • XVI-C. Blocage [Blocking]
        • Passer à l'état bloqué
          • XVI-C-1-a. Dormant (Sleeping)
          • XVI-C-1-b. Suspension et reprise
          • XVI-C-1-c. Attendre et notifier
          • XVI-C-1-d. Bloqué sur I/O
          • XVI-C-1-e. Tester
        • XVI-C-2. Interblocage [Deadlock]
          • XVI-C-2-a. La dépréciation de stop(), suspend(), resume(), et destroy() en Java 2
        • XVI-C-3. Lire et changer les priorités
        • XVI-C-4. Les groupes de threads
          • XVI-C-4-a. Contrôler les groupes de threads
      • XVI-D. Runnable revisité
        • XVI-D-1. Trop de threads
      • XVI-E. Résumé
      • XVI-F. Exercices
  • Page 17
    • XVII. Informatique distribuée
      • XVII-A. La programmation réseau
        • XVII-A-1. Identifier une machine
          • XVII-A-1-a. Serveurs et clients
          • XVII-A-1-b. Tester les programmes hors réseau
          • XVII-A-1-c. Les Ports  : un emplacement unique dans la machine
        • XVII-A-2. Les sockets
          • XVII-A-2-a. Un serveur et un client vraiment simples
        • XVII-A-3. Servir des clients multiples
        • XVII-A-4. Les Datagrammes
        • XVII-A-5. Utiliser des URL depuis un applet
          • XVII-A-5-a. Lire un fichier depuis un serveur
        • XVII-A-6. En savoir plus sur le travail en réseau
      • XVII-B. Se connecter aux bases de données : Java Database Connectivity (JDBC)
        • XVII-B-1. Faire fonctionner l'exemple
          • XVII-B-1-a. Étape 1 : Trouver le Driver JDBC
          • XVII-B-1-b. Étape 2 : Configurer la base de données
          • XVII-B-1-c. Étape 3 : Tester la configuration
          • XVII-B-1-d. Étape 4 : Générer votre requête SQL
          • XVII-B-1-e. Étape 5 : Modifier et insérer votre requête
        • XVII-B-2. Une version GUI du programme de recherche
        • XVII-B-3. Pourquoi l'API JDBC paraît si complexe
        • XVII-B-4. Un exemple plus sophistiqué
      • XVII-C. Les servlets
        • XVII-C-1. Le servlet de base
        • XVII-C-2. Les servlets et le multithreading
        • XVII-C-3. Gérer des sessions avec les servlets
          • XVII-C-3-a. La classe Cookie
          • XVII-C-3-b. La classe Session
        • XVII-C-4. Faire fonctionner les exemples de servlet
      • XVII-D. Les Pages Java Serveur - Java Server Pages
        • XVII-D-1. Les objets implicites
        • XVII-D-2. Les directives JSP
        • XVII-D-3. Les éléments de scripting JSP
        • XVII-D-4. Extraire des champs et des valeurs
        • XVII-D-5. Attributs et visibilité d'une page JSP
        • XVII-D-6. Manipuler les sessions en JSP
        • XVII-D-7. Créer et modifier des cookies
        • XVII-D-8. Résumé sur les JSP
      • XVII-E. RMI (Remote Method Invocation) : Invocation de méthodes distantes
        • XVII-E-1. Interfaces Remote
        • XVII-E-2. Implémenter l'interface distante
          • Mise en place du registre
        • XVII-E-3. Utilisation de l'objet distant
      • XVII-F. Introduction à CORBA
        • XVII-F-1. Principes de base de CORBA
          • XVII-F-1-a. CORBA Interface Definition Language (IDL - Langage de Définition d'Interface)
          • XVII-F-1-b. Le service de nommage (naming service)
        • XVII-F-2. Un exemple
          • XVII-F-2-a. Écrire le source IDL
          • XVII-F-2-b. Création des stubs et des skeletons
          • XVII-F-2-c. Implémentation du serveur et du client
          • XVII-F-2-d. Quelques services CORBA
          • XVII-F-2-e. Activation du processus du service de nommage
          • XVII-F-2-f. Activation du serveur et du client
        • XVII-F-3. Les applets Java et CORBA
        • XVII-F-4. CORBA face à RMI
      • XVII-G. Enterprise Java Beans
        • XVII-G-1. JavaBeans contre EJB
        • XVII-G-2. Que définit la spécification des EJB ?
          • XVII-G-2-a. Les rôles
          • XVII-G-2-b. Composants EJB
            • XVII-G-2-b-i. Conteneur d'EJB
            • XVII-G-2-b-ii. Serveur EJB
            • XVII-G-2-b-iii. Java Naming and Directory Interface (JNDI)
            • XVII-G-2-b-iv. Java Transaction API / Java Transaction Service (JTA/JTS)
            • XVII-G-2-b-v. CORBA et RMI/IIOP
        • XVII-G-3. Qu'est-ce qui compose un composant EJB ?
          • XVII-G-3-a. Enterprise Bean
          • XVII-G-3-b. Interface Home
          • XVII-G-3-c. Interface Remote
          • XVII-G-3-d. Descripteur de déploiement
          • Fichier EJB-Jar
        • XVII-G-4. Comment travaille un EJB ?
        • XVII-G-5. Types d'EJB
          • XVII-G-5-a. Session Beans
            • XVII-G-5-a-i. Les Session Beans non persistants
            • XVII-G-5-a-ii. Les Session Beans persistants
          • XVII-G-5-b. Entity Beans
            • XVII-G-5-b-i. Gestion de la persistance par le Bean (BMP - Bean Managed Persistence)
        • XVII-G-6. Développer un Enterprise Java Bean
        • XVII-G-7. En résumé
      • XVII-H. Jini : services distribués
        • XVII-H-1. Contexte de Jini
        • XVII-H-2. Qu'est-ce que Jini ?
        • XVII-H-3. Comment fonctionne Jini
        • XVII-H-4. Le processus de découverte
        • XVII-H-5. Le processus de recherche
        • XVII-H-6. Séparation de l'interface et de l'implémentation
        • XVII-H-7. Abstraction des systèmes distribués
      • XVII-I. Résumé
      • XVII-J. Exercices
  • Page 18
    • XVIII. Passage et retour d'objets
      • XVIII-A. Passage de références
        • XVIII-A-1. Aliasing
      • XVIII-B. Création de copies locales
        • XVIII-B-1. Passage par valeur
        • XVIII-B-2. Clonage d'objets
        • XVIII-B-3. Rendre une classe cloneable
          • XVIII-B-3-a. Utilisation d'une astuce avec protected
          • XVIII-B-3-b. Implémenter l'interface Cloneable
        • XVIII-B-4. Le mécanisme de Object.clone( )
        • XVIII-B-5. Cloner un objet composé
        • XVIII-B-6. Copie profonde d'une ArrayList
        • XVIII-B-7. Supporter le clonage plus bas dans la hiérarchie
        • XVIII-B-8. Pourquoi cet étrange design ?
      • XVIII-C. Contrôler la clonabilité
        • XVIII-C-1. Le constructeur de copie
          • XVIII-C-1-a. Pourquoi cela fonctionne-t-il en C++ et pas en Java ?
      • XVIII-D. Classes en lecture seule
        • XVIII-D-1. Créer des classes en lecture seule
        • XVIII-D-2. L'inconvénient de l'immuabilité
      • XVIII-E. Chaînes immuables
      • XVIII-F. Constantes implicites
      • XVIII-G. Surcharge de l'opérateur « + » et les StringBuffer
      • XVIII-H. Les classes String et StringBuffer
      • XVIII-I. Les String sont spéciales
      • XVIII-J. Résumé
      • XVIII-K. Exercices
  • Page 19
    • XIX. L'Interface Java Natif (JNI)
      • XIX-A. Appeler une méthode native
        • XIX-A-1. Le générateur d'entête [ header file generator] : javah
        • XIX-A-2. Les conventions de nommage [name mangling] et les signatures de fonctions
        • XIX-A-3. Implémenter votre DLL
      • XIX-B. Accéder à des fonctions JNI : l'argument JNIEnv
      • XIX-C. Accéder à des chaînes Java
      • XIX-D. Passer et utiliser des objets Java
      • XIX-E. JNI et les exceptions Java
      • XIX-F. JNI et le threading
      • XIX-G. Utiliser une base de code préexistantes
      • XIX-H. Information complémentaire
  • Page 20
    • XX. Conseils pour une programmation stylée en java
      • XX-A. Conception
  • Page 21
    • XXI. Ressources
      • XXI-A. Logicielles
      • XXI-B. Livres
        • XXI-B-1. Analyse et conception
        • XXI-B-2. Python
        • XXI-B-3. La liste de mes livres

Ce livre a été écrit par Bruce Eckel groupe de traduction
télécharger la version française (PDF) |  Commander le livre en version anglaise (amazon) |  télécharger la version anglaise

Lire l'article.

Article lu   fois.

L'auteur

Bruce Eckel Site personnel

L´article

Publié le 1er juin 2012 - Mis à jour le 25 avril 2013 

Version en ligne

Version PDF Version hors-ligne

ePub , Azw et Mobi

Lire l'article

Liens sociaux

Viadeo Twitter Google Bookmarks ! Facebook Digg del.icio.us MySpace Yahoo MyWeb Blinklist Netvouz Reddit Simpy StumbleUpon Bookmarks Windows Live Favorites 

suivant
  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2013 Bruce Eckel. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. Cette page est déposée.

 
 

Responsables bénévoles de la rubrique Java : mlny84 - Mickael Baron -

 
 
Developpez.com

Nous contacter

Participez

Informations légales

 
Services

Forum Java

Blogs

Hébergement

 
Partenaires

Hébergement Web

Copyright © 2000-2013 - www.developpez.com