Développons en Java - Sommaire complet

*Développons en Java* v 2.40 Copyright (C) 1999-2023 Jean-Michel DOUDOUX.
						Rechercher dans DEJ avec Google

Développons en Java


Préambule

   A propos de ce document
   Remerciements
   Notes de licence
   Marques déposées
   Historique des versions

Partie 1 : Les bases du langage Java
  Cette première partie est chargée de présenter les bases du langage java

1. Présentation de Java
  introduit le langage Java en présentant les différentes éditions et versions du JDK, les caractéristiques du langage et décrit l'installation du JDK
  1.1. Les caractéristiques
  1.2. Les logos de Java
  1.3. Un rapide historique de Java
  1.4. Les différentes éditions et versions de Java
  1.5. Un rapide tour d'horizon des API et de quelques outils
  1.6. Les différences entre Java et JavaScript
  1.7. L'installation du JDK

2. Les notions et techniques de base en Java
  présente rapidement quelques notions de base et comment compiler et exécuter une application
  2.1. Les concepts de base
  2.2. L'exécution d'une applet
  2.3. L'utilisation de fonctionnalités non standards
  2.4. Les builds early access

3. La syntaxe et les éléments de bases de Java
  explore les éléments du langage d'un point de vue syntaxique
  3.1. Les règles de base
  3.2. Les mots réservés du langage Java
  3.3. Les identifiants
  3.4. Les commentaires
  3.5. La déclaration et l'utilisation de variables
  3.6. La déclaration de variables locales avec l'inférence de type
  3.7. Les opérations arithmétiques
  3.8. La priorité des opérateurs
  3.9. Les structures de contrôles
  3.10. Les évolutions de l'instruction switch dans Java 14
  3.11. Les tableaux
  3.12. Les conversions de types
  3.13. L'autoboxing et l'unboxing

4. La programmation orientée objet
  explore comment Java permet d'utiliser la programmation orientée objet
  4.1. Le concept de classe
  4.2. Les objets
  4.3. Les modificateurs d'accès
  4.4. Les propriétés ou attributs
  4.5. Les méthodes
  4.6. L'héritage
  4.7. Les packages
  4.8. Les classes internes
  4.9. Les types scellés
  4.10. La gestion dynamique des objets

5. Les génériques (generics)
  détaille la définition et l'utilisation de types génériques
  5.1. Le besoin des génériques
  5.2. La définition des concepts
  5.3. L'utilisation de types génériques
  5.4. La définition de types génériques
  5.5. La pollution du heap (Heap Pollution)
  5.6. La mise en oeuvre des génériques
  5.7. Les méthodes et les constructeurs génériques
  5.8. Les paramètres de type bornés (bounded type parameters)
  5.9. Les paramètres de type avec wildcard
  5.10. Les bornes multiples (Multiple Bounds) avec l'intersection de types
  5.11. L'effacement de type (type erasure)
  5.12. La différence entre l'utilisation d'un argument de type et un wildcard
  5.13. Les conséquences et les effets de bord de l'effacement de type
  5.14. Les restrictions dans l'utilisation des génériques

6. Les chaînes de caractères
  détaille l'utilisation des chaînes de caractères
  6.1. Les chaînes de caractères littérales
  6.2. La classe java.lang.String
  6.3. La création d'un objet de type String
  6.4. Les opérations sur les chaînes de caractères
  6.5. La conversion de et vers une chaîne de caractères
  6.6. La concaténation de chaînes de caractères
  6.7. La classe StringTokenizer
  6.8. Les chaînes de caractères et la sécurité
  6.9. Le stockage en mémoire
  6.10. Les blocs de texte (Text Blocks)

7. Les packages de bases
  propose une présentation rapide des principales API fournies avec le JDK
  7.1. Les packages selon la version du JDK
  7.2. Le package java.lang
  7.3. La présentation rapide du package awt java
  7.4. La présentation rapide du package java.io
  7.5. Le package java.util
  7.6. La présentation rapide du package java.net
  7.7. La présentation rapide du package java.applet

8. Les fonctions mathématiques
  indique comment utiliser les fonctions mathématiques
  8.1. Les variables de classe
  8.2. Les fonctions trigonométriques
  8.3. Les fonctions de comparaisons
  8.4. Les arrondis
  8.5. La méthode IEEEremainder(double, double)
  8.6. Les Exponentielles et puissances
  8.7. La génération de nombres aléatoires
  8.8. La classe BigDecimal
  8.9. La précision des calculs en virgule flottante

9. La gestion des exceptions
  explore la faculté qu'a Java de traiter et gérer les anomalies qui surviennent lors de l'exécution du code
  9.1. Les mots clés try, catch et finally
  9.2. La classe Throwable
  9.3. Les classes Exception, RunTimeException et Error
  9.4. Les exceptions personnalisées
  9.5. Les exceptions chaînées
  9.6. L'utilisation des exceptions
  9.7. L'instruction try-with-resources
  9.8. Des types plus précis lorsqu'une exception est relevée dans une clause catch
  9.9. Multiples exceptions dans une clause catch

10. Les énumérations (type enum)
  détaille les nouvelles fonctionnalités du langage de la version 1.5
  10.1. Les énumérations locales

11. Les annotations
  présente les annotations qui sont des métadonnées insérées dans le code source et leurs mises en oeuvre.
  11.1. La présentation des annotations
  11.2. La mise en oeuvre des annotations
  11.3. L'utilisation des annotations
  11.4. Les annotations standard
  11.5. Les annotations communes (Common Annotations)
  11.6. Les annotations personnalisées
  11.7. L'exploitation des annotations
  11.8. L'API Pluggable Annotation Processing
  11.9. Les ressources relatives aux annotations

12. Les expressions lambda
  détaille l'utilisation des expressions lambda et des références de méthodes et constructeurs.
  12.1. L'historique des lambdas pour Java
  12.2. Les expressions lambda
  12.3. Les références de méthodes
  12.4. Les interfaces fonctionnelles

13. Les records
  décrit la déclaration et l'utilisation de classes records
  13.1. L'introduction aux records
  13.2. La définition d'un record
  13.3. La mise en oeuvre des records

Partie 2 : Les API de base
  Le JDK fournit un certain nombres d'API de base

14. Les collections
  propose une revue des classes fournies par le JDK pour gérer des ensembles d'objets
  14.1. Présentation du framework collection
  14.2. Les interfaces des collections
  14.3. Les collections de type List : les listes
  14.4. Les collections de type Set : les ensembles
  14.5. Les collections de type Map : les associations de type clé/valeur
  14.6. Les collections de type Queue : les files
  14.7. Le tri des collections
  14.8. Les algorithmes
  14.9. Les exceptions du framework

15. Les flux d'entrée/sortie
  explore les classes utiles à la mise en oeuvre d'un des mécanismes de base pour échanger des données
  15.1. La présentation des flux
  15.2. Les classes de gestion des flux
  15.3. Les flux de caractères
  15.4. Les flux d'octets
  15.5. La classe File
  15.6. Les fichiers à accès direct
  15.7. La classe java.io.Console

16. NIO 2
  détaille l'API FileSystem qui facilite l'utilisation de systèmes de fichiers
  16.1. Les entrées/sorties avec Java
  16.2. Les principales classes et interfaces
  16.3. L'interface Path
  16.4. Glob
  16.5. La classe Files
  16.6. Le parcours du contenu de répertoires
  16.7. L'utilisation de systèmes de gestion de fichiers
  16.8. La lecture et l'écriture dans un fichier
  16.9. Les liens et les liens symboliques
  16.10. La gestion des attributs
  16.11. La gestion des unités de stockages
  16.12. Les notifications de changements dans un répertoire
  16.13. La gestion des erreurs et la libération des ressources
  16.14. L'interopérabilité avec le code existant

17. La sérialisation
  ce procédé offre un mécanisme standard pour transformer l'état d'un objet en un flux de données qui peut être rendu persistant ou échangé sur le réseau pour permettre de recréer un objet possédant le même état.
  17.1. La sérialisation standard
  17.2. La documentation d'une classe sérialisable
  17.3. La sérialisation et la sécurité
  17.4. La sérialisation en XML

18. L'interaction avec le réseau
  propose un aperçu des API fournies par Java pour utiliser les fonctionnalités du réseau dans les applications
  18.1. L'introduction aux concepts liés au réseau
  18.2. Les adresses internet
  18.3. L'accès aux ressources avec une URL
  18.4. L'utilisation du protocole TCP
  18.5. L'utilisation du protocole UDP
  18.6. Les exceptions liées au réseau
  18.7. Les interfaces de connexions au réseau

19. L'internationalisation
  traite d'une façon pratique de la possibilité d'internationaliser une application
  19.1. Les objets de type Locale
  19.2. La classe ResourceBundle
  19.3. Un guide pour réaliser la localisation

20. Les composants Java beans
  examine comment développer et utiliser des composants réutilisables
  20.1. La présentation des Java beans
  20.2. Les propriétés.
  20.3. Les méthodes
  20.4. Les événements
  20.5. L'introspection
  20.6. Paramétrage du bean ( Customization )
  20.7. La persistance
  20.8. La diffusion sous forme de jar

21. Le logging
  indique comment mettre en oeuvre deux API pour la gestion des logs : Log4J du projet open source Jakarta et l'API Logging du JDK 1.4
  21.1. La présentation du logging
  21.2. Log4j
  21.3. L'API logging
  21.4. Jakarta Commons Logging (JCL)
  21.5. D'autres API de logging

22. L'API Stream
  L'API Stream permet au travers d'un approche fonctionnelle de manipuler des données d'une source dans le but de produire un résultat. Les traitements sont exprimés de manière déclarative et peuvent être exécutés au besoin en parallèle.
  22.1. Le besoin de l'API Stream
  22.2. Le pipeline d'opérations d'un Stream
  22.3. Les opérations intermédiaires
  22.4. Les opérations terminales
  22.5. Les Collectors
  22.6. Les Streams pour des données primitives
  22.7. L'utilisation des Streams avec les opérations I/O
  22.8. Le traitement des opérations en parallèle
  22.9. Les optimisations réalisées par l'API Stream
  22.10. Les Streams infinis
  22.11. Le débogage d'un Stream
  22.12. Les limitations de l'API Stream
  22.13. Quelques recommandations sur l'utilisation de l'API Stream

23. Les expressions régulières
  Ce chapitre détaille l'utilisation et la mise en oeuvre des expressions régulières avec les API du JDK
  23.1. Le package java.util.regex
  23.2. La mise en oeuvre des expressions régulières
  23.3. Les remplacements de texte
  23.4. L'utilisation d'expressions régulières dans les méthodes de la classe String

Partie 3 : Les API avancées
  Le JDK fournit un certain nombres d'API avancées

24. La gestion dynamique des objets et l'introspection
  ces mécanismes permettent dynamiquement de connaître le contenu d'une classe et de l'utiliser
  24.1. La classe Class
  24.2. La recherche des informations sur une classe
  24.3. La définition dynamique d'objets
  24.4. L'invocation dynamique d'une méthode
  24.5. L'API Reflection et le SecurityManager
  24.6. L'utilisation de l'API Reflection sur les annotations

25. L'appel de méthodes distantes : RMI
  étudie la mise en oeuvre de la technologie RMI pour permettre l'appel de méthodes distantes
  25.1. La présentation et l'architecture de RMI
  25.2. Les différentes étapes pour créer un objet distant et l'appeler avec RMI
  25.3. Le développement coté serveur
  25.4. Le développement coté client
  25.5. La génération de la classe stub
  25.6. La mise en oeuvre des objets RMI

26. La sécurité
  partie intégrante de Java, elle revêt de nombreux aspects dans les spécifications, la gestion des droits d'exécution et plusieurs API dédiées
  26.1. La sécurité dans les spécifications du langage
  26.2. Le contrôle des droits d'une application
  26.3. La cryptographie
  26.4. JCA (Java Cryptography Architecture) et JCE (Java Cryptography Extension)
  26.5. JSSE (Java Secure Sockets Extension)
  26.6. JAAS (Java Authentication and Authorization Service)

27. JCA (Java Cryptography Architecture)
  détaille l'utilisation de l'API proposant des fonctionnalités cryptographiques de base
  27.1. L'architecture de JCA
  27.2. Les classes et interfaces de JCA
  27.3. Les fournisseurs d'implémentations
  27.4. La classe java.security.Provider
  27.5. La classe java.security.Security
  27.6. La classe java.security.MessageDigest
  27.7. Les classes DigestInputStream et DigestOuputStream
  27.8. La classe java.security.Signature
  27.9. La classe java.security.KeyStore
  27.10. Les interfaces de type java.security.Key
  27.11. La classe java.security.KeyPair
  27.12. La classe java.security.KeyPairGenerator
  27.13. La classe java.security.KeyFactory
  27.14. La classe java.security.SecureRandom
  27.15. La classe java.security.AlgorithmParameters
  27.16. La classe java.security.AlgorithmParameterGenerator
  27.17. La classe java.security.cert.CertificateFactory
  27.18. L'interface java.security.spec.KeySpec et ses implémentations
  27.19. La classe java.security.spec.EncodedKeySpec et ses sous-classes
  27.20. L'interface java.security.spec.AlgorithmParameterSpec

28. JCE (Java Cryptography Extension)
  détaille l'API pour l'encryptage et le décryptage, la génération de clés et l'authentification de messages avec des algorithmes de type MAC
  28.1. La classe javax.crypto.KeyGenerator
  28.2. La classe javax.crypto.SecretKeyFactory
  28.3. La classe javax.crypto.Cipher
  28.4. Les classes javax.crypto.CipherInputStream et javax.crypto.CipherOutputStream
  28.5. La classe javax.crypto.SealedObject
  28.6. La classe javax.crypto.Mac

29. JNI (Java Native Interface)
  technologie qui permet d'utiliser du code natif dans une classe Java et vice versa
  29.1. La déclaration et l'utilisation d'une méthode native
  29.2. La génération du fichier d'en-tête
  29.3. L'écriture du code natif en C
  29.4. Le passage de paramètres et le renvoi d'une valeur (type primitif)
  29.5. Le passage de paramètres et le renvoi d'une valeur (type objet)

30. JNDI (Java Naming and Directory Interface)
  introduit l'API qui permet d'accéder aux services de nommage et d'annuaires
  30.1. La présentation de JNDI
  30.2. La mise en oeuvre de l'API JNDI
  30.3. L'utilisation d'un service de nommage
  30.4. L'utilisation avec un DNS
  30.5. L'utilisation du File System Context Provider
  30.6. LDAP
  30.7. L'utilisation avec un annuaire LDAP
  30.8. JNDI et J2EE/Java EE

31. Le scripting
  L'utilisation d'outils de scripting avec Java a longtemps été possible au travers de produits open source. Depuis la version 6.0 de Java, une API standard est proposée.
  31.1. L'API Scripting

32. JMX (Java Management Extensions)
  ce chapitre détaille l'utilisation de JMX. C'est une spécification qui définit une architecture, une API et des services pour permettre de surveiller et de gérer des ressources en Java
  32.1. La présentation de JMX
  32.2. L'architecture de JMX
  32.3. Un premier exemple
  32.4. La couche instrumentation : les MBeans
  32.5. Les MBeans standard
  32.6. La couche agent
  32.7. Les services d'un agent JMX
  32.8. La couche services distribués
  32.9. Les notifications
  32.10. Les Dynamic MBeans
  32.11. Les Model MBeans
  32.12. Les Open MBeans
  32.13. Les MXBeans
  32.14. L'interface PersistentMBean
  32.15. Le monitoring d'une JVM
  32.16. Des recommandations pour l'utilisation de JMX
  32.17. Des ressources

33. L'API Service Provider (SPI)
  ce chapitre détaille la mise en oeuvre de services en utilisant l'API ServiceLoader
  33.1. Introduction
  33.2. La mise en oeuvre
  33.3. La consommation d'un service
  33.4. Un exemple complet
  33.5. Les services de JPMS

Partie 4 : Le système de modules
  Java 9 a introduit le système de modules de la plateforme Java (Java Platform Module System ou JPMS)

34. Le système de modules de la plateforme Java
  ce chaptitre décrit le système de modules de la plateforme Java
  34.1. La modularisation
  34.2. Les difficultés pouvant être résolues par les modules
  34.3. Java Plateform Module System (JPMS)
  34.4. L'implémentation du système de modules

35. Les modules
  ce chapitre détaille les modules et les descripteurs de module
  35.1. Le contenu d'un module
  35.2. Le code source d'un module
  35.3. Le descripteur de module
  35.4. Les règles d'accès
  35.5. La qualité des descripteurs de module

Partie 5 : La programmation parallèle et concurrente
  Le JDK fournit un certain nombre d'API pour mettre en oeuvre des traitements parallélisés éventuellent exécutés en concurrence

36. Le multitâche
  décrit les principaux fondamentaux des traitements multitaches et de leurs mises en oeuvre avec Java

37. Les threads
  présente et met en oeuvre les mécanismes des threads qui permettent de répartir différents traitements d'un même programme en plusieurs unités distinctes exécutées de manière "simultanée"
  37.1. L'interface Runnable
  37.2. La classe Thread
  37.3. Le cycle de vie d'un thread
  37.4. Les démons (daemon threads)
  37.5. Les groupes de threads
  37.6. L'obtention d'informations sur un thread
  37.7. La manipulation des threads
  37.8. Les messages de synchronisation entre threads
  37.9. Les restrictions sur les threads
  37.10. Les threads et les classloaders
  37.11. Les threads et la gestion des exceptions
  37.12. Les piles

38. L'association de données à des threads
  détaille les solutions utilisables pour permettre d'associer des données à un thread
  38.1. La classe ThreadLocal
  38.2. La classe InheritableThreadLocal
  38.3. La classe ThreadLocalRandom

39. Le framework Executor
  détaille l'utilisation du framework Executor
  39.1. L'interface Executor
  39.2. Les pools de threads
  39.3. L'interface java.util.concurrent.Callable
  39.4. L'interface java.util.concurrent.Future
  39.5. L'interface java.util.concurrent.CompletionService

40. La gestion des accès concurrents
  détaille différentes solutions pour gérer les accès concurrents dans les traitements en parallèle
  40.1. Le mot clé volatile
  40.2. Les races conditions
  40.3. La synchronisation avec les verrous
  40.4. Les opérations atomiques
  40.5. L'immutabilité et la copie défensive

Partie 6 : Le développement des interfaces graphiques
  Les interfaces graphiques assurent le dialogue entre les utilisateurs et une application.

41. Le graphisme
  entame une série de chapitres sur les interfaces graphiques en détaillant les objets et méthodes de base pour le graphisme
  41.1. Les opérations sur le contexte graphique

42. Les éléments d'interfaces graphiques de l'AWT
  recense les différents composants qui sont fournis dans la bibliothèque AWT
  42.1. Les composants graphiques
  42.2. La classe Component
  42.3. Les conteneurs
  42.4. Les menus
  42.5. La classe java.awt.Desktop

43. La création d'interfaces graphiques avec AWT
  indique comment réaliser des interfaces graphiques avec l'AWT
  43.1. Le dimensionnement des composants
  43.2. Le positionnement des composants
  43.3. La création de nouveaux composants à partir de Panel
  43.4. L'activation ou la désactivation des composants

44. L'interception des actions de l'utilisateur
  détaille les mécanismes qui permettent de réagir aux actions de l'utilisateur via une interface graphique
  44.1. L'interception des actions de l'utilisateur avec Java version 1.0
  44.2. L'interception des actions de l'utilisateur avec Java version 1.1

45. Le développement d'interfaces graphiques avec SWING
  indique comment réaliser des interfaces graphiques avec Swing
  45.1. La présentation de Swing
  45.2. Les packages Swing
  45.3. Un exemple de fenêtre autonome
  45.4. Les composants Swing
  45.5. Les boutons
  45.6. Les composants de saisie de texte
  45.7. Les onglets
  45.8. Le composant JTree
  45.9. Les menus
  45.10. L'affichage d'une image dans une application.

46. Le développement d'interfaces graphiques avec SWT
  indique comment réaliser des interfaces graphiques avec SWT
  46.1. La présentation de SWT
  46.2. Un exemple très simple
  46.3. La classe SWT
  46.4. L'objet Display
  46.5. L'objet Shell
  46.6. Les composants
  46.7. Les conteneurs
  46.8. La gestion des erreurs
  46.9. Le positionnement des contrôles
  46.10. La gestion des événements
  46.11. Les boîtes de dialogue

47. JFace
  présente l'utilisation de ce framework facilitant le développement d'applications utilisant SWT
  47.1. La présentation de JFace
  47.2. La structure générale d'une application
  47.3. Les boites de dialogue

Partie 7 : L'utilisation de documents XML et JSON
  Cette partie traite de l'utilisation de documents XML et JSON avec Java

48. Java et XML
  présente XML qui s'est imposée pour les échanges de données et explore les API Java pour utiliser XML
  48.1. La présentation de XML
  48.2. Les règles pour formater un document XML
  48.3. La DTD (Document Type Definition)
  48.4. Les parseurs
  48.5. La génération de données au format XML
  48.6. JAXP : Java API for XML Parsing
  48.7. Jaxen

49. SAX (Simple API for XML)
  présente l'utilisation de l'API SAX avec Java. Cette API utilise des événements pour traiter un document XML
  49.1. L'utilisation de SAX de type 1
  49.2. L'utilisation de SAX de type 2

50. DOM (Document Object Model)
  présente l'utilisation avec Java de cette spécification du W3C pour proposer une API qui permet de modéliser, de parcourir et de manipuler un document XML
  50.1. Les interfaces du DOM
  50.2. L'obtention d'un arbre DOM
  50.3. Le parcours d'un arbre DOM
  50.4. La modification d'un arbre DOM
  50.5. L'envoi d'un arbre DOM dans un flux

51. XSLT (Extensible Stylesheet Language Transformations)
  présente l'utilisation avec Java de cette recommandation du W3C pour transformer des documents XML
  51.1. XPath
  51.2. La syntaxe de XSLT
  51.3. Un exemple avec Internet Explorer
  51.4. Un exemple avec Xalan 2

52. Les modèles de documents
  présente quelques API open source spécifiques à Java pour traiter un document XML : JDom et Dom4J
  52.1. L'API JDOM
  52.2. dom4j

53. JAXB (Java Architecture for XML Binding)
  détaille l'utilisation de cette spécification qui permet de faire correspondre un document XML à un ensemble de classes et vice versa.
  53.1. JAXB 1.0
  53.2. JAXB 2.0

54. StAX (Streaming Api for XML)
  détaille l'utilisation de cette API qui permet de traiter un document XML de façon simple en consommant peu de mémoire tout en permettant de garder le contrôle sur les opérations d'analyse ou d'écriture
  54.1. La présentation de StAX
  54.2. Les deux API de StAX
  54.3. Les fabriques
  54.4. Le traitement d'un document XML avec l'API du type curseur
  54.5. Le traitement d'un document XML avec l'API du type itérateur
  54.6. La mise en oeuvre des filtres
  54.7. L'écriture un document XML avec l'API de type curseur
  54.8. L'écriture un document XML avec l'API de type itérateur
  54.9. La comparaison entre SAX, DOM et StAX

55. JSON
  présente le format JSON
  55.1. La syntaxe de JSON
  55.2. L'utilisation de JSON
  55.3. JSON ou XML

56. Gson
  Présente l'API Gson de Google pour la lecture et la génération de documents JSON
  56.1. La classe Gson
  56.2. La sérialisation
  56.3. La désérialisation
  56.4. La personnalisation de la sérialisation/désérialisation
  56.5. Les annotations de Gson
  56.6. L'API Streaming
  56.7. Mixer l'utilisation du model objets et de l'API Streaming
  56.8. Les concepts avancés

57. JSON-P (Java API for JSON Processing)
  détaille l'utilisation de l'API JSON-P spécifiée dans la JSR 353
  57.1. La classe Json
  57.2. L'API Streaming
  57.3. L'API Object Model

58. JSON-B (Java API for JSON Binding)
  détaille l'utilisation de l'API JSON-B qui propose une API standard pour permettre de convertir un document JSON en objet Java et vice versa
  58.1. La sérialisation/désérialisation d'un objet
  58.2. Le moteur JSON-B
  58.3. Le mapping par défaut
  58.4. La configuration du moteur JSON-B
  58.5. La personnalisation du mapping

Partie 8 : L'accès aux bases de données
  Cette partie concerne l'accès aux bases de données à partir d'applications Java

59. La persistance des objets
  expose les difficultés liées à la persistance des objets vis à vis du modèle relationnel et présente rapidement des solutions architecturales et techniques (API standards et open source)
  59.1. La correspondance entre les modèles relationnel et objet
  59.2. L'évolution des solutions de persistance avec Java
  59.3. Le mapping O/R (objet/relationnel)
  59.4. L'architecture et la persistance de données
  59.5. Les différentes solutions
  59.6. Les API standards
  59.7. Les frameworks open source
  59.8. L'utilisation de procédures stockées

60. JDBC
  indique comment utiliser cette API historique pour accéder aux bases de données
  60.1. Les outils nécessaires pour utiliser JDBC
  60.2. Les types de pilotes JDBC
  60.3. La présentation des classes et interfaces de base de l'API JDBC
  60.4. La connexion à une base de données
  60.5. L'accès à la base de données
  60.6. L'obtention d'informations sur la base de données
  60.7. L'utilisation d'un objet de type PreparedStatement
  60.8. L'utilisation des transactions
  60.9. Les procédures stockées
  60.10. Le traitement des erreurs JDBC
  60.11. Les évolutions de l'API JDBC
  60.12. MySQL et Java
  60.13. L'amélioration des performances avec JDBC

61. JDO (Java Data Object)
  API qui standardise et automatise le mapping entre des objets Java et un système de gestion de données
  61.1. La présentation de JDO
  61.2. Un exemple avec Lido
  61.3. L'API JDO
  61.4. La mise en oeuvre
  61.5. Le parcours de toutes les occurrences
  61.6. La mise en oeuvre de requêtes

62. Hibernate
  présente Hibernate, un framework de mapping Objets/Relationnel open source
  62.1. La création d'une classe qui va encapsuler les données
  62.2. La création d'un fichier de correspondance
  62.3. Les propriétés de configuration
  62.4. L'utilisation d'Hibernate
  62.5. La persistance d'une nouvelle occurrence
  62.6. L'obtention d'une occurrence à partir de son identifiant
  62.7. L'obtention de données
  62.8. La mise à jour d'une occurrence
  62.9. La suppression d'une ou plusieurs occurrences
  62.10. Les relations
  62.11. Le mapping de l'héritage de classes
  62.12. Les caches d'Hibernate
  62.13. Les outils de génération de code

63. JPA (Java Persistence API)
  JPA est la spécification de l'API standard dans le domaine du mapping O/R utilisable avec Java EE mais aussi avec Java SE à partir de la version 5.
  63.1. L'installation de l'implémentation de référence
  63.2. Les entités
  63.3. Le fichier de configuration du mapping
  63.4. L'utilisation du bean entité
  63.5. Le fichier persistence.xml
  63.6. La gestion des transactions hors Java EE
  63.7. La gestion des relations entre tables dans le mapping
  63.8. Le mapping de l'héritage de classes
  63.9. Les callbacks d'événements

Partie 9 : La machine virtuelle Java (JVM)
  Cette partie concerne la machine virtuelle Java ou JVM (Java Virtual Machine)

64. La JVM (Java Virtual Machine)
  ce chapitre détaille les différents éléments et concepts qui sont mis en oeuvre dans la JVM.
  64.1. La mémoire de la JVM
  64.2. Le cycle de vie d'une classe dans la JVM
  64.3. Les ClassLoaders
  64.4. Le bytecode
  64.5. Le compilateur JIT
  64.6. Les paramètres de la JVM HotSpot
  64.7. Les interactions de la machine virtuelle avec des outils externes
  64.8. Service Provider Interface (SPI)
  64.9. Les JVM 32 et 64 bits

65. La gestion de la mémoire dans la JVM HotSpot
  ce chapitre détaille la gestion de la mémoire dans la JVM HotSpot et notamment les concepts et le paramétrage du ramasse-miettes.
  65.1. Le ramasse-miettes (Garbage Collector ou GC)
  65.2. Le fonctionnement du ramasse-miettes de la JVM Hotspot
  65.3. Le paramétrage du ramasse-miettes de la JVM HotSpot
  65.4. Le monitoring de l'activité du ramasse-miettes
  65.5. Les différents types de référence
  65.6. L'obtention d'informations sur la mémoire de la JVM
  65.7. Les fuites de mémoire (Memory leak)
  65.8. Les exceptions liées à un manque de mémoire

66. La JVM HotSpot dans un conteneur Docker
  ce chapitre détaille les points d'attention lors de l'utilisation d'une JVM HotSpot dans un conteneur Docker.
  66.1. La limitation des ressources d'un conteneur Docker
  66.2. L'utilisation et la configuration des ressources utilisables par une JVM
  66.3. Le support de Docker par la JVM
  66.4. Le support de cgroups v2

67. La décompilation et l'obfuscation
  ce chapitre présente la décompilation qui permet de transformer du bytecode en code source et l'obfuscation qui est l'opération permettant de limiter cette transformation.
  67.1. Décompiler du bytecode
  67.2. Obfusquer le bytecode

68. Programmation orientée aspects (AOP)
  ce chapitre présente le concept de l'AOP (Apsect Oriented Programming
  68.1. Le besoin d'un autre modèle de programmation
  68.2. Les concepts de l'AOP
  68.3. La mise en oeuvre de l'AOP
  68.4. Les avantages et les inconvénients
  68.5. Des exemples d'utilisation
  68.6. Des implémentations pour la plate-forme Java

69. Terracotta
  Ce chapitre détaille les possibilités de l'outil open source Terracotta qui permet de mettre en cluster des JVM
  69.1. La présentation de Terrocatta
  69.2. Les concepts utilisés
  69.3. La mise en oeuvre des fonctionnalités
  69.4. Les cas d'utilisation
  69.5. Quelques exemples de mise en oeuvre
  69.6. La console développeur
  69.7. Le fichier de configuration
  69.8. La fiabilisation du cluster
  69.9. Quelques recommandations

Partie 10 : Le développement d'applications d'entreprises
  Cette partie traite de l'utilisation de Java côté serveur avec la plate-forme basée sur le Java SE et orientée entreprise : Java EE (Java Entreprise Edition)

70. J2EE / Java EE
  introduit la plate-forme Java Entreprise Edition
  70.1. La présentation de J2EE
  70.2. Les API de J2EE / Java EE
  70.3. L'environnement d'exécution des applications J2EE
  70.4. L'assemblage et le déploiement d'applications J2EE
  70.5. J2EE 1.4 SDK
  70.6. La présentation de Java EE 5.0
  70.7. La présentation de Java EE 6
  70.8. La présentation de Java EE 7
  70.9. La présentation de Java EE 8/Jakarta EE 8

71. JavaMail
  traite de l'API qui permet l'envoi et la réception d'e-mails
  71.1. Le téléchargement et l'installation
  71.2. Les principaux protocoles
  71.3. Les principales classes et interfaces de l'API JavaMail
  71.4. L'envoi d'un e-mail par SMTP
  71.5. La récupération des messages d'un serveur POP3
  71.6. Les fichiers de configuration

72. JMS (Java Message Service)
  indique comment utiliser cette API qui permet l'échange de données entre applications grâce à un système de messages
  72.1. La présentation de JMS
  72.2. Les services de messages
  72.3. Le package javax.jms
  72.4. L'utilisation du mode point à point (queue)
  72.5. L'utilisation du mode publication/abonnement (publish/subscribe)
  72.6. La gestion des erreurs
  72.7. JMS 1.1
  72.8. Les ressources relatives à JMS

73. Les EJB (Entreprise Java Bean)
  propose une présentation de l'API et les spécifications pour des objets chargés de contenir les règles métiers
  73.1. La présentation des EJB
  73.2. Les EJB session
  73.3. Les EJB entité
  73.4. Les outils pour développer et mettre en oeuvre des EJB
  73.5. Le déploiement des EJB
  73.6. L'appel d'un EJB par un client
  73.7. Les EJB orientés messages

74. Les EJB 3
  ce chapitre détaille la version 3 des EJB qui est une évolution majeure de cette technologie car elle met l'accent sur la facilité de développement sans sacrifier les fonctionnalités qui font la force des EJB.
  74.1. L'historique des EJB
  74.2. Les nouveaux concepts et fonctionnalités utilisés
  74.3. EJB 2.x vs EJB 3.0
  74.4. Les conventions de nommage
  74.5. Les EJB de type Session
  74.6. Les EJB de type Entity
  74.7. Un exemple simple complet
  74.8. L'utilisation des EJB par un client
  74.9. L'injection de dépendances
  74.10. Les intercepteurs
  74.11. Les EJB de type MessageDriven
  74.12. Le packaging des EJB
  74.13. Les transactions
  74.14. La mise en oeuvre de la sécurité

75. Les EJB 3.1
  ce chapitre détaille la version 3.1 des EJB utilisée par Java EE 6
  75.1. Les interfaces locales sont optionnelles
  75.2. Les EJB Singleton
  75.3. EJB Lite
  75.4. La simplification du packaging
  75.5. Les améliorations du service Timer
  75.6. La standardisation des noms JNDI
  75.7. L'invocation asynchrone des EJB session
  75.8. L'invocation d'un EJB hors du conteneur

76. Les services web de type Soap
  permettent l'appel de services distants en utilisant un protocole de communication et une structuration des données échangées avec XML de façon standardisée
  76.1. La présentation des services web
  76.2. Les standards
  76.3. Les différents formats de services web SOAP
  76.4. Des conseils pour la mise en oeuvre
  76.5. Les API Java pour les services web
  76.6. Les implémentations des services web
  76.7. Inclure des pièces jointes dans SOAP
  76.8. WS-I
  76.9. Les autres spécifications

77. Les WebSockets
  présente le procotole WebSocket
  77.1. Les limitations du protocole HTTP
  77.2. La spécification du protocole WebSocket
  77.3. La connexion à une WebSocket
  77.4. La mise en oeuvre des WebSockets

78. L'API WebSocket
  détaille l'utilisation de l'API Java API for WebSocket spécifiée par la JSR 356
  78.1. Les principales classes et interfaces
  78.2. Le développement d'un endpoint
  78.3. Les encodeurs et les décodeurs
  78.4. Le débogage des WebSockets
  78.5. Des exemples d'utilisation
  78.6. L'utilisation d'implémentations

Partie 11 : Le développement d'applications web
  Plusieurs frameworks standard de Java EE ou open source peuvent être utilisés pour développer des applications web

79. Les servlets
  plonge au coeur de l'API servlet qui est un des composants de base pour le développement d'applications Web
  79.1. La présentation des servlets
  79.2. L'API servlet
  79.3. Le protocole HTTP
  79.4. Les servlets http
  79.5. Les informations sur l'environnement d'exécution des servlets
  79.6. L'utilisation des cookies
  79.7. Le partage d'informations entre plusieurs échanges HTTP
  79.8. Packager une application web
  79.9. L'utilisation de Log4J dans une servlet

80. Les JSP (Java Server Pages)
  poursuit la discussion sur les servlets en explorant un mécanisme basé sur celles-ci pour réaliser facilement des pages web dynamiques
  80.1. La présentation des JSP
  80.2. Les outils nécessaires
  80.3. Le code HTML
  80.4. Les Tags JSP
  80.5. Un exemple très simple
  80.6. La gestion des erreurs
  80.7. Les bibliothèques de tags personnalisés (custom taglibs)

81. JSTL (Java server page Standard Tag Library)
  est un ensemble de bibliothèques de tags personnalisés communément utilisé dans les JSP
  81.1. Un exemple simple
  81.2. Le langage EL (Expression Language)
  81.3. La bibliothèque Core
  81.4. La bibliothèque XML
  81.5. La bibliothèque I18n
  81.6. La bibliothèque Database

82. Struts
  présente et détaille la mise en oeuvre du framework open source de développement d'applications web le plus populaire
  82.1. L'installation et la mise en oeuvre
  82.2. Le développement des vues
  82.3. La configuration de Struts
  82.4. Les bibliothèques de tags personnalisés
  82.5. La validation de données

83. JSF (Java Server Faces)
  détaille l'utilisation de la technologie Java Server Faces (JSF) dont le but est de proposer un framework qui facilite et standardise le développement d'applications web avec Java.
  83.1. La présentation de JSF
  83.2. Le cycle de vie d'une requête
  83.3. Les implémentations
  83.4. Le contenu d'une application
  83.5. La configuration de l'application
  83.6. Les beans
  83.7. Les composants pour les interfaces graphiques
  83.8. La bibliothèque de tags Core
  83.9. La bibliothèque de tags Html
  83.10. La gestion et le stockage des données
  83.11. La conversion des données
  83.12. La validation des données
  83.13. La sauvegarde et la restauration de l'état
  83.14. Le système de navigation
  83.15. La gestion des événements
  83.16. Le déploiement d'une application
  83.17. Un exemple d'application simple
  83.18. L'internationalisation
  83.19. Les points faibles de JSF

84. D'autres frameworks pour les applications web
  présente rapidement quelques frameworks open source pour le développement d'applications web
  84.1. Les frameworks pour les applications web
  84.2. Les moteurs de templates

Partie 12 : Le développement d'applications RIA / RDA
  Cette partie est consacrée au développement d'applications de type RIA (Rich Internet Application) et RDA (Rich Desktop Application)

85. Les applications riches de type RIA et RDA
  présente les caractéristiques des applications riches et les principales solutions qui permettent de les développer.
  85.1. Les applications de type RIA
  85.2. Les applications de type RDA
  85.3. Les contraintes
  85.4. Les solutions RIA
  85.5. Les solutions RDA

86. Les applets
  plonge au coeur des premières applications qui ont rendu Java célèbre
  86.1. L'intégration d'applets dans une page HTML
  86.2. Les méthodes des applets
  86.3. Les interfaces utiles pour les applets
  86.4. La transmission de paramètres à une applet
  86.5. Les applets et le multimédia
  86.6. Une applet pouvant s'exécuter comme une application
  86.7. Les droits des applets

87. Java Web Start (JWS)
   est une technologie qui permet le déploiement d'applications clientes riches à travers le réseau via un navigateur
  87.1. La création du package de l'application
  87.2. La signature d'un fichier jar
  87.3. Le fichier JNLP
  87.4. La configuration du serveur web
  87.5. Le fichier HTML
  87.6. Le test de l'application
  87.7. L'utilisation du gestionnaire d'applications
  87.8. L'API de Java Web Start

88. AJAX
  présente ce concept qui permet de rendre les applications web plus conviviales et plus dynamiques. Le framework open source DWR est aussi détaillé.
  88.1. La présentation d'AJAX
  88.2. Le détail du mode de fonctionnement
  88.3. Un exemple simple
  88.4. Des frameworks pour mettre en oeuvre AJAX

89. GWT (Google Web Toolkit)
  GWT est un framework pour le développement d'applications de type RIA
  89.1. La présentation de GWT
  89.2. La création d'une application
  89.3. Les modes d'exécution
  89.4. Les éléments de GWT
  89.5. L'interface graphique des applications GWT
  89.6. La personnalisation de l'interface
  89.7. Les composants (widgets)
  89.8. Les panneaux (panels)
  89.9. La création d'éléments réutilisables
  89.10. Les événements
  89.11. JSNI
  89.12. La configuration et l'internationalisation
  89.13. L'appel de procédures distantes (Remote Procedure Call)
  89.14. La manipulation des documents XML
  89.15. La gestion de l'historique sur le navigateur
  89.16. Les tests unitaires
  89.17. Le déploiement d'une application
  89.18. Des composants tiers
  89.19. Les ressources relatives à GWT

Partie 13 : Le développement d'applications avec Spring
  Cette partie couvre le framework Spring et quelques-unes des nombreuses extensions qui composent son portfolio

90. Spring
  ce chapitre est une présentation générale de Spring
  90.1. Le but et les fonctionnalités proposées par Spring
  90.2. L'historique de Spring
  90.3. Spring Framework
  90.4. Les projets du portfolio Spring
  90.5. Les avantages et les inconvénients de Spring
  90.6. Spring et Java EE

91. Spring Core
  ce chapitre détaille la configuration et la mise en oeuvre du conteneur Spring qui gère le cycle de vie des beans
  91.1. Les fondements de Spring
  91.2. Le conteneur Spring
  91.3. Le fichier de configuration
  91.4. L'injection de dépendances
  91.5. Spring Expression Langage (SpEL)
  91.6. La configuration en utilisant les annotations
  91.7. Le scheduling

92. La mise en oeuvre de l'AOP avec Spring
  présente la mise en oeuvre de l'AOP avec Spring
  92.1. Spring AOP
  92.2. AspectJ
  92.3. Spring AOP et AspectJ
  92.4. L'utilisation des namespaces

93. La gestion des transactions avec Spring
  ce chapitre présente les différentes possibilités de gestion des transactions dans une application Spring
  93.1. La gestion des transactions par Spring
  93.2. La propagation des transactions
  93.3. L'utilisation des transactions de manière déclarative
  93.4. La déclaration des transactions avec des annotations
  93.5. La gestion du rollback des transactions
  93.6. La mise en oeuvre d'aspects sur une méthode transactionnelle
  93.7. L'utilisation des transactions via l'API
  93.8. L'utilisation d'un gestionnaire de transactions reposant sur JTA

94. Spring et JMS
  ce chapitre couvre la mise en oeuvre de JMS dans Spring
  94.1. Les packages de Spring JMS
  94.2. La classe JmsTemplate : le template JMS de Spring
  94.3. La réception asynchrone de messages
  94.4. L'espace de nommage jms

95. Spring et JMX
  ce chapitre détaille la façon dont Spring facilite la mise en oeuvre de JMX
  95.1. L'enregistrement d'un bean en tant que MBean
  95.2. Le nommage des MBeans
  95.3. Les Assembler
  95.4. L'utilisation des annotations
  95.5. Le développement d'un client JMX
  95.6. Les notifications

Partie 14 : Les outils pour le développement
  Cette partie présente quelques outils du JDK et open source utiles pour le développement

96. Les outils du J.D.K.
  indique comment utiliser les outils fournis avec le JDK
  96.1. Le compilateur javac
  96.2. L'interpréteur java/javaw
  96.3. L'outil jar
  96.4. L'outil appletviewer pour tester des applets
  96.5. L'outil javadoc pour générer la documentation technique
  96.6. L'outil Java Check Update pour mettre à jour Java
  96.7. La base de données Java DB
  96.8. L'outil JConsole

97. JavaDoc
  explore l'outil de documentation fourni avec le JDK
  97.1. La mise en oeuvre
  97.2. Les tags définis par javadoc
  97.3. Un exemple
  97.4. Les fichiers pour enrichir la documentation des packages
  97.5. La documentation générée

98. JShell
  détaille l'utilisation de l'outil JShell
  98.1. Les outils de type REPL
  98.2. Introduction à JShell
  98.3. La saisie d'éléments dans JShell
  98.4. Les fragments
  98.5. Les commandes de JShell
  98.6. L'édition
  98.7. Les fonctionnalités de l'environnement
  98.8. Les scripts
  98.9. Les modes de feedback
  98.10. L'utilisation de classes externes
  98.11. Les options de JShell
  98.12. JShell API

99. Les outils libres et commerciaux
  tente une énumération non exhaustive des outils libres et commerciaux pour utiliser java
  99.1. Les environnements de développement intégrés (IDE)
  99.2. Les serveurs d'application
  99.3. Les conteneurs web
  99.4. Les conteneurs d'EJB
  99.5. Les outils divers
  99.6. Les MOM
  99.7. Les outils concernant les bases de données
  99.8. Les outils de modélisation UML

100. Ant
  propose une présentation et la mise en oeuvre de cet outil d'automatisation de la construction d'applications
  100.1. L'installation de l'outil Ant
  100.2. L'exécution de l'outil Ant
  100.3. Le fichier build.xml
  100.4. Les tâches (task)

101. Maven
  présente l'outil open source Maven qui facilite et automatise certaines tâches de la gestion d'un projet
  101.1. Les différentes versions de Maven
  101.2. Maven 1
  101.3. Maven 2

102. Tomcat
  Détaille la mise en oeuvre du conteneur web Tomcat
  102.1. L'historique des versions
  102.2. L'installation
  102.3. L'exécution de Tomcat
  102.4. L'architecture
  102.5. La configuration
  102.6. L'outil Tomcat Administration Tool
  102.7. Le déploiement des applications WEB
  102.8. Tomcat pour le développeur
  102.9. Le gestionnaire d'applications (Tomcat manager)
  102.10. L'outil Tomcat Client Deployer
  102.11. Les optimisations
  102.12. La sécurisation du serveur

103. Des outils open source pour faciliter le développement
  présentation de quelques outils de la communauté open source permettant de simplifier le travail des développeurs.
  103.1. CheckStyle
  103.2. Jalopy

Partie 15 : La conception et le développement des applications
  Cette partie présente des techniques pour concevoir et développer des fonctionnalités dans des applications

104. Java et UML
  propose une présentation de la notation UML ainsi que sa mise en oeuvre avec Java
  104.1. La présentation d'UML
  104.2. Les commentaires
  104.3. Les cas d'utilisations (use cases)
  104.4. Le diagramme de séquence
  104.5. Le diagramme de collaboration
  104.6. Le diagramme d'états-transitions
  104.7. Le diagramme d'activités
  104.8. Le diagramme de classes
  104.9. Le diagramme d'objets
  104.10. Le diagramme de composants
  104.11. Le diagramme de déploiement

105. Les motifs de conception (design patterns)
  présente certains modèles de conception en programmation orientée objet et leur mise en oeuvre avec Java
  105.1. Les modèles de création
  105.2. Les modèles de structuration
  105.3. Les modèles de comportement

106. Des normes de développement
  propose de sensibiliser le lecteur à l'importance de la mise en place de normes de développement sur un projet et propose quelques règles pour définir de telles normes
  106.1. Les fichiers
  106.2. La documentation du code
  106.3. Les déclarations
  106.4. Les séparateurs
  106.5. Les traitements
  106.6. Les règles de programmation

107. Les techniques de développement spécifiques à Java
  couvre des techniques de développement spécifiques à Java
  107.1. L'écriture d'une classe dont les instances seront immuables
  107.2. La redéfinition des méthodes equals() et hashCode()
  107.3. Le clonage d'un objet

108. L'encodage des caractères
  ce chapitre fournit des informations sur l'encodage des caractères dans les applications Java.
  108.1. L'utilisation des caractères dans la JVM
  108.2. Les jeux d'encodages de caractères
  108.3. Unicode
  108.4. L'encodage de caractères
  108.5. L'encodage du code source
  108.6. L'encodage de caractères avec différentes technologies

109. Les frameworks
  présente les frameworks et propose quelques solutions open source dans divers domaines
  109.1. La présentation des concepts
  109.2. Les frameworks pour les applications web
  109.3. L'architecture pour les applications web
  109.4. Le modèle MVC type 1
  109.5. Le modèle MVC de type 2
  109.6. Les frameworks de mapping Objet/Relationel
  109.7. Les frameworks de logging

110. La génération de documents
  ce chapitre présente plusieurs API open source permettant la génération de documents dans différents formats notamment PDF et Excel
  110.1. Apache POI
  110.2. iText

111. La validation des données
  la validation des données est une tâche commune, nécessaire et importante dans chaque application de gestion de données.
  111.1. Quelques recommandations sur la validation des données
  111.2. L'API Bean Validation (JSR 303)
  111.3. D'autres frameworks pour la validation des données

112. L'utilisation des dates
  ce chapitre détaille l'utilisation des dates en Java
  112.1. Les classes standard du JDK pour manipuler des dates
  112.2. Des exemples de manipulations de dates
  112.3. La classe SimpleDateFormat
  112.4. Joda Time
  112.5. La classe FastDateFormat du projet Apache commons.lang
  112.6. L'API Date and Time

113. La planification de tâches
  ce chapitre propose différentes solutions pour planifier l'exécution de tâches dans une application Java
  113.1. La planification de tâches avec l'API du JDK
  113.2. Quartz

114. Des bibliothèques open source
  présentation de quelques bibliothèques de la communauté open source particulièrement pratiques et utiles
  114.1. JFreeChart
  114.2. Beanshell
  114.3. Apache Commons
  114.4. JGoodies
  114.5. Apache Lucene

115. Apache Commons
  Ce chapitre décrit quelques fonctionnalités de la bibliothèque Apache Commons
  115.1. Apache Commons Configuration
  115.2. Apache Commons CLI

Partie 16 : Les tests automatisés
  Cette partie détaille la mise en oeuvre de tests automatisés

116. Les frameworks de tests
  propose une présentation de frameworks et d'outils pour faciliter les tests du code
  116.1. Les tests unitaires
  116.2. Les frameworks et outils de tests

117. JUnit
  présente en détail le framework de tests unitaires le plus utilisé
  117.1. Un exemple très simple
  117.2. L'écriture des cas de tests
  117.3. L'exécution des tests
  117.4. Les suites de tests
  117.5. L'automatisation des tests avec Ant
  117.6. JUnit 4

118. JUnit 5
  la version 5 de JUnit est une réécriture complète qui supporte Java 8 et de nombreuses nouvelles fonctionnalités
  118.1. L'architecture
  118.2. Les dépendances
  118.3. L'écriture de tests
  118.4. L'écriture de tests standard
  118.5. Les assertions
  118.6. Les suppositions
  118.7. La désactivation de tests
  118.8. Les tags
  118.9. Le cycle de vie des instances de test
  118.10. Les tests imbriqués
  118.11. L'injection d'instances dans les constructeurs et les méthodes de tests
  118.12. Les tests répétés
  118.13. Les tests paramétrés
  118.14. Les tests dynamiques
  118.15. Les tests dans une interface
  118.16. Les suites de tests
  118.17. La compatibilité
  118.18. La comparaison entre JUnit 4 et JUnit 5

119. Les objets de type mock
  ce chapitre détaille la mise en oeuvre des objets de type mocks et les doublures d'objets
  119.1. Les doublures d'objets et les objets de type mock
  119.2. L'utilité des objets de type mock
  119.3. Les tests unitaires et les dépendances
  119.4. L'obligation d'avoir une bonne organisation du code
  119.5. Les frameworks
  119.6. Les inconvénients des objets de type mock

Partie 17 : Les outils de profiling et monitoring
  Cette partie détaille quelques outils pour le profiling et le monitoring

120. Arthas
  Cette section détaille la mise en oeuvre de l'outil de profiling et de monitoring Arthas
  120.1. Installation
  120.2. Le démarrage
  120.3. Les fonctionnalités
  120.4. L'exécution de commandes en asynchrone
  120.5. Les scripts batch
  120.6. La console web

121. VisualVM
  VisualVM est un outil historiquement fourni dans la JDK est maintenant en open source qui propose des fonctionnalités de monitoring et de profiling basic extensible par plug-in
  121.1. L'utilisation de VisualVM
  121.2. Les plugins pour VisualVM
  121.3. L'utilisation de VisualVM
  121.4. La connexion à une JVM
  121.5. L'obtention d'informations
  121.6. Le profilage d'une JVM
  121.7. La création d'un snapshot
  121.8. Le plugin VisualGC

Partie 18 : Java et le monde informatique
  Cette partie détaille quelques interactions entre Java et le monde informatique

122. La communauté Java
  ce chapitre présente quelques-unes des composantes de l'imposante communauté Java
  122.1. Le JCP
  122.2. Les ressources proposées par Oracle
  122.3. Oracle Technology Network
  122.4. La communauté Java.net
  122.5. Les JUG
  122.6. Les Cast Codeurs Podcast
  122.7. Parleys.com
  122.8. Les conférences Devoxx et Voxxed Days
  122.9. Les conférences
  122.10. Les unconférences
  122.11. Webographie
  122.12. Les communautés open source

123. Les plates-formes Java et .Net
  ce chapitre présente rapidement les deux plates-formes
  123.1. La présentation des plates-formes Java et .Net
  123.2. La compilation
  123.3. Les environnements d'exécution
  123.4. Le déploiement des modules
  123.5. Les version des modules
  123.6. L'interopérabilité inter-language
  123.7. La décompilation
  123.8. Les API des deux plates-formes

124. Java et C#
  ce chapitre détaille les principales fonctionnalités des langages Java et C#
  124.1. La syntaxe
  124.2. La programmation orientée objet
  124.3. Les chaînes de caractères
  124.4. Les tableaux
  124.5. Les indexeurs
  124.6. Les exceptions
  124.7. Le multitâche
  124.8. L'appel de code natif
  124.9. Les pointeurs
  124.10. La documentation automatique du code
  124.11. L'introspection/reflection
  124.12. La sérialisation

Partie 19 : Le développement d'applications mobiles
  Cette partie détaille quelques fonctionnalités par Java ME pour le développement d'applications en environnement contraint

125. J2ME / Java ME
  présente la plate-forme Java pour le développement d'applications sur des appareils mobiles tels que des PDA ou des téléphones cellulaires
  125.1. L'historique de la plate-forme
  125.2. La présentation de J2ME / Java ME
  125.3. Les configurations
  125.4. Les profiles
  125.5. J2ME Wireless Toolkit 1.0.4
  125.6. J2ME wireless toolkit 2.1

126. CLDC
  présente les packages et les classes de la configuration CLDC
  126.1. Le package java.lang
  126.2. Le package java.io
  126.3. Le package java.util
  126.4. Le package javax.microedition.io

127. MIDP
  propose une présentation et une mise en oeuvre du profil MIDP pour le développement d'applications mobiles
  127.1. Les Midlets
  127.2. L'interface utilisateur
  127.3. La gestion des événements
  127.4. Le stockage et la gestion des données
  127.5. Les suites de midlets
  127.6. Packager une midlet
  127.7. MIDP for Palm O.S.

128. CDC
  présente les packages et les classes de la configuration CDC

129. Les profils du CDC
  propose une présentation et une mise en oeuvre des profils pouvant être utilisés avec la configuration CDC
  129.1. Foundation profile
  129.2. Le Personal Basis Profile (PBP)
  129.3. Le Personal Profile (PP)

130. Les autres technologies pour les applications mobiles
  propose une présentation des autres technologies basées sur Java pour développer des applications mobiles
  130.1. KJava
  130.2. PDAP (PDA Profile)
  130.3. PersonalJava
  130.4. Embedded Java

Partie 20 : Annexes
  contient les documents en annexe
   Annexe A : GNU Free Documentation License
   Annexe B : Glossaire


*Développons en Java* v 2.40 Copyright (C) 1999-2023 Jean-Michel DOUDOUX.