Programmer avec Java

Book description

Un best-seller US enfin traduit en France

Ce livre est destiné à éléver l'expérience de tout programmeur Java 7 et 8 à un niveau d'excellence. Rempli d'exemples de programmes mettant en oeuvre les toutes dernières APIs Java et donnant des principes de programmation afin d'optimiser l'écriture et l'exécution du code Java, il deviendra vite indispensable à tout programmeur digne de ce nom.

Table of contents

  1. Couverture
  2. Programmer avec Java - Concepts fondamentaux et mise en oeuvre par l'exemple - collection O'Reilly - collection O'Reilly
  3. Copyright
  4. Avant-propos
  5. Préface
    1. À propos de la septième édition anglaise
    2. Structure du livre
      1. Partie I
      2. Partie II
      3. Autres livres conseillés
      4. Code source des exemples
      5. Conventions typographiques
      6. Conventions terminologiques
  6. PARTIE I. Présentation de Java
    1. CHAPITRE 1. Introduction à l’environnement Java
      1. Le langage, la machine JVM et l’écosystème
        1. Qu’est-ce que le langage Java ?
        2. Qu’est-ce que la machine virtuelle JVM ?
        3. L’écosystème Java
      2. Bref historique de Java et de la JVM
        1. Java 1.0 (1996)
        2. Java 1.1 (1997)
        3. Java 1.2 (1998)
        4. Java 1.3 (2000)
        5. Java 1.4 (2002)
        6. Java 5 (2004)
        7. Java 6 (2006)
        8. Java 7 (2011)
        9. Java 8 (2014) LTS
        10. Java 9 (2017)
        11. Java 10 (mars 2018)
        12. Java 11 (septembre 2018) LTS
      3. Cycle de vie d’un programme Java
      4. Quelques questions fréquentes
        1. Qu’est-ce que le bytecode (octocode) ?
        2. Est-ce que Java est un compilateur ?
        3. Que signifie le mot octocode (bytecode) ?
        4. Est-ce que l'octocode est optimisé ?
        5. Quelle est la portabilité de l'octocode ? Et l’ordre des bits ?
        6. Est-ce que Java est un langage interprété ?
        7. Peut-on faire exécuter d’autres langages par la JVM ?
      5. Java et la sécurité
      6. Comparaison de Java à d’autres langages
        1. Java comparé au langage C
        2. Java comparé au langage C++
        3. Java comparé au langage Python
        4. Java comparé à JavaScript
      7. Réponses à quelques critiques de Java
        1. Trop long à écrire (trop verbeux) ?
        2. Lent au changement ?
        3. Problèmes de performances ?
        4. Problèmes de sécurité ?
        5. Réservé aux grandes entreprises ?
    2. CHAPITRE 2. Les règles d’écriture Java
      1. Présentation du parcours
      2. Structure lexicale
        1. Le jeu de caractères Unicode
        2. Distinction entre MAJUSCULES et minuscules
        3. Commentaires
        4. Mots clés ou réservés
        5. Identifiants
        6. Littéraux
        7. Ponctuation
        8. Opérateurs
      3. Types de données primitifs
        1. Le type binaire boolean
        2. Le type caractère char
        3. Le type chaîne de caractères littérale (string)
        4. Types numériques entiers (integer)
        5. Les types flottants (float et double)
        6. Transtypage entre types primitifs
      4. Expressions et opérateurs
        1. Présentation des opérateurs
          1. Priorité entre opérateurs
          2. Associativité
          3. Tableau des opérateurs Java
        2. Type et quantité d’opérandes
        3. Type de la valeur renvoyée (return)
        4. Effets secondaires des opérateurs
        5. Ordre d’évaluation des opérateurs
        6. Opérateurs arithmétiques
          1. Addition ( + )
          2. Soustraction ( - )
          3. Multiplication ( * )
          4. Division ( / )
          5. Modulo ( % )
          6. Moins unaire
        7. Opérateur de concaténation de chaînes
        8. Les opérateurs d’incrémentation et de décrémentation
        9. Opérateurs de comparaison et de test
          1. Égalité ==
          2. Inégalité !=
        10. Opérateurs relationnels
        11. Opérateurs booléens combinants et sur bits
          1. ET combinant (&&)
          2. OU combinant ( ¦¦ )
          3. NON booléen ( ! )
          4. ET sur bits sans optimisation (&)
          5. OU sur bits sans optimisation ( ¦ )
          6. OU exclusif sur bits (XOR, ^)
        12. Opérateurs sur bits et de décalage
          1. Complément binaire (~)
          2. ET binaire entre bits ( & )
          3. Ou logique entre bits ( ¦ )
          4. OU exclusif entre bits ou XOR ( ^ )
          5. Décalage de bits par la gauche ( << )
          6. Décalage de bits par la droite avec signe ( >> )
          7. Décalage de bits par la droite sans signe ( >>> )
        13. Opérateurs d’affectation ou de copie
        14. L’opérateur conditionnel ternaire ?
        15. L’opérateur de test d’objet instanceof
        16. Opérateurs spéciaux
          1. Qualificateur d’accès à un membre ( . )
          2. Accès un élément de tableau ( [ ] )
          3. Appel ou invocation de méthode ( () )
          4. Expressions lambda ( -> )
          5. Création d’objet avec new
          6. Création de tableau avec new
          7. Transtypage ( () )
      5. Instructions
        1. Les instructions d’expressions
        2. Blocs d’instructions
        3. L'instruction vide (;)
        4. L’instruction de label
        5. L’instruction de déclaration de variable locale
          1. Constantes et mot clé final
        6. L’instruction conditionnelle if else
          1. La clause else if
        7. L’instruction switch
        8. L’instruction de répétition while
        9. L’instruction de répétition do
        10. L’instruction de répétition for
        11. La variante d’instruction « foreach » ( for : )
          1. Limitations de foreach
        12. L’instruction de rupture break
        13. L’instruction de reprise continue
        14. L’instruction de retour à l’appelant return
        15. L’instruction de verrouillage synchronized
        16. L’instruction de déclenchement d’exception throw
        17. Les instructions try, catch et finally
          1. Le bloc try
          2. Le bloc catch
          3. Le bloc finally
        18. Variante de try avec ressources
        19. L’instruction de mise au point assert
          1. Activation de assert
      6. Méthodes
        1. Définition de méthode
        2. Modificateurs de méthode
          1. abstract
          2. final
          3. native
        3. Contrôle d’accès avec public, protected et private
          1. Méthode de classe avec static
          2. strictfp
          3. synchronized
        4. Exceptions prévues et imprévues (checked et unchecked)
          1. Traitement des exceptions prévues
        5. Liste de paramètres à longueur variable.
      7. Présentation rapide des classes et des objets
        1. Définition d’une classe
        2. Création d’une instance de classe (d’un objet)
        3. Exploitation d’un objet
        4. Objets littéraux
          1. Littéraux de chaînes avec String
          2. Littéraux de types
          3. La pseudo-référence null
        5. Expressions lambda
      8. Tableaux
        1. Le type tableau ( [ ])
          1. Conversion de types tableau par élargissement
          2. Syntaxe de compatibilité C
        2. Création et initialisation d’un tableau
          1. Initialisation des tableaux
        3. Utilisation des tableaux
          1. Accès aux éléments d’un tableau
          2. Limites d’un tableau
          3. Balayage du contenu d’un tableau
          4. Copie du contenu d’un tableau
          5. Utilitaires des tableaux
        4. Tableaux à plusieurs dimensions
      9. Types référence
        1. Types référence et types primitifs
        2. Utilisation des objets et copie de références
        3. Comparaison d’objets
        4. Emballage (boxing) et déballage (unboxing)
      10. Paquetages et espace de noms Java
        1. Déclaration d’un paquetage
        2. Noms de paquetages globalement uniques
        3. Importation de types
          1. Conflits de noms et masquage
        4. Importation de membres statiques
          1. Importation de membres statiques et méthodes surchargées
      11. Structure d’un fichier source Java
      12. Fichiers de classes et exécution du programme
      13. Conclusion
    3. CHAPITRE 3. Programmation orientée objets Java
      1. Le concept de classe
        1. Définitions de base
          1. Classe
          2. Objet
        2. Autres types référence
        3. Syntaxe de la définition d’une classe
          1. abstract
          2. final
          3. strictfp
      2. Champs et méthodes
        1. Syntaxe de déclaration d’un champ
          1. public, protected, private
          2. static
          3. final
          4. transient
          5. volatile
        2. Champs de classe
        3. Méthodes de classe
        4. Champs d’instance
        5. Méthodes d’instance
        6. Mécanisme de la référence this
      3. Création et initialisation d’un objet
        1. Définition d’un constructeur
        2. Définition de plusieurs constructeurs
        3. Appel de constructeurs en cascade
        4. Valeurs par défaut des champs et des initialiseurs
          1. Bloc d’initialisation
      4. Sous-classes et héritage
        1. Création d’une sous-classe par extension
        2. Classes finales
        3. Super-classes, objets et hiérarchie des classes
        4. Constructeur de sous-classe
        5. Chaînage de constructeurs et constructeur par défaut
          1. Le constructeur de continuité par défaut
        6. Masquage des champs de superclasse
        7. Redéfinition d’une méthode de super-classe
          1. Ne pas confondre redéfinition et masquage
          2. Recherche virtuelle de méthode (lookup)
          3. Appel à une méthode redéfinie
      5. Confinement des données et encapsulation
        1. Niveaux de contrôle d’accès
          1. Accès à un module
          2. Accès au niveau paquetage
          3. Accès au niveau classe
          4. Accès au niveau membre
          5. Contrôle d’accès et héritage
        2. Synthèse des règles d’accès aux membres
        3. Méthodes d’accès aux données
      6. Méthodes abstraites et classes abstraites
        1. Conversions entre types référence
      7. Synthèse des modificateurs
    4. CHAPITRE 4. Le système des types Java
      1. Interfaces
        1. Définition d’une interface
        2. Extension d’une interface
        3. Implémentation d’une interface
        4. Méthodes par défaut
          1. Compatibilité arrière
          2. Implémentation de méthodes par défaut
        5. Interfaces marqueurs
      2. Types génériques
        1. Présentation du concept de générique
        2. Types générique et paramètres de types
        3. Syntaxe diamant
        4. Effacement de type (type erasure)
        5. Paramètres de type liés
        6. Introduction à la covariance
        7. Types métacaractères (wildcards)
          1. Types métacaractères liés (bounded wildcards)
          2. Covariance de types
          3. Contravariance de types
        8. Méthodes génériques
        9. Type à la compilation et type à l’exécution
        10. Conception et utilisation des types génériques
          1. Pratiquant
          2. Concepteur
      3. Énumérations et annotations
        1. Énumérations
        2. Annotations
          1. Définition d’une annotation spécifique
          2. SOURCE
          3. CLASSE
          4. RUNTIME
        3. Annotations de type
      4. Expressions lambda
        1. Conversion et consommation d’une lambda
        2. Références de méthode
        3. Programmation fonctionnelle
          1. Traduction par map()
          2. Filtrage par filter()
          3. Réduction par reduce()
        4. Bornage lexical et variable locale
      5. Types imbriqués
        1. Type membre statique
        2. Classe membre non statique
        3. Classe locale
        4. Classe anonyme
        5. Type membre statique
          1. Caractéristiques des types membres statiques
        6. Classe membre non statique
          1. Particularités des classes membres
          2. Syntaxe des classes membres
        7. Classe locale
          1. Caractéristiques d’une classe locale
          2. Prolongation de portée d’une classe locale
        8. Classe anonyme
      6. Types non dénotables et mot clé var
      7. Conclusion
        1. Statique
        2. Nominal
        3. Orienté objets et impératif
        4. Légèrement fonctionnel
        5. Inférence de type
        6. Compatibilité arrière forte
        7. Effacement de type
    5. CHAPITRE 5. Introduction à la conception orientée objets Java
      1. Valeurs Java
      2. Quelques méthodes fondamentales de java.lang.Object
        1. toString()
        2. equals()
        3. hashCode()
        4. Comparable: :compareTo()
        5. clone()
      3. À propos de conception orientée objets
        1. Constantes
        2. Interfaces ou classes abstraites ?
        3. Une méthode par défaut peut-elle devenir un trait ?
        4. Méthodes d’instance ou méthodes de classe ?
          1. Précision au sujet de System.out.println()
        5. Composition ou héritage
        6. Héritage de champs et accesseurs
        7. Singleton ou enfant unique
      4. Conception orientée objets avec les lambdas
        1. Lambdas ou classes imbriquées ?
        2. Lambdas ou références de méthodes ?
      5. Gestion des exceptions
      6. Programmation robuste en Java
    6. CHAPITRE 6. Gestion mémoire et parallélisme en Java
      1. Fondamentaux de la gestion mémoire Java
        1. Les fuites mémoire en Java
        2. Principe de l’algorithme Marquant-Nettoyant
          1. Table d’allocation
          2. Liste des blocs libres
        3. L’algorithme Marquant-Nettoyant (Mark-and-Sweep)
      2. Techniques d’optimisation du recyclage mémoire par la JVM
        1. Stratégie d’évacuation
      3. La zone du tas (heap) de HotSpot
        1. Autres recycleurs ou collecteurs
          1. Le collecteur ParallelOld
          2. Le collecteur CMS (Concurrent Mark and Sweep)
      4. Finalisation
        1. Quelques détails concernant la finalisation
      5. Programmation à concurrence en Java
        1. Durée de vie d’un exétron
          1. Visibilité et mutabilité des objets
          2. Sécurité de la concurrence
        2. Mécanisme d’exclusion et protection d’état
          1. Le mot clé volatile
        3. Sélection de méthodes de Thread
          1. getId()
          2. getPriority() et setPriority()
          3. setName() et getName()
          4. getState()
          5. isAlive()
          6. start()
          7. interrupt()
          8. join()
          9. setDaemon()
          10. setUncaughtExceptionHandler()
        4. Quelques méthodes obsolètes de Thread
          1. stop()
          2. suspend(), resume() et countStackFrames()
          3. destroy()
      6. Conseils d’utilisation des exétrons
      7. Conclusion
  7. PARTIE II. Utilisation de la plate-forme Java
    1. CHAPITRE 7. Conventions de rédaction et documentation
      1. Conventions de nommage et de capitalisation
        1. Modules
        2. Noms des paquetages
        3. Noms des classes
        4. Noms des interfaces
        5. Noms des méthodes
        6. Noms des champs et constantes
        7. Noms des paramètres de méthodes
        8. Noms des variables locales
      2. Conseils pratiques de nommage
      3. Commentaires documentaires Java
        1. Structure d’un docomment
        2. Balises de docomment
          1. @author nom
          2. @version texte
          3. @param nom-paramètre description
          4. @return description
          5. @exception nomclasse_complet description
          6. @throws nomclasse_complet description
          7. @see référence
          8. @deprecated explication
          9. @since version
          10. @serial description
          11. @serialField Nom type description
          12. @serialData description
        3. Balises docomment en ligne {}
          1. {@link reference }
          2. {@linkplain reference }
          3. {@inheritDoc}
          4. {@docRoot}
          5. {@literal texte }
          6. {@code texte }
          7. {@value}
          8. {@value reference }
        4. Références croisées dans les docomments
          1. nom_paquetage
          2. nom_paquetage.nom_type
          3. nom_type
          4. nom_type#nom_méthode
          5. nom_type#nom_méthode ( type_param)
          6. #nom_méthode
          7. #nom_méthode ( type_param )
          8. nom_type#nom_champ
          9. #nom_champ
        5. Docomments de paquetages
      4. Outils documentaires Doclets
      5. Bonnes pratiques de portabilité
        1. Méthodes natives
        2. La méthode Runtime.exec()
        3. La méthode System.getenv()
        4. Classes non documentées
        5. Fonctions dépendantes de l’implémentation
        6. Bogues opportunistes
        7. Comportements spécifiques
        8. Définition des classes système
        9. Noms de fichiers codés littéralement
        10. Sauts de ligne et retours chariot
    2. CHAPITRE 8. Les collections de données Java
      1. Introduction à l’APICollections
        1. L’interface Collection
        2. L’interface Set (ensemble)
        3. L’interface List
          1. Parcours par itération et boucles for each
          2. Accès direct (random) aux éléments d’une liste
        4. L’interface de dictionnaire Map
        5. Les interfaces Queue et BlockingQueue
        6. Ajout d’éléments à une queue
          1. add()
          2. offer()
          3. put()
        7. Suppression d’éléments d’une queue
          1. remove()
          2. poll()
          3. take()
          4. drainTo()
        8. Interrogations ou requêtes
          1. element()
          2. peek()
        9. Méthodes utilitaires
          1. Collections spécifiques
        10. Tableaux et méthodes support (helper)
      2. Flux Java Streams et expressions lambda
        1. Approche fonctionnelle
          1. Sélection avec filter()
          2. map()
          3. forEach()
          4. reduce()
        2. L’APIStreams
        3. Évaluation optimisée (lazy)
          1. Méthodes utilitaires par défaut des flux
            1. Collection::removeIf
            2. Map::forEach
            3. Map::computeIfAbsent
      3. Conclusion
    3. CHAPITRE 9. Gestion des formats de données standard
      1. Le format texte
        1. Syntaxe spécifique des chaînes
          1. Littéraux chaîne
          2. Conversion avec toString()
          3. Concaténation de chaînes
          4. Immutabilité des chaînes
          5. Codes de hachage et immutabilité effective
        2. Expressions régulières (regexp)
      2. Nombres et librairies Math
        1. Représentation des types entiers dans Java
        2. Les numériques flottants Java
          1. BigDecimal
          2. La librairie mathématique standard de Java
      3. Dates et heures en Java 8
        1. Présentation de l’API de date et heure de Java 8
          1. Composants d’une horodate (timestamp)
          2. Un exemple de traitement de date
        2. Requêtes de dates
        3. Ajusteurs temporels
        4. Ancienne approche date et heure
      4. Conclusion
    4. CHAPITRE 10. Gestion de fichiers et entrées/sorties (I/O)
      1. Entrées/sorties Java classiques
        1. Les méthodes de File
        2. Les flux d’entrées/sorties (streams)
        3. Lecteurs et scripteurs
        4. Retour sur la technique TWR (try avec ressources)
        5. Problèmes des entrées/sorties classiques
      2. Les entrées/sorties Java modernes
        1. La classe Files
        2. Les chemins d’accès Path
      3. Canaux et tampons de NIO
        1. Tampon ByteBuffer
        2. Tampon d’octets « mappé »
      4. Entrées/sorties asynchrones
        1. Interface Future
          1. isDone()
          2. get()
          3. Mode asynchrone avec fonction de rappel
        2. Services de guet Watch et scrutation de répertoire
      5. API réseau de Java
        1. HTTP
        2. La couche TCP
        3. IP
    5. CHAPITRE 11. Chargement de classes, Reflection et handles de méthodes
      1. Fichiers de classes, objets de classes et métadonnées
        1. Quelques exemples d’objets Class
        2. Objets Class et métadonnées
      2. Phases du chargement de classes
        1. Préchargement ou implantation
        2. Vérification
        3. Préparation et résolution
        4. Initialisation
      3. Chargement de classes et sécurité
      4. Fonctionnement du chargement de classes
        1. Hiérarchie des chargeurs de classes
        2. Le chargeur primordial, Bootstrap
        3. Les chargeurs de classes de niveau plate-forme
        4. Le chargeur de classes d’application
        5. Chargeurs de classes spécifiques
      5. Le mécanisme Reflection
        1. Quand utiliser Reflection
        2. Comment utiliser Reflection
        3. Les objets Method
        4. Problèmes liés à Reflection
        5. Proxy dynamiques
      6. Handles de méthodes
        1. L’objet MethodType
        2. Consultation de méthodes (lookup)
        3. Appel d’un handle de méthode
    6. CHAPITRE 12. Les modules de plate-forme. Java (JPMS)
      1. Pourquoi des modules ?
        1. Modularisation du JDK
      2. Conception d’un nouveau module
        1. Syntaxe élémentaire des modules
        2. Conception d’une application modulaire simple
        3. Le chemin de modules
        4. Modules automatiques
        5. Modules ouverts
        6. Services
        7. JAR multiversions
        8. Conversion vers un JAR multiversions
        9. Migration vers les modules
        10. Images exécutables spécifiques
      3. Points sensibles des modules
        1. Unsafe et autres problèmes de sécurité
        2. Absence de versionnage
        3. Lenteur du rythme d’adoption des modules
      4. Conclusion
    7. CHAPITRE 13. Outils de la plate-forme
      1. Outils sur ligne de commande
        1. javac
          1. Description
          2. Options principales
          3. Notes
        2. java
          1. Description
          2. Options principales
          3. Notes
        3. jar
          1. Syntaxe typique
          2. Description
          3. Options de mode
          4. Modificateurs
          5. Notes
        4. javadoc
          1. Syntaxe typique
          2. Description
          3. Options principales
          4. Notes
        5. jdeps
          1. Syntaxe typique
          2. Description
          3. Options principales
          4. Notes
        6. jps
          1. Syntaxe typique
          2. Description
          3. Options principales
          4. Notes
        7. jstat
          1. Syntaxe typique
          2. Description
          3. Options principales
          4. Notes
        8. jstatd
          1. Syntaxe typique
          2. Description
          3. Notes
        9. jinfo
          1. Syntaxe typique
          2. Description
          3. Options principales
          4. Notes
        10. jstack
          1. Syntaxe typique
          2. Description
          3. Options principales
          4. Notes
        11. jmap
          1. Syntaxe typique
          2. Description
          3. Options principales
          4. Notes
        12. javap
          1. Syntaxe typique
          2. Description
          3. Options principales
          4. Notes
        13. jaotc
          1. Syntaxe typique
          2. Description
          3. Options principales
          4. Notes
        14. jlink
          1. Syntaxe typique
          2. Description
          3. Options principales
          4. Notes
        15. jmod
          1. Syntaxe typique
          2. Description
          3. Modes de base
          4. Options principales
          5. Notes
      2. L’interpréteur JShell
      3. Conclusion
    8. ANNEXE A. Nashorn et VisualVM
      1. Présentation de Nashorn
        1. Les langages autres que Java dans la JVM
        2. Raisons d’être de Nashorn
      2. Exécution de JavaScript par Nashorn
        1. Exécution sur la ligne de commande
        2. L’interpréteur Nashorn jjs
      3. Nashorn et javax.script
        1. Utilisation de javax.script avec Nashorn
        2. L’API javax.script
          1. ScriptEngineManager
          2. ScriptEngine
          3. Liaisons Bindings
      4. Concepts Nashorn avancés
        1. Appel de Java depuis Nashorn
        2. JavaClass et JavaPackage
        3. Fonctions JavaScript et expressions lambda de Java
        4. Extensions de JavaScript dans Nashorn
          1. Boucles de répétition à itération for each in
          2. Fonctions mono-expression
          3. Clauses catch multiples
          4. Les coulisses de Nashorn
      5. Le futur de Nashorn et GraalVM
      6. VisualVM
  8. Sommaire

Product information

  • Title: Programmer avec Java
  • Author(s): Benjamin Evans, David Flanagan
  • Release date: March 2019
  • Publisher(s): Editions First
  • ISBN: 9782412045121