Warning: include(./redir.php): failed to open stream: No such file or directory in /home/developpez/www/developpez-com/upload/djibril/java/livres/index.php on line 74

Warning: include(): Failed opening './redir.php' for inclusion (include_path='.:/opt/php56/lib/php') in /home/developpez/www/developpez-com/upload/djibril/java/livres/index.php on line 74
Les meilleurs livres Java, Java EE, Spring, Android
Warning: filemtime(): stat failed for /home/developpez/www/developpez-com/upload/djibrilhttps://www.developpez.com/template/kit/developpez-kit-generation.css in /home/developpez/www/developpez-com/template/entete.php on line 405

Warning: filemtime(): stat failed for /home/developpez/www/developpez-com/upload/djibrilhttps://www.developpez.com/template/kit/code.css in /home/developpez/www/developpez-com/template/entete.php on line 405

Warning: filemtime(): stat failed for /home/developpez/www/developpez-com/upload/djibrilhttps://www.developpez.com/template/kit/lightbox.2.51.css in /home/developpez/www/developpez-com/template/entete.php on line 405

Warning: filemtime(): stat failed for /home/developpez/www/developpez-com/upload/djibrilhttps://www.developpez.com/public/css/index2.css in /home/developpez/www/developpez-com/template/entete.php on line 405
IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Warning: include(): http:// wrapper is disabled in the server configuration by allow_url_include=0 in /home/developpez/www/developpez-com/upload/djibril/java/livres/index.php on line 77

Warning: include(http://java.developpez.com/index/rightColumn): failed to open stream: no suitable wrapper could be found in /home/developpez/www/developpez-com/upload/djibril/java/livres/index.php on line 77

Warning: include(): Failed opening 'http://java.developpez.com/index/rightColumn' for inclusion (include_path='.:/opt/php56/lib/php') in /home/developpez/www/developpez-com/upload/djibril/java/livres/index.php on line 77

Les livres Java SEConsultez tous les livres

Dernière mise à jour : 8 février 2013 

precedentsommairesuivant
  1. Java 7
  2. Java - La maîtrise - 2ème édition - Java 5 et 6
  3. Les Design Patterns en Java : Les 23 modèles de conception fondamentaux
  4. Programmation concurrente en Java
  5. Java 6 : Entraînez-vous et maîtrisez Java par la pratique - Collections : Les TP Informatiques
  6. Hardcore Java
  7. Groovy in Action
  8. Harnessing Hibernate
  9. Effective Java - Second Edition
  10. Java - La maîtrise - 2ème édition - Java 5 et 6
  11. Filthy Rich Clients
  12. Java Persistence et Hibernate
  13. Programmer en Java
  14. Java Generics - and Collections
  15. Checking Java Programs
  16. Le guide de Survie - Java: L'essentiel du code et des commandes
  17. Swing la synthèse - Développement des interfaces graphiques en Java
  18. SCJP - Sun Certified Programmer for Java 5: (Exam 310-055)
  19. Java Tête la première - Couvre Java 5.0
  20. Les Cahiers du programmeur Swing
  21. Mieux programmer en Java - 68 astuces pour optimiser son code
  22. Exercices en Java - Couvre Java 5.0
  23. Les expressions régulières par l'exemple
  24. Java en concentré - Manuel de référence pour Java
  25. Les cahiers du programmeur - Java 1.4 et 5.0
  26. Aide-Mémoire de Java
  27. Refactoring des applications Java/J2EE
  28. Au coeur de Java 2, Volume 2, Fonctions avancées JDK 5.0
  29. Cahiers du programmeur : Java/XML
  30. Ant précis & concis
  31. Programmation Orienté Aspect pour Java / J2EE
  32. Java & XSLT
  33. Au Coeur de Java 2 JDK 5, Vol.1 - Notions Fondamentales
  34. Java Efficace - Guide de Programmation
couverture du livre Java 7

Note 3.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Java 7

de Robert Chevallier
Public visé : Débutant

Résumé de l'éditeur

Très pédagogique, ce livre fournit un cadre pratique pour acquérir une bonne maîtrise du langage Java. Il étudie chacune des notions de programmation objet : les classes, les objets, l'envoi de messages et l'encapsulation ; l'héritage, la composition et l'association de classes ; la réalisation de structures d'objets et d'interfaces graphiques ; la généricité.

Cette nouvelle édition présente les enrichissements proposés par la dernière version de Java (Java SE 7) afin d'améliorer la compatibilité et la performance des applications : l'écriture des valeurs numériques ; l'emploi de l'instruction switch ; la définition des types génériques ; la simplification du traitement des erreurs d'exécution ; la gestion automatique des ressources.

Les exercices, qui occupent la moitié du livre, sont intégralement corrigés. Tous les programmes étudiés sont opérationnels et montrent comment résoudre les problèmes posés.

La progression pédagogique, les nombreuses illustrations et les exercices riches et variés font de ce livre un outil d'apprentissage et de révision indispensable pour les étudiants et les professionnels.

250 pages, 1° edition édition,

Édition Campus Press / Pearson

ISBN10 : 274407537X

ISBN13 : 9782744075377

Commandez sur www.amazon.fr :

20,90 € TTC (prix éditeur 22 € TTC) livraison gratuite !
  • Classe, objets et variables
  • Les méthodes surchargées et les méthodes static
  • Les classes String, StringBuffer et Math
  • Envois de messages et encapsulation
  • Composition et association
  • Structures d'objets et sérialisation
  • Héritage simple, classes abstraites et interfaces
  • Conversion, autoboxing, transtypage et généricité
  • Les interfaces graphiques avec Swing
  • Annexe A. Installation de Java
  • Annexe B. La classe Saisie

 
Critique du livre par la rédaction Benwit le 1er octobre 2011 

Que penser du livre "Java 7" publié aux éditions Pearson ?

Si on se fie uniquement au titre "Java 7" et qu'on s'attend à découvrir les ajouts de cette nouvelle version de Java, on sera fortement déçu. Le titre est trompeur car à part quelques lignes en page 4, je cherche toujours les chapitres qui devaient détailler ces nouveautés de la version 7.

En revanche, si on se fie au descriptif de la collection "Synthèse de cours et exercices corrigés", le contrat est cette fois respecté. Le contenu du livre correspond effectivement à celui d'un cours dispensé à des étudiants d'IUT ou BTS. Les exercices sont nombreux et corrigés et permettront à un novice de se familiariser avec le langage et les notions de la Programmation Orientée Objet.

En tant que professionnel expérimenté, les conventions de nommage et les simplifications de l'auteur me déplaisent. Cependant, je pense que je ne suis pas le bon public et que cet ouvrage pourra bien convenir à un lecteur débutant.

Si vous ne connaissez pas Java, ce livre vous sera profitable sinon passez votre chemin.

Commentez Donner une note à l´article (4)

 
couverture du livre  Java - La maîtrise

Note 4.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Java - La maîtrise

2ème édition - Java 5 et 6

de Jérôme Bougeault
Public visé : Débutant - Intermédiaire

Résumé de l'éditeur

Acquérir rapidement une solide maîtrise du langage Java - Conçu sous forme de modules très pratiques accompagnés d'exercices et de FAQ, ce guide d'autoformation est destiné à tout programmeur débutant en Java et souhaitant acquérir rapidement une solide maîtrise de ce langage de programmation.

Cette seconde édition porte sur les versions 5 et 6 du langage dans sa version standard (Java Standard Edition). Il couvre la syntaxe de base du langage, les techniques de programmation objet, ainsi que les principales bibliothèques de Java S2 : JDBC, AWT et Swing, Java.net, etc.

Cet ouvrage peut également être utilisé comme support pour la préparation aux certifications Sun Certified Java Associate (SCJA), Sun Certified Java Programmer (SCJP) et Sun Certified Java Developer (SCJD).

550 pages, 2 édition,

Édition Eyrolles

ISBN10 : 2212122500

ISBN13 : 9782212122503

Commandez sur Eyrolles : 42,75  € TTC

Commandez sur www.amazon.fr :

42.75  € TTC (prix éditeur 42,75  € TTC) livraison gratuite !
  • Préambule
  • Module 1 : Introduction
  • Module 2 : Eléments du langage
  • Module 3 : Concepts objet avec Java
  • Module 4 : Les exceptions
  • Module 5 : Classes utiles en Java
  • Module 6 : Les entrée/sorties
  • Module 7 : Les collections d'objets
  • Module 8 : Java et le multi-thread
  • Module 9 : AWT et le développement d'interfaces graphiques
  • Module 10 : La gestion des événements
  • Module 11 : Accès aux bases de données avec JDBC
  • Module 12 : Les JavaBeans
  • Module 13 : JFC et Swing
  • Module 14 : Programmation Internet et réseau
  • Index
  • Annexe A : Installation du poste stagiaire
  • Annexe B : Description des outils du JDK
  • Annexe C : Documenter ses programmes avec Javadoc
  • Annexe D : Prise en mains de NetBeans
  • Annexe E : Access et MySQL
  • Annexe F : Corrigé des exercices
  • Annexe G : Glossaire

 
Critique du livre par la rédaction Hinault Romaric

Le langage Java est présenté très souvent comme le langage orienté objet par excellence, sans toutefois qu'on explique clairement le pourquoi. De même, on dit de lui que c'est l'un des tous meilleurs langages sans justifier avec exactitude les raisons qui font de lui, le langage ce qu'il est.

Ce livre a le mérite de lever toutes ses incompréhensions : en effet, dès le début de cet ouvrage, l'accent est mis sur les caractéristiques du langage, le pourquoi de ce dernier et surtout les critères pertinents qui permettent à tout chef de projet informatique de faire des choix techniques en fonction du problème qu'il veut résoudre.

Les concepts objets y sont clairement expliqués et leur implémentation avec Java y est présentée via des exemples de code simples et concis.

Ce livre est donc un précieux guide pour toute personne qui souhaite « maitriser » Java ou pour celui qui voudrait préparer les certifications Java. Il a le mérite d'être suffisamment exhaustif sur les principaux concepts de ce langage, de façon à vous assurer une prise en main totale de celui-ci.

 
couverture du livre Les Design Patterns en Java : Les 23 modèles de conception fondamentaux

Note 3.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Les Design Patterns en Java : Les 23 modèles de conception fondamentaux

de Steven-John Metsker, William-C Wake
Public visé : Expérimentés

Résumé de l'éditeur

Tout programmeur Java se doit de connaître les 23 design patterns fondamentaux recensés par les célèbres développeurs du Gang of Four, véritable condensé de l'expérience de plusieurs générations de développeurs, et aujourd'hui incontournable pour écrire un code propre et efficace.
Cet ouvrage, fondé sur de nombreux exemples d'application, vous aidera à comprendre ces modèles et développera votre aptitude à les appliquer dans vos programmes.
Forts de leur expérience en tant qu'instructeurs et programmeurs Java, Steve Metsker et William Wake vous éclaireront sur chaque pattern, au moyen de programmes Java réels, de diagrammes UML, de conseils sur les bonnes pratiques et d'exercices clairs et pertinents. Vous passerez rapidement de la théorie à l'application en apprenant comment écrire un meilleur code ou restructurer du code existant pour le rationaliser, le rendre plus performant et plus facile à maintenir.

Commentez Donner une note à l´article (3)

520 pages, 2ème édition, 3 décembre 2009 

Édition CampusPress

ISBN10 : 2744023965

ISBN13 : 9782744023965

Commandez sur www.amazon.fr :

39,90 € TTC (prix éditeur 42 € TTC) livraison gratuite !
  • Introduction
  • Introduction aux interfaces
  • ADAPTER
  • FACADE
  • COMPOSITE
  • BRIDGE
  • Introduction à la responsabilité
  • SINGLETON
  • OBSERVER
  • MEDIATOR
  • PROXY
  • CHAIN OF RESPONSABILITY
  • FLYWEIGHT
  • Introduction à la construction
  • BUILDER
  • FACTORY METHOD
  • ABSTRACT FACTORY
  • PROTOTYPE
  • MEMENTO
  • Introduction aux opérations
  • TEMPLATE METHOD
  • STATE
  • STRATEGY
  • COMMAND
  • INTERPRETER
  • Introduction aux extensions
  • DECORATOR
  • ITERATOR
  • VISITOR
  • A. Recommandations
  • B. Solutions
  • C. Code source d'Oozinoz
  • D. Introduction à UML

 
Critique du livre par la rédaction Vallée Nicolas le 1er octobre 2010 

Cet ouvrage se veut une présentation thématique de design patterns. En effet, les auteurs ont choisi de regrouper par "idée fonctionnelle" les designs patterns afin de présenter les concepts similaires de manière assez proche.
Un autre point intéressant, cet ouvrage est construit comme un cahier d'exercices. Au fur et à mesure de sa lecture, le lecteur est invité à compléter en exercice les exemples présentés, afin de lui faire appliquer immédiatement les concepts présentés, et ainsi faciliter leur assimilation. Bien entendu, les corrigés se trouvent en annexe.

Quelques critiques...
Tout d'abord, l'auteur a choisi d'illustrer son ouvrage à l'aide d'un exemple directeur. Cette idée est intéressante: le lecteur est censé pouvoir se raccrocher à ce fil conducteur, et mieux cerner le schéma global de ce micro-projet. Malheureusement le domaine choisi, à savoir une usine de fabrication de feux d'artifices, n'est pas parlant pour un profane.
Ensuite, cet ouvrage semble être une traduction littéraire. De nombreux points auraient certainement pu mieux respecter les expressions idiomatiques de la langue française.
Enfin, le niveau de cet ouvrage est signalé comme étant avancé, ce qui est loin d'être le cas selon moi. Les concepts ne sont pas poussés dans leur retranchement, un lecteur averti y verrait plutôt une application quasi-immédiate. Par ailleurs, sa notion de polymorphisme est tout simplement incomplète, car restreinte à l'application de LSP. Or depuis Java 1.5, le polymorphisme paramétrique est disponible, et il aurait été intéressant de voir ce qu'il impliquait dans la conception.

 
couverture du livre Programmation concurrente en Java

Note 5.0drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Programmation concurrente en Java

de Brian Goetz
Traducteur(s) : Eric Jacoboni
Public visé : Intermédiaires,Expérimentés

Résumé de l'éditeur

La programmation concurrente permet l'exécution de programmes en parallèle. A l'heure où les processeurs multicoeurs sont devenus un standard, elle est désormais incontournable, et concerne tous les développeurs Java. Mais l'écriture d'un code qui exploite efficacement la puissance des nouveaux processeurs et supporte les environnements concurrents représente un défi à la fois en termes d'architecture, de programmation et de tests. Le développement, le test et le débogage d'applications multithreads s'avèrent en effet très ardus car, évidemment, les problèmes de concurrence se manifestent de façon imprévisible. Ils apparaissent généralement au pire moment - en production, sous une lourde charge de travail. Le but de ce livre est de répondre à ces défis en offrant des techniques, des patrons et des outils pour analyser les programmes et pour encapsuler la complexité des interactions concurrentes. Il fournit à la fois les bases théoriques et les techniques concrètes pour construire des applications concurrentes fiables et adaptées aux systèmes actuels - et futurs.

10 commentaires Donner une note à l´article (4)

370 pages, 1ère édition, 05/2009 

Édition Pearson Education

ISBN10 : 2744023337

ISBN13 : 978-2-7440-2333-0

18,5 cm x 23 cm, 795g

Commandez sur www.amazon.fr :

37,05 € TTC (prix éditeur 39 € TTC) livraison gratuite !
  1. Les bases
    • Thread safety
    • Partage des objets
    • Composition d'objets
    • Briques de base
  2. Structuration des applications concurrentes
    • Exécution des tâches
    • Annulation et arrêt
    • Pools de threads
    • Applications graphiques
  3. Vivacité, performances et tests
    • Éviter les problèmes de vivacité
    • Performances et adaptabilité
    • Tests des programmes concurrents
  4. Sujets avancés
    • Verrous explicites
    • Construction de synchronisateurs personnalisés
    • Variables atomiques et synchronisation non bloquante
    • Le modèle mémoire de Java

 
Critique du livre par la rédaction benwit le 08/2010 

"Programmation concurrente en Java" est un ouvrage qui peut intimider au premier abord. Avec un titre pareil, s'il ne fait aucun doute que le développeur concerné par le sujet fait partie du lectorat visé, qu'en est-il d'un public plus large ? Peut-il intéressé un développeur Java plutôt habitué à des programmes monothread ?

Si la présence du mot "Java" me laissait penser qu'il était orienté pratique, le sujet me semblait quand même assez spécifique. Quand j'ai décidé de le lire, c'était donc plus par curiosité. Bien m'en a pris et je vais vous expliquer pourquoi.

Sur la forme tout d'abord.

Cet ouvrage fait partie d'une collection "Référence" particulièrement soignée. Je n'ai relevé aucun problème de traduction et je tenais à le souligner car je sais que certains développeurs préfèrent parfois la version originale pour les éviter.

La table des matières est très détaillée et illustre bien via son plan progressif à quel point l'ouvrage est didactique.

J'ai particulièrement apprécié des choses que l'on voit trop rarement :

  • Dans la présentation, l'auteur expose les prérequis et situe son ouvrage, nous dit ce qu'il est, ce qu'il n'est pas et le cas échéant, il nous oriente vers des ouvrages plus indiqués ! Un must.
  • Les nombreux exemples sont tous référencés dans une table des listings et même si le sujet s'y prête bien, ils sont de trois types : les mauvais, les moyens et les bons.

Sur le fond ensuite.

Jusque là, je n'avais qu'effleuré la programmation concurrente. Je l'avais plus ou moins rencontré dans des applications desktop (Swing) ou dans des applications web (Servlet) mais elle nous concerne bien plus que je l'imaginai (Les threads sont partout !).

Avec cet ouvrage, vous comprendrez entre autres :

  • pourquoi les interfaces graphiques sont monothread !
  • pourquoi de nombreux programmes ne sont pas corrects !
  • pourquoi les plantages de la production ne sont pas causés par des ondes alpha !
  • pourquoi tant qu'on a pas compris ce qu'est la thread-safety, on ne sait pas programmer !

Vous verrez également que parfois, la programmation concurrente n'apporte aucune performance supplémentaire et que parfois, elle simplifie l'écriture de programmes !

Dans ce livre, j'ai appris beaucoup de vocabulaire : vivacité, réentrance, confinement, publication, ... et j'ai pu mettre des noms sur certaines de mes pratiques comme le "confinement dans la pile". J'ai également découvert la richesse des API Java (AtomicXXX et le framework Executor, ...)

En plus de toutes ces explications théoriques, cet ouvrage se veut également un guide pratique pour nous aider dans notre activité de codage et prodigue de nombreux conseils tirés de 20 ans d'expériences.

Bref, vous l'aurez compris, j'ai aimé ce livre et je le conseille à tous les développeurs Java intermédiaire/avancé. Je n'ai qu'un seul regret, ne pas l'avoir lu plus vite !

Critique du livre par la rédaction Eric Reboisson le 1er décembre 2010 

Un livre de moins de 400 pages où beaucoup de choses intéressantes sont dites sur la programmation concurrente en Java, c'est tout l'objectif de "Programmation concurrente en Java".

Le livre est découpé en plusieurs parties : une première aborde les bases de la concurrence, de la "thread safety" et de la composition de classes concurrentes. Une seconde partie montre comment une bonne utilisation de la concurrence peut améliorer la réactivité et la performance des applications (utilisation de pool de threads...). Une troisième partie aborde le test des applications concurrentes pour s'assurer du bon fonctionnement du code. Enfin, une dernière partie couvre des aspects avancés de la programmation concurrente. A noter que la table des matières est très détaillée, permettant de retrouver rapidement un sujet recherché.

On trouvera tout au long du livre des exemples de codes sur ce qu'il est bon de faire et à éviter pour obtenir un code concurrent sécurisé, performant et maintenable. On trouvera ainsi des modèles d'utilisation de la programmation concurrente que l'on pourra réutiliser dans des projets réels comme par exemple la meilleure manière de gérer un cache en utilisant des threads (en principe le code du livre est disponible sur le site de Pearson, mais je n'ai pas encore trouvé l'endroit).

Pas toujours évident, le sujet de la programmation concurrente ne s'adresse pas au débutant en programmation et nécessite une bonne connaissance de Java, ou au moins quelques connaissances pour réussir à suivre. L'auteur de ce livre réussi tout de même à faire passer la pilule sur un sujet qui n'est pas des plus amusants à première vue. En tout cas, je conseille ce livre à tous ceux que la programmation concurrente intéresse, car il me semble que cet ouvrage est une petite bible sur le sujet.

 
couverture du livre Java 6 : Entraînez-vous et maîtrisez Java par la pratique

Note 3.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Java 6 : Entraînez-vous et maîtrisez Java par la pratique

Collections : Les TP Informatiques

de Alexandre Brillant
Public visé : Intermédiaires, Expérimentés

Résumé de l'éditeur

Ce livre s'adresse aux développeurs, chefs de projet ou responsables techniques désireux de découvrir et maîtriser Java 6 à travers des exercices courts et variés. Avec pour objectif d'aller au-delà de la théorie et de vous inculquer dès le départ les bons réflexes, il vous fera gagner en productivité. Si vous connaissez une version antérieure et souhaitez avoir une vision rapide de la nouvelle plateforme, vous apprécierez cette méthode d'apprentissage par l'exemple dont les solutions sont toujours appuyées par de brefs rappels de cours. Les travaux pratiques proposés couvrent l'essentiel de Java 6 : bases de la syntaxe, programmation objet, connaissances de l'API. Ils reprennent les points indispensables propres à Java (définition d'une classe, héritage, abstraction, polymorphisme, annotations) mais également les nouveautés qui font de Java 6 une source inépuisable de possibilités (web services, scripting...). Au-delà des exercices, ce livre constitue un socle de références (modèles de programmation) que vous pourrez reprendre à loisir dans vos travaux quotidiens. Les éléments nécessaires à la réalisation des exercices sont en téléchargement sur le site de l'éditeur.
119 QCM - 59 travaux pratiques et leurs corrigés - Plus de 23 H de mise en pratique.
300 pages, 05/2007 

Édition ENI

ISBN10 : 2746036134

ISBN13 : 978-2746036130

Commandez sur www.editions-eni.fr : 25,65 ? seulement (au lieu de 27 ? : prix public)

Commandez sur www.amazon.fr :

25,65 € TTC (prix éditeur 27 € TTC) livraison gratuite !
  • Chapitre 1 : Le langage
    • Pré-requis
    • Contrôle de flux
    • Exception
    • Type de données
    • Classe
    • Interface
    • Classe anonyme et interne
    • Accessibilité
    • Énumération
    • Ellipse
  • Chapitre 2 : Les collections
    • Pré-requis
    • java.util.List
    • java.util.Map
    • java.util.Set
    • java.util.Queue
  • Chapitre 3 : Les entrées/sorties
    • Pré-requis
    • Les flux binaires
    • Accès aléatoire
    • Les filtres
    • Les flux de caractères
    • Les flux mémoires
    • La sérialization
    • N/IO
  • Chapitre 4 : JDBC - Base de données
    • Pré-requis
    • Installation d'une base de données MySQL avec accès ODBC
    • Accès en lecture et écriture par Statement
    • Accès en lecture et écriture par PreparedStatement
    • Les procédures stockées
    • Les DataSources
  • Chapitre 5 : Threads
    • Pré-requis
    • La classe Thread
    • Synchronisation multithreads
    • java.util.concurrent.ExecutorService
    • java.util.concurrent.ArrayBlockingQueue
    • java.util.concurrent.Exchanger
    • java.lang.management.ThreadInfo
  • Chapitre 6 : Swing
    • Pré-requis
    • Construction d'un répertoire téléphonique
    • Construction d'un éditeur de texte
    • Mise à jour asynchrone d'une table
    • Installation d'un lookAndFeel
    • Actions
    • Tri et table
    • SystemTray
  • Chapitre 7 : JAXP - XML
    • Pré-requis
    • SAX
    • DOM
    • XPath
    • Transformation
    • JAXB
    • StAX
  • Chapitre 8 : Classes utilitaires
    • Pré-requis
    • java.lang.ProcessBuilder
    • java.util.Scanner
    • Expressions régulières
    • Préférences
    • Logs
    • Console
    • Annotations
    • Scripts
  • Chapitre 9 : Java Web Start
    • Pré-requis
    • Exécution d'une application
    • javax.jnlp.ServiceManager
  • Chapitre 10 : Services Web
    • Pré-requis
    • Création et usage d'un service Web
    • Usage d'un service Web sur un site marchand
  • Chapitre 11 : Accès réseaux
    • Pré-requis
    • Socket
    • HTTP
    • Cookie

 
Critique du livre par la rédaction Y. Charpiot le 1er mars 2009 

Quand j'ai lu ce livre, je cherchais à me mettre à jour sur Java (j'en étais resté à la 1.4) et donc je me suis dit que des cas pratiques étaient souvent plus intéressants que de longs discours théoriques.
Certes, les cas sont très pratiques, mais malheureusement les fonctionnalités de Java 5 / 6 ne sont pas très présentes. Un sous-chapitre très succint sur les Annotations, un Chapitre entier sur JDBC sans parler des nouvelles fonctionnalités de la 6, rien non plus sur les nouveautés liées aux Collections. Il y a tout de même un chapitre sur les web services ainsi qu'un sous-chapitre parlant de Stax et des scripts. On ne peut bien sur pas voir tous les aspects de Java dans un livre de 300 pages, mais dans ce cas, le titre du livre me semble mal adapté.

Je n'ai pas eu l'occasion de lire d'autre livre de cette collection mais la mise en page est très claire. Je n'ai pas eu trop de difficulté à « switcher » des énoncés aux corrections, grâce aux hauts de pages qui sont intuitifs. Le jeu des FAQs pour se tester avant chaque chapitre est très judicieux, c'est un bon moyen de faire un bilan rapide de compétence et de s'informer plus particulièrement par soi même le cas échéant (même si certaines réponses données sont discutables car non exhaustives, c'est d'autant plus gênant lorsque le public visé est débutant).
J'ai été aussi surpris par un vocabulaire approximatif. Pour ma part, il ne me semble pas assez précis, surtout lorsqu'il s'agit de vulgariser un langage (on ne parle pas d'accesseurs, ni d'instance de classe,...). Cela ne gênera toutefois pas les non puristes.

Pour finir, les corrigés sont pédagogiques et bien rédigés, je regrette juste qu'ils se concentrent trop sur la description du corrigé (on décrit ce qu'on fait) et non sur la démarche utilisée (pourquoi utiliser cette Classe plutôt qu'une autre, quel intérêt d'utiliser ce pattern, pourquoi je prends cette API et pas celle là,.). Bref, à la fin du TP on maîtrise le sujet posé, mais on n'a malheureusement pas le recul nécessaire pour l'appliquer dans un projet.
Surtout que certaines petites erreurs viennent entacher la poursuite des TPs (exemple du chapitre 7 où il manque des informations sur les fichiers styles ou une méthode main pour tester une classe).
En l'état, impossible de faire fonctionner le TP complètement. Heureusement que les corrigés sont accessibles en ligne sur le site des éditions ENI.
Encore faudrait-il le savoir !! Cela n'est écrit nulle part dans le livre. J'ai passé 2h à trouver la solution avant de voir une minuscule phrase sur la page arrière du bouquin parlant des corrigés en ligne.

Vous l'aurez compris, je n'ai pas été très tendre avec ce livre, mais c'est tout simplement parce que, comme beaucoup de personnes qui achètent ce genre de livre, je suis exigeant. Malgré cela, j'ai passé un bon moment et j'ai appris certaines choses « concrètes » ce qui au final est ce que l'on attend d'un livre de TP.

 
couverture du livre Hardcore Java

Note 4.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Hardcore Java

de Robert Simmons Jr
Public visé : Intermédiaire / Avancé

Résumé de l'éditeur

Java has quickly become one of the most important languages in programming, particularly for professional and enterprise-level projects. From its infancy as a language primarily used for web applets to its maturity through servlets, Enterprise JavaBeans, and database access, Java has become a complex and robust tool for today's developer. Hardcore Java takes this language and breaks it apart, piece by piece, revealing the important secrets and tricks that will take you from a junior-level programmer to a seasoned and expert developer. You'll fly through the fundamentals and quickly find yourself learning about advanced memory management techniques, optimization and bytecode-level enhancements, and the techniques required to build lightning-fast GUIs. Throughout the book, you'll also master the art of writing and maintaining bulletproof and error-proof code, all while grasping the intricacies of the Java language. Hardcore Java covers:

  • Use of the final keyword to optimize and protect your Java classes.
  • Complete and thorough coverage of all types of nested classes, including how to optimize anonymous and inner classes.
  • Detailed discussion of immutable objects, including unique tips on when to use them (and when not to).
  • Elimination of bugs through exception-handling management.
  • In-depth studies of constants, including their impact on the Java memory model.
  • The most thorough discussion of reflection in print, moving far beyond other books' "Hello World" coverage.
  • Construction and use of dynamic proxies, in both Java Standard and Enterprise editions.
  • Expansive coverage of weak references, including usage patterns and their role in garbage collection and memory management.

Hardcore Java is an invaluable addition to every programmer's library, and even the most advanced developers will find themselves moving beyond their own conceptions into truly advanced applications of the language. Thousands of lines of code, heavily commented and easily runnable, illustrate each concept in the book.

400 pages, 1ère édition, 1er janvier 2004 

Édition O'Reilly

ISBN10 : 0596005687

ISBN13 : 978-0596005689

Commandez sur www.amazon.fr :

39.95 € TTC (prix éditeur 39.95 € TTC) livraison gratuite !
  • 1. Java in Review
  • 2. The Final Story
  • 3. Immutable Types
  • 4. Collections
  • 5. Exceptional Code
  • 6. Nested Classes
  • 7. All About Constants
  • 8. Data Modeling
  • 9. Practical Reflection
  • 10. Proxies
  • 11. References in our Flavors
  • 12. Tiger: JDK 1.5

 
Critique du livre par la rédaction Baptiste Wicht le 12/2008 

Ce livre présente plusieurs particularités du langage Java ainsi que beaucoup de trucs et astuces permettant d'utiliser au mieux ce language.

Le premier chapitre passe en revue les particularités du langage Java. Il met en avant quelques spécialités du langage et démontre quelques erreurs qui sont communes aux programmeurs Java. Le chapitre suivant est complètement dedié au mot clé final. Il parle de l'utilité du mot clé final pour les champs, les méthodes et les classes. Ce chapitre traite aussi de la compilation conditionelle. Le chapitre suivant est dediée aux objets immuables, de leur conception à leur utilité.

Le quatrième chapitre est entièrement dedié aux collections du langage Java. Il présente les différents types de Collection que propose l'API standard et les différents concepts qu'il est utile de connaître pour choisir une collection. Ce chapitre ne se contente pas de lister les différentes collections, il va décrire en détails les mécanismes de chacune de ces dernières. Il va également traiter de la performance des collections et des arguments pouvant conduire au choix de l'une ou de l'autre collection.

Le chapitre 5 décrit le mécanisme des exceptions dans Java. Il présente également les bonnes manières de gérer les exceptions dans un programme Java. Le chapitre suivant décrit en profondeur le système des classes internes. Il va décrire tous les types de classes internes, leur utilité et leur utilisation. Il donne aussi un résumé de ce que peut faire et ne peut pas faire chaque type de classe interne.

Le chapitre 7 traite des constantes. Il parle des constantes de substition, des objets constants et des options constantes. Il traite également des "bit fields" qui sont des variables combinant plusieurs états vrais-faux. Avec le chapitre suivant, on passe dans la modélisation des données. Ce chapitre indique tous les points auxquels il faut faire attention quand on modélise un modèle de données. Il traite des contraintes sur le modèle, du langage de modélisation naturel et du choix entre une base de données orientée objet ou relationnelle.

Le chapitre suivant traite de la réflection et son utilité dans un programme Java. Un premier exemple utilise la reflection pour faciliter le logging des classes et un autre pour les tests unitaires. Le chapitre 10 décrit les proxies. Il va décrire le proxy statique et le proxy dynamique généré directement par Java. L'avant-dernier chapitre décrit les références et présente les différentes utilités de chacun des types de référence présente dans le langage Java. Enfin le dernier chapitre repasse sur les nouveautés de Tiger. Ce chapitre n'est utile qu'aux personnes ne connaissant pas encore ces nouveautés.

En conclusion, ce livre est très bon pour compléter ses connaissances sur le Java. En effet, ce livre traite de sujets qui ne sont habituellement pas traités dans les autres livres que j'ai pu lire sur Java. Néanmoins, j'ai trouvé que certains chapitres n'allaient pas assez en profondeur dans leur sujet. Cependant, ce livre m'a permis d'appréhender des sujets encore quasi-inconnus et d'en approfondir d'autres. Je conseille ce livre à tous les utilisateurs du langage Java qui n'ont pas forcément encore poussé à fond dans le langage.

 
couverture du livre Groovy in Action

Note 4.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Groovy in Action

de Dierk Koenig, Andrew Glover , Paul King , Guillaume Laforge , Jon Skeet
Public visé : Débutant

Résumé de l'éditeur

Groovy, the brand-new language for the Java platform, brings to Java many of the features that have made Ruby popular. Groovy in Action is a comprehensive guide to Groovy programming, introducing Java developers to the new dynamic features that Groovy provides. To bring you Groovy in Action, Manning again went to the source by working with a team of expert authors including both members and the manager of the Groovy Project team. The result is the true definitive guide to the new Groovy language.

Groovy in Action introduces Groovy by example, presenting lots of reusable code while explaining the underlying concepts. Java developers new to Groovy find a smooth transition into the dynamic programming world. Groovy experts gain a solid reference that challenges them to explore Groovy deeply and creatively.

Because Groovy is so new, most readers will be learning it from scratch. Groovy in Action quickly moves through the Groovy basics, including:

  • Simple and collective Groovy data types
  • Working with closures and Groovy control structures
  • Dynamic Object Orientation, Groovy style

Readers are presented with rich and detailed examples illustrating Groovy's enhancements to Java, including

  • How to work with builders and the GDK
  • Database programming with Groovy

Groovy in Action then demonstrates how to Integrate Groovy with XML, and provides,

  • Tips and Tricks
  • Unit testing and build support
  • Groovy on Windows

An additional bonus is a chapter dedicated to Grails, the Groovy web application framework.

696 pages, 1ere édition,

Édition Manning Publications

ISBN10 : 1932394842

ISBN13 : 978-1932394849

Broché

Commandez sur www.amazon.fr :

39,35 € TTC (prix éditeur  € TTC) livraison gratuite !
  • Your way to Groovy
  • Part 1 The Groovy language
    • Overture: The Groovy basics
    • The simple Groovy datatypes
    • The collective Groovy datatypes
    • Working with closures
    • Groovy control structures
    • Dynamic object orientation, Groovy style
  • Part 2 Around the Groovy library
    • Working with builders
    • Working with the GDK
    • Database programming with Groovy
    • Integrating Groovy
    • Working with XML
    • Dynamic object orientation, Groovy style
  • Part 3 Everyday Groovy
    • Tips and tricks
    • Unit testing with Groovy
    • Groovy on Windows
    • Seeing the Grails light
  • appendix A Installation and documentation
  • appendix B Groovy language info
  • appendix C GDK API quick reference
  • appendix D Cheat sheets

 
Critique du livre par la rédaction Gildas CUISINIER (hikage)

Ce livre est tout simplement merveilleux. Bien plus qu'une introduction à Groovy, c'est une véritable bible sur le sujet. Des bases du langage à l'utilisation de Grails, tout les sujets sont traités : Testing, Parsing XML, accès aux bases de données, intégration avec Windows et les ActiveX ou encore développement Web.

Grâce à une écriture claire et légère, ce livre sera donc parfait afin de découvrir Groovy, aussi bien pour les habitués de Java que pour les autres.
De par sa complétude, ce livre sera aussi le compagnon parfait qui vous aidera sur un point précis durant un développement Groovy.

Le public que cible ce livre est d'ailleurs très large. Le développeur Web trouvera son bonheur avec les explications sur les Groovlet ou encore l'introduction à Grails. L'administrateur système sera particulièrement intéressé par les chapitres sur le scripting, la gestion des processus ou encore l'intégration Windows avec Scriptom. Les développeurs Swing ou Java ne sont pas en reste non plus.

Bref, ce livre est LE livre à posséder dès que l'on touche à Groovy.

 
couverture du livre Harnessing Hibernate

Note 3.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Harnessing Hibernate

de James Elliott, Tim O'Brien, Ryan Fowler
Public visé : Débutants

Résumé de l'éditeur

This guide is an ideal introduction to Hibernate, the framework that lets Java developers work with information from a relational database easily and efficiently. Databases are a very different world than Java objects, and with Hibernate, bridging them is significantly easier. This new edition lets you explore the system, from download and configuration through a series of projects that demonstrate how to accomplish a variety of practical goals.

380 pages, 1ère édition, 1er mai 2008 

Édition O'Reilly

ISBN10 : 0596517726

Commandez sur www.amazon.fr :

28.12 € TTC seulement (au lieu de 29.91  € TTC : prix éditeur) livraison gratuite !
  • Chapitre 1. Installation and setup
  • Chapitre 2. Introduction to mapping
  • Chapitre 3. Harnessing Hibernate
  • Chapitre 4. Collections and Associations
  • Chapitre 5. Richer Associations
  • Chapitre 6. Custom Value Types
  • Chapitre 7. The Annotation Alternative
  • Chapitre 8. Criteria Queries
  • Chapitre 9. A Look at HQL
  • Chapitre 10. Connecting Hibernate to MySQL
  • Chapitre 11. Hibernate and Eclipse: Really Using
  • Chapitre 12. Maven in More Depth
  • Chapitre 13. Put a Spring in your Step: Hibernate with Spring
  • Chapitre 14. The finishing Touch: Stripes with Spring and Hibernate

 
Critique du livre par la rédaction Pierre Chauvin

Habitué à d'autres formes de persistence et ORM avec le langage Java, Harnessing Hibernate est ma première lecture sur Hibernate. Les chapitres de ce livre gravitent autour d'un projet central (le traditionnel outil de gestion de collection de musique), enrichi au fur et à mesure par les fonctionnalités d'Hibernate. Installation des outils (Maven, Ant), mappings et requêtes simples, requêtes Criteria, annotations, intégration avec d'autres bases de données (HSQLDB, MySQL) et outils (Spring, Stripes, IDE Eclipse) : une vision assez globale est donnée et vous serez en mesure de construire vos premiers projets avec une couche de persistence reposant sur Hibernate, et en exploitant les primitives simples.

Néanmoins je trouve que l'auteur consacre beaucoup trop de temps aux outils annexes comme Maven (le chapitre 12!), qui nécessite à lui seul un livre, et j'aurais préféré qu'il passe davantage de temps sur des mappings plus complexes, ou encore à la gestion de cache, la gestion des sessions Hibernate. Il demeure bien construit pour un lecteur débutant, mais aura du mal à satisfaire celui-ci dés l'apparition des premiers besoins atypiques et plus complexes. Utile, mais loin d'être indispensable.

 
couverture du livre Effective Java

Note 5.0drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Effective Java

Second Edition

de Joshua Bloch
Public visé : débutants, intermédiaires, expérimentés

Résumé de l'éditeur

Le livre est composé de 78 items, découpés par catégories et couvrant Java 5. Le tout est rédigé par Joshua Bloch, architecte Java ayant participé à l'élaboration et à la maintenance du JDK, et désormais architecte Java chez Google.

384 pages, deuxième édition, 28 mai 2008 

Édition Prentice Hall PTR

ISBN10 : 0321356683

ISBN13 : 978-0321356680

Commandez sur www.amazon.fr :

38,64 € TTC (prix éditeur 38,64 € TTC) livraison gratuite !
  1. Introduction
  2. Creating and Destroying Objects
  3. Methods Common to All Objects
  4. Classes and Interfaces
  5. Generics
  6. Enums and Annotations
  7. Methods
  8. General Programming
  9. Exceptions
  10. Concurrency
  11. Serialization

 
Critique du livre par la rédaction Thibaut Cuvelier le 20 septembre 2011 

Un ensemble d'items, de gemmes pourrait-on dire, contenant des conseils de programmation en Java, tant pour le novice que pour le développeur plus expérimenté, du point de vue d'un concepteur d'API Java, tous utiles, un jour ou l'autre, vu la diversité des sujets évoqués.

Dans l'avant-propos, on remarque une citation intéressante :

This book address your third need: customary and effective usage. [...] Here he offers good advice, systematically organized, on how to structure your code so that it works well, so that other people can understand it, so that future modifications and improvements are less likely to cause headache.
Ce livre répond à votre troisième besoin : l'habitude et l'usage pratique. [...] Ici, il offre de bons conseils, systématiquement organisés, sur la manière de structurer le code pour qu'il fonctionne bien, que d'autres puissent le comprendre, que de futures modifications et améliorations ne causent pas trop de maux de tête.

C'est exactement ce qui est fait : alors que bien des livres décrivent en longueur la syntaxe du langage ou les outils disponibles, très peu se penchent sur la manière de bien les utiliser. On comprend alors les avantages mais aussi les faiblesses du langage, ce que l'on peut faire et ce qu'il est préférable d'éviter, même avec les meilleures intentions, pour que tous en bénéficient (tant les futurs mainteneurs que les utilisateurs des API).

Un point cependant que l'on pourrait reprocher : une grande partie est orientée du point de vue d'un concepteur d'API, c'est-à-dire pas vraiment le but de la majorité des développements. Ces bonnes pratiques, néanmoins, utilisées dans toute application, ne peuvent qu'améliorer le code et tout ce qui s'en suit, sans beaucoup extrapoler.

On peut donc, sans grand danger, le recommander à tout qui a déjà débuté dans le langage (il n'est pas du tout prévu pour apprendre la syntaxe, il la considère acquise en grande partie) : le seul effet sera de produire du code de meilleure qualité !

Les items ne sont pas prévus pour être lus l'un après l'autre obligatoirement, il y a souvent une série de références d'items qui approfondissent certains points, ce qui fait qu'ils sont généralement assez spécialisés - bien que, parfois, une seule page leur est dédiée, ce qui est un peu court. On peut donc utiliser ce livre comme référence constante lors d'un développement, pour avoir une approche souvent considérée comme la meilleure : tous en bénéficieront, à tout moment de l'utilisation du langage. Cependant, se limiter à le lire ne sera probablement pas suffisant : tester soi-même ce qui est proposé et les alternatives, voir pourquoi, « en vrai », la solution proposée est meilleure en général, déceler les cas où cela n'est pas tellement d'application, discuter de cela avec des experts du langage.

Cette deuxième édition a été complètement revue pour Java SE 5 et 6 et dispense donc les dernières nouveautés de ces deux versions, principalement la 5, étant donné que la mise à jour a commencé avant la sortie de Java 6.

Vous avez lu ce livre ? Qu'en pensez-vous ? 1 commentaire Donner une note à l´article (5)

Critique du livre par Joseph Pachod le 1er août 2008 

Comment dire... Pour faire simple, pour moi, ce livre devrait être obligatoire pour tous les développeurs Java. Rien de plus, rien de moins, simple non ?

Au lieu des habituels "comment faire une boucle", l'auteur y aborde comment utiliser au mieux les différents éléments constituant le langage Java, en justifiant et expliquant le tout, permettant au lecteur de bénéficier de son ample connaissance du langage. Le sommaire donne d'ailleurs une bonne idée de l'ampleur des thèmes abordés.

Pour ma part, cela m'a vraiment donné une meilleure vision du langage et des problématiques objet en général. On comprend dès lors mieux les forces et faiblesses, tout en ayant ce qu'il faut pour en tirer le maximum.

Allez, en ultime teaser, vous y trouverez comment éviter les déclarations verbeuses de génériques, comment construire proprement des objets avec plein de paramètres (éventuellement optionnels), les usages pertinents des énumérations ou de l'autoboxing... parmi milles autres remarques pertinentes !

En somme, pour peu que vous vous posiez des questions en codant, ce livre se dévore et permet vraiment un approfondissement du langage. Personnellement, j'en suis à ma deuxième lecture...

Enfin, en écrivant cette critique, je me suis rendu compte que des pointures tels James Gosling ou Heinz M. Kabutz (de Java Specialists) partageaient pleinement cette opinion. Pour conclure : foncez l'acheter !

 
couverture du livre Java - La maîtrise

Note 3.5drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Java - La maîtrise

2ème édition - Java 5 et 6

de Jérôme Bougeault
Public visé : Débutant - Intermédiaire
Introduction : Le guide de formation TSoft pour Java

Résumé de l'éditeur

Acquérir rapidement une solide maîtrise du langage Java - Conçu sous forme de modules très pratiques accompagnés d'exercices et de FAQ, ce guide d'autoformation est destiné à tout programmeur débutant en Java et souhaitant acquérir rapidement une solide maîtrise de ce langage de programmation.

Cette seconde édition porte sur les versions 5 et 6 du langage dans sa version standard (Java Standard Edition). Il couvre la syntaxe de base du langage, les techniques de programmation objet, ainsi que les principales bibliothèques de Java S2 : JDBC, AWT et Swing, Java.net, etc.

Cet ouvrage peut également être utilisé comme support pour la préparation aux certifications Sun Certified Java Associate (SCJA), Sun Certified Java Programmer (SCJP) et Sun Certified Java Developer (SCJD).

550 pages, 2ème édition, 1er février 2008 

Édition Eyrolles

ISBN10 : 2-212-12250-0

ISBN13 : 978-2-212-12250-3

19x26 - 1235g

Commandez sur www.amazon.fr :

42.75 € TTC seulement (au lieu de 45.00  € TTC : prix éditeur) livraison gratuite !
  • Préambule
  • Module 1 : Introduction
  • Module 2 : Eléments du langage
  • Module 3 : Concepts objet avec Java
  • Module 4 : Les exceptions
  • Module 5 : Classes utiles en Java
  • Module 6 : Les entrée/sorties
  • Module 7 : Les collections d'objets
  • Module 8 : Java et le multi-thread
  • Module 9 : AWT et le développement d'interfaces graphiques
  • Module 10 : La gestion des événements
  • Module 11 : Accès aux bases de données avec JDBC
  • Module 12 : Les JavaBeans
  • Module 13 : JFC et Swing
  • Module 14 : Programmation Internet et réseau
  • Index
  • Annexe A : Installation du poste stagiaire
  • Annexe B : Description des outils du JDK
  • Annexe C : Documenter ses programmes avec Javadoc
  • Annexe D : Prise en mains de NetBeans
  • Annexe E : Access et MySQL
  • Annexe F : Corrigé des exercices
  • Annexe G : Glossaire

 
Critique du livre par la rédaction Julien Ibarz le 1er septembre 2008 

Après une très bonne introduction au langage Java et notamment à la programmation orientée objet grâce à des schémas UML et des métaphores très explicites, l'auteur nous présente ensuite de façon très détaillée toute la bibliothèque standard de SUN.

On pourra regretter la faible information donnée sur les generics Java, grande nouveauté de Java 5.0. En effet, seulement 2 pages sont dédiées à ces derniers alors qu'il en faudrait un chapitre entier. Certaines parties de la bibliothèque standard ne sont que présentées et l'auteur ne fait parfois qu'une simple énumération des méthodes au lieu d'en montrer leur utilité ou leur application. Néanmoins le livre est rempli d'exemples bien faits et d'exercices très intéressants avec les solutions fournies sur le site web.

Ce livre est donc d'une qualité inégale, parfois incomplet. Ne vous attendez donc pas à maitriser Java avec ce dernier. Néanmoins il sera parfait comme support de cours, pense-bête ou pour un programmeur maitrisant déjà un langage et voulant passer sur Java.

Critique du livre par la rédaction Alp Mestan le 1er juillet 2008 

A la réception de ce livre, bien qu'ayant lu des résumés à son sujet, je ne savais pas du tout à quoi m'attendre, moi qui cherchais apprendre grâce à un bon livre le langage Java. Et je n'ai pas vraiment été déçu.

Lorsque l'on débute la lecture de ce livre, on aborde en douceur le langage Java en étudiant les différents éléments de base du langage. L'apprentissage se poursuit directement par la programmation orientée objet en présentant les concepts de base de la POO puis l'étude des exceptions en Java. Ensuite, on s'attaque à la bibliothèque standard Java en apprenant à utiliser les classes utilitaires telles que celles relatives aux mathématiques, chaînes de caractères, collections, entrées/sorties. Ensuite, le niveau augmente d'un cran avec l'approche du multithreading en Java, de la programmation graphique avec Abstract Windowing Toolkit (AWT), la gestion des évènements, l'accès aux bases de données, la programmation réseau standard, Swing, etc. Enfin, on termine par des annexes, qui présentent un tas d'outils utiles, tels que JavaDoc, Netbeans ainsi que des petits Howtos comme celui sur l'utilisation de MySQL.

A priori, l'élévation du niveau est continue et progressive, l'accent est nettement mis sur la programmation orientée objet, qui est la base même du langage Java, ce qui est bon signe. Effectivement, on ne se laisse pas dépasser par la progression grâce aux nombreux petits exemples qui démontrent de manière efficace les concepts sous-jacents et la manière d'utiliser les différentes classes. Le livre ne s'attarde toutefois pas éternellement sur chaque chose tel que le ferait (à raison) un livre sur Java pour les débutants absolus en programmation.

Je n'ai que 2 petits reproches à faire à ce livre. Le premier n'en est pas réellement un ; en effet, il s'agit simplement du fait qu'il vaut mieux avoir déjà programmé dans un langage auparavant (même un langage non-orienté objet) pour tirer parti de la densité d'informations présentées. Le deuxième est que le Java est un langage qui fait un usage très intensif des design patterns (il n'y a qu'à voir le livre du Gang of Four sur le sujet qui se base sur Java pour tous les exemples de codes). Toutefois, dans ce livre, il n'est que très peu fait mention desDPs, ce qui est regrettable car cela signifie que le lecteur devra apprendre à part l'utilisation de ces formidables modèles de conception orientée objet.

Toutefois, cela reste un livre qui a sa place dans la bibliothèque d'un développeur qui s'intéresse au langage Java et qui désire passer l'une des certifications mentionnées dans le résumé ou qui veut tout simplement pouvoir réaliser des programmes utilisant la multitude de classes fournies dans la bibliothèque standard tout en manipulant correctement les divers éléments du langage.

 
couverture du livre Filthy Rich Clients

Note 5.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Filthy Rich Clients

de Chet Haase, Romain Guy
Public visé : Intermédiaires,Expérimentés

Résumé de l'éditeur

Filthy Rich Clients refers to ultra-graphically rich applications that ooze cool. They suck the user in from the outset and hang on to them with a death grip of excitement. Filthy Rich Clients: Developing Animated and Graphical Effects for Desktop JavaT Applications shows you how to build better, more effective, cooler desktop applications that intensify the user experience.

The keys to Filthy Rich Clients are graphical and animated effects. These kinds of effects provide ways of enhancing the user experience of the application through more attractive GUIs, dynamic effects that give your application a pulse, and animated transitions that keep your user connected to the logical flow of the application. The book also discusses how to do so effectively, making sure to enrich applications in sensible ways.

608 pages, 1ère édition, 19 août 2007 

Édition Prentice Hall PTR

ISBN10 : 0132413930

ISBN13 : 9780132413930

Broché

Commandez sur www.amazon.fr :

32.01 € TTC seulement (au lieu de 33.70  € TTC : prix éditeur) livraison gratuite !
  1. Graphics and GUI Fundamentals
    1. Desktop Java Graphics APIs: Swing, AWT, and Java 2D
    2. Swing Rendering Fundamentals
    3. Graphics Fundamentals
    4. Images
    5. Performance
  2. Advanced Graphics Rendering
    1. Composites
    2. Gradients
    3. Image Processing
    4. Glass Pane
    5. Layered Panes
    6. Repaint Manager
  3. Animation
    1. Animation Fundamentals
    2. Smooth Moves
    3. Timing Framework: Fundamentals
    4. Timing Framework: Advanced Features
  4. Effects
    1. Static Effects
    2. Dynamic Effects
    3. Animated Transitions
    4. Birth of a Filthy Rich Client

 
Critique du livre par la rédaction Fabrice Bouyé le 1er mai 2008 

Il s'agit là d'un livre que j'ai longtemps attendu ; en fait, je l'attendais même sans le savoir depuis que j'ai commencé à programmer des applications clientes utilisant Swing.

En effet, l'intégration de Java2D lors de la sortie de Java 2 (1.2) dès 1998 a permis d'étendre considérablement les capacités de la plateforme Java en ce qui concerne les effets et traitements d'images et ce de manière totalement portable d'un système à l'autre. De même, Swing, sorti à la même époque, permettait enfin de faire des interfaces graphiques en s'affranchissant des limites de l'AWT, mieux Swing reposait sur Java2D. Cependant, s'il peut-être aisé de trouver des informations, cours ou livres sur Java2D et plus encore sur Swing, il est resté assez difficile de trouver des exemples d'intégration avancée entre ces deux bibliothèques hormis les démos fournies par Sun avec le JDK. Et même celles-ci ne montrent pas comment Java2D peut, littéralement, transformer et transcender Swing.

Tous les programmeurs qui ont eut à créer leur propre composant Swing ou à modifier l'affichage d'un composant existant ont du à un moment ou à un autre écrire un peu de Java2D dans leur code d'affichage ; cependant nous sommes tous généralement restés confinés à des appels des primitives pour tracer des lignes ou encore remplir de simples polygones avec des couleurs unies, personne ne sachant vraiment trop comment combiner les deux bouts ensemble. Ainsi, tandis que les nouvelles versions de Windows et MacOS se succédaient les unes aux autres apportant à chaque fois leur lot de nouveaux effets graphiques cools, les interfaces graphiques Java restaient portables, certes, mais étaient également globalement toujours aussi grises et ennuyantes.

Ne craignez rien ! Romain Guy (Gfx) et Chet Haase, les deux superstars des très populaires présentations orientées Desktop des conférences JavaOne de ces dernières années viennent ENFIN à notre rescousse ! Si vous avez déjà été explorer les tonnes d'exemples et d'astuces que Gfx a proposés sur ce site et notre forum Java ou sur son blog ou ceux que Chet a postés sur le sien, une bonne partie est condensée dans ce livre (en anglais). Avec un langage simple, clair et non dénué d'humour, les deux auteurs nous présentent tour à tour tout ce qui est nécessaire pour faire que votre application Swing sorte du lot et accroche votre utilisateur ; qu'elle puisse s'intégrer aux designs plus riches en couleurs et autres effets graphiques ainsi qu'aux nouveaux standards en matière d'ergonomie ou de présentation des OS d'aujourd'hui.

Dans la première partie de l'ouvrage, nous retrouveront, outre les conseils habituels de "bonne conduite" en ce qui concerne la programmation Swing, des astuces pour bénéficier d'optimisations des performances du rendu. La seconde partie aborde des concepts plus avancés tels que les Composites (ce qui se passe lors de la superposition de 2 rendus), les gradients de couleur, les filtres permettant de faire des traitements sur des images mais également certains concepts Swing nécessaires à l'intégration de ces effets dans une IHM tels que le Glass Pane ou encore le Repaint Manager. La troisième partie touchera quant à elle à l'animation en présentant les concepts de base de ce qui fait une animation puis en abordant le Timing Framework auquel participe Chet Haase. La dernière partie du livre aborde enfin les effets qu'il est possible de créer en combinant tout ce qui a été vu au cours des chapitres précédents ainsi que les différentes étapes de la conception et de la création d'un client "obscènement" riche (traduction libre de Filthy Rich Client).

Attention toutefois, ce livre est uniquement disponible en anglais. Il supposera que vous connaissez déjà les fondamentaux de Swing et que vous avez également quelques connaissances de la manière de dessiner, ce serait-ce qu'une ligne droite ; ce n'est en aucun cas un ouvrage d'introduction à Java2D. De plus, on pourra parfois regretter que certaines images illustrant les chapitres soient un peu petites et que l'impression en niveaux de gris ne permette pas toujours de se rendre compte du résultat final de certains des effets, notamment ceux de surbrillance.

Cependant, ce livre reste une réussite en tout point et est un "must have" pour toute personne qui désire améliorer l'apparence de son application Swing que ce soit à petite dose pour l'épicer juste ce qu'il faut ou au contraire en balançant tout le "bling-bling" d'un seul coup à la face de l'utilisateur. À noter que les exemples accompagnant chacun des chapitres du livre sont directement et gratuitement téléchargeables sur le site http://filthyrichclients.org/

 
couverture du livre Java Persistence et Hibernate

Note 4.0drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Java Persistence et Hibernate

de Anthony Patricio
Public visé : Intermédiaires,Expérimentés

Résumé de l'éditeur

Gestion optimale de la persistance dans les applications Java/JEE
Avec JPA (Java Persistance API), composante essentielle des spécifications EJB 3, le monde Java/JEE dispose enfin d'un standard fiable et efficace pour la gestion de la persistance et du mapping objet-relationnel. Largement inspiré du pragmatisme d'Hibernate et tirant parti d'une avancée majeure de Java SE 5 (les annotations), Java Persistance privilégie la simplicité de développement en plaçant les métadonnées de persistance au coeur du code Java SE ou EE et en reléguant les descripteurs XML aux cas extrêmes.

Un livre pratique illustré d'une étude de cas détaillée A la fois pratique et didactique, cet ouvrage décrit les différentes facettes de l'API et de son implémentation Hibernate en montrant comment les mettre en oeuvre à travers une étude de cas déclinée au fil des chapitres. Il insiste tout particulièrement sur la définition des annotations et l'utilisation du gestionnaire d'entités en environnement Java SE ou Java EE, ainsi que sur les aspects méthodologiques et sur les questions de performances : mapping de modèles objet ou de schémas relationnels complexes, récupération efficace des objets persistants, gestion de la concourance et persistance transitive, configuration des pools de connexions et des caches de second niveau, etc.
L'ouvrage montre également comment repousser les limites de Java Persistence API grâce aux possibilités d'optimisation et aux extensions offertes par Hibernate.

365 pages, 1ère édition, 18 décembre 2007 

Édition Eyrolles

ISBN10 : 2212122594

ISBN13 : 9782212122596

Commandez sur eyrolles.com : 39,90 € TTC seulement (au lieu de 42,00 € TTC : prix public)

Commandez sur www.amazon.fr :

39.90 € TTC seulement (au lieu de 42.00  € TTC : prix éditeur) livraison gratuite !
  1. Préface
  2. Remerciements
  3. Table des matières
  4. Avant-propos
  5. Persistance et mapping objet-relationnel
  6. Démarrer avec Java Persistence
  7. Métdadonnées et mapping des entités
  8. Héritage, polymorphisme et modèles complexes
  9. Méthodes de récupération des entités
  10. Création, modification et suppression d'entités
  11. Obtenir et manipuler le gestionnaire d'entités
  12. Fonctionnalités de mapping avancées
  13. La suite Hibernate Tools
  14. Projets annexes Java Persistence/Hibernate
  15. Index

 
Critique du livre par la rédaction theLeadingEdge le 1er octobre 2008 

Cet ouvrage est certainement le meilleur de ceux qu'il m'ait été donné de lire sur le sujet.
Agréable à lire, illustré de nombreuses captures d'écran qui renforcent les explications données, c'est un livre trés détaillé qui couvre l'ensemble des possibilités d'Hibernate.
Pour autant, même si le public visé est clairement celui des développeurs, il couvre bien plus que le simple aspect programmation.
Tout au long du livre l'auteur s'attache à nous proposer une mise en oeuvre qui va bien au delà du simple mapping mécanique entre une base de données et le modèle métier.
Pour certains cas notamemnt, il étudie plusieurs possibilités de mapping, ou de modélisation, et montre les conséquences sur les autres couches. Les stratégies de chargement les plus adaptées en fonction des différents contextes qu'il est possible de rencontrer sont également abordées dans le détail. Les concepteurs et les architectes devraient apprécier et en tirer sans aucun doute des renseignements utiles.
Mon seul regret concerne la partie technique : l'auteur a choisi de n'utiliser que les annotations. Personnellement je trouve que c'est dommage. J'aurai bien aimé trouver les exemples en XML.

Critique du livre par la rédaction Baptiste Wicht le 1er mars 2008 

Comme son titre l'indique, cet ouvrage présente Java Persistence API (JPA) avec Hibernate comme fournisseur de persistance. Ce livre ne va pas se contenter de couvrir la partie JPA, il va également explorer des fonctionnalités spécifiques à Hibernate qui permettront d'aller plus loin que les spécifications JPA.

L'auteur commence par nous présenter la problématique de la persistance et l'évolution des librairies facilitant cette tâche au fil des ans jusqu'à l'avènement de JPA. Il nous montre également les avantages d'un outil de mapping objet-relationnel. Il présente ensuite ce qu'est JPA et c'est qu'est Hibernate.

On continue avec beaucoup de pratique avec les chapitres 3 et 4. Dans ces chapitres, on va apprendre à annoter nos entités pour configurer le mapping objet-relationnel. J'ai trouvé ces chapitres très complets, mais ils vont un peu vite, ce qui est parfois déroutant car on passe d'une notion à une autre très rapidement. Ils présentent également les notions complexes comme l'héritage et le polymorphisme sur les entités.

Les deux chapitres suivants traitent quand à eux des méthodes de récupération des entités ainsi que de la façon de les gérer, c'est-à-dire les modifier, les supprimer et les créer. Ces 2 chapitres sont très complets et plus simples à suivre que les précédents. La partie récupération traite bien de toutes les manières de récupérer des objets (EJB-QL, SQL natif, Criteria). On y parle également des transactions et de la gestion des accès concourants.

Vient ensuite un chapitre sur la gestion de l'EntityManager. C'est-à-dire comment le créer ou récupérer et comment gérer son cycle de vie tout au long de l'exécution de l'application. Il traite des différentes stratégies de gestion de l'EM ainsi que du traitement par lot ou de l'utilisation dans un batch. On y traite également de l'utilisation des EJB3 pour gérer l'EntityManager. Comme je n'ai pas pu installer JBoss intégré, je n'ai pu tester cette partie. Avec le chapitre 8, on entre dans le cour d'Hibernate qui permet de faire plus de choses que la spécification JPA. On verra donc les formules, les procédures stockées, les types personnalisés, les clés composées et encore d'autres notions avancées de mapping avancés. Ces 2 chapitres traitent de notions assez complexes, mais ils les traitent bien, et on s'y retrouve facilement.

L'avant dernier chapitre parle de la suite Hibernate Tools. Il traite surtout du plugin pour Eclipse permettant de faciliter le développement JPA/Hibernate et de SchemaExport, l'utilitaire permettant de générer le schéma de la base de données. Le dernier chapitre, quant à lui, traite des autres projets autour d'Hibernate. On va notamment s'intéresser aux pools de connexion et au gestionnaire de cache de second niveau ainsi qu'à la validation des entités.

En conclusion, j'ai trouvé certaines notions de ce livre complexes à mettre en oeuvre et le plan du livre laisse parfois à désirer. L'auteur va parfois un peu trop vite et le lecteur se retrouve emmêlé entre plusieurs notions parfois très différentes. Néanmoins, ce livre présente très bien les différentes notions de JPA ainsi que les aspects avancés qui nécessitent Hibernate. Mais je ne le conseillerais pas aux débutants.

 
couverture du livre Programmer en Java

Note 4.0drapeaucdrom
Détails du livre
Sommaire
Critiques (3)
 
 

Programmer en Java

de Claude Delannoy
Public visé : Débutants,Intermédiaires,Expérimentés
Introduction : 5ème édition Java 5 et 6

Résumé de l'éditeur

Dans cet ouvrage, Claude Delannoy applique au langage Java la démarche pédagogique qui a fait le succès de ses livres sur le C et le C++. Il insiste tout particulièrement sur la bonne compréhension des concepts objet et sur l'acquisition de méthodes de programmation rigoureuses. L'apprentissage du langage se fait en quatre étapes : apprentissage de la syntaxe de base, maîtrise de la programmation objet en Java, initiation à la programmation graphique et événementielle avec la bibliothèque Swing, introduction au développement Web avec les servlets Java et les JSP. Chaque notion nouvelle et chaque fonction du langage sont illustrées de programmes complets dont le code source est fourni sur le CD-Rom d'accompagnement. L'environnement de développement Eclipse, également fourni sur le CD-Rom, vous permettra de tester ces exemples et de développer vos propres programmes Java. L'accent est mis dans cette 5e édition sur les nouveautés des versions 5 et 6 de Java Standard Edition : programmation générique, types énumérés, annotations (chapitre nouveau), nouvelles possibilités de la classe File, nouveau gestionnaire Grouplayout, nouvelles interfaces et classes de collections (Queue, Deque, ArrayDeque, NavigableSet, NavigableMap), fonctionnalités permettant de professionnaliser une application (classes Desktop et Console, action sur la barre des tâches du système), etc. Lorsque nécessaire, les exemples de code ont été fournis en deux versions : une version exploitant les possibilités nouvelles de Java SE 5 et 6 et une version compatible avec les versions antérieures.

Biographie de l'auteur

Ingénieur informaticien au CNRS, Claude Delannoy possède une grande pratique de la formation continue et de l'enseignement supérieur. Réputés pour la qualité de leur démarche pédagogique, ses ouvrages sur les langages et la programmation totalisent plus de 250 000 exemplaires vendus.

799 pages, 5ème édition, 11 octobre 2007 

Édition Eyrolles

ISBN10 : 2212122322

Commandez sur eyrolles.com : 33,25 € TTC seulement (au lieu de 35,00 € TTC : prix public)

Commandez sur www.amazon.fr :

33.25 € TTC seulement (au lieu de 35.00  € TTC : prix éditeur) livraison gratuite !
  1. Présentation de Java
  2. Généralités
  3. Les types primitifs de Java
  4. Les opérateurs et les expressions
  5. Les instructions de contrôle de Java
  6. Les classes et les objets
  7. Les tableaux
  8. L'héritage
  9. Les chaînes de caractères et les types énumérés
  10. La gestion des exceptions
  11. Les threads
  12. Les bases de la programmation graphique
  13. Les contrôles usuels
  14. Les boîtes de dialogue
  15. Les menus, les actions et les barres d'outils
  16. Les évènements de bas niveau
  17. Les gestionnaires de mise en forme
  18. Textes et graphiques
  19. Les applets
  20. Les flux et les fichiers
  21. La programmation générique
  22. Les collections et les algorithmes
  23. Programmation Java côté serveur : servlets et JSP
  24. L'introspection et les annotations

 
Critique du livre par la rédaction Julien PLU le 1er août 2008 

Ce livre est vraiment instructif car il explique vraiment bien ce que peut être le langage Java. Le débutant y trouvera un très bon cours pour le Java, la POO, les graphiques avec SWING, et même pour le développement web avec JSP et d'autres outils / techniques / ... .

Ce livre sera aussi une très bonne référence pour les initiés à Java car il contient une annexe très bien fournie et des exemples de code tout faits qui peuvent beaucoup servir.

Une chose très constructive aussi : beaucoup de remarques sur certains points communs avec le langage C++, pour que l'on puisse bien voir les différences ou similitudes avec ce langage. J'ai également beaucoup apprécié le chapitre sur la programmation générique qui est vraiment bien construit. Sinon, mon seul regret est qu'il manque un chapitre sur JDBC qui est très utile et aurait pu introduire une partie BDD.

Conclusion : Ce livre est pour moi LA référence en français du langage Java pour ceux qui voudraient l'apprendre.
C'est également un très bon aide mémoire pour les initiés car il donne tout ce qu'il faut pour être totalement autonome afin de développer ses propres applications et appréhender en toute sérénité la volumineuse documentation Java.

Critique du livre par la rédaction BWP-Necromance le 1er juillet 2008 

Étant développeur C / C++ de base et désirant migrer vers le langage Java, je me suis intéressé à l'ouvrage « Programmer en Java » de Jean-Claude Delannoy dans sa 5e Édition. La première approche de ce livre est plutôt bonne, il regroupe la plupart des bases du langage comme les class, les threads, les boucles et même l'interface graphique de type Swing sur plusieurs chapitres. On peut noter également la présence d'un chapitre dédié à Java EE qui donne des idées sur la programmation orientée Web avec les pages dynamiques JSP ou les servlets.

Avec plus de détail, ce livre montre une approche très pratique et scolaire sur les divers points du langage Java avec des exemples de code expliqués. J'ai également apprécié les diverses comparaisons entre le Java et le langage C++ qui permette de voir comment le Java est assez proche du C++ et permet également aux développeurs C++ de ne pas être dépaysé par le Java.

Mon avis sur cet ouvrage est très positif, cependant, il est vraiment réservé pour apprendre les bases et ce limite uniquement aux aspects les plus importants du langage Java, ce qui signifie que si vous cherchez des informations sur des techniques de programmation avancés, ce livre ne sera pas fait pour vous. Par contre pour apprendre ou migrer sur le Java, ce livre est un réel plus à avoir à côté de soi.

Critique du livre par la rédaction Eric Reboisson le 1er février 2008 

Un ouvrage très instructif pour tous ceux qui voudraient se lancer dans Java. Ce livre traite de tous les points essentiels du langage : les origines de Java, les types, mots clés, POO, threads, IHM, programmation Web, etc. Claude Delannoy, l'auteur de "Programmer en Java" publie là une 5ème édition de ce qu'on peut appeler maintenant un best-seller. Je vous livre maintenant mes impressions :

Les plus :
  • Un sommaire très détaillé qui pour moi est un bon indicateur sur le contenu
  • La rédaction et le style simple facilitant la bonne compréhension
  • Un contenu de qualité et fiable et les parallèles avec C/C++
  • Plus de 250 000 ouvrages vendus, ce n'est pas un hasard
Les moins :
  • La mise en page trop sobre (mais les goûts et les couleurs, vous connaissez la suite...)
  • Certains chapitres ne sont vraiment que des petites introductions (mais on comprendra que l'ouvrage n'a pas non plus vocation à l'exhaustivité)

Au final, sans être LE livre indispensable au développeur Java qui se respecte, il est je pense un très bon livre en français sur le développement Java pour ceux que l'anglais rebuterait.
Le petit bonus : pour chaque plate-forme (Mac, Windows et Linux/Unix) un CD contenant Eclipse Europa, le JDK en version 6, et les codes sources du livre, ainsi les malheureux de la connexion internet ne seront pas en reste.

Je conseille donc vivement la lecture de "Programmer en Java" de Claude Delannoy, non seulement au débutant Java, mais aussi aux initiés qui chercheraient un référent documentaire.

 
couverture du livre Java Generics

Note 3.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Java Generics

and Collections

de Maurice Naftalin, Philip Wadler
Public visé : Expérimentés, Intermédiaires

Résumé de l'éditeur

This comprehensive guide shows you how to master the most important changes to Java since it was first released. Generics and the greatly expanded collection libraries have tremendously increased the power of Java 5 and Java 6. But they have also confused many developers who haven't known how to take advantage of these new features. Java Generics and Collections covers everything from the most basic uses of generics to the strangest corner cases. It teaches you everything you need to know about the collections libraries, so you'll always know which collection is appropriate for any given task, and how to use it. Topics covered include:

* Fundamentals of generics: type parameters and generic methods
* Other new features: boxing and unboxing, foreach loops, varargs
* Subtyping and wildcards
* Evolution not revolution: generic libraries with legacy clients and generic clients with legacy libraries
* Generics and reflection
* Design patterns for generics
* Sets, Queues, Lists, Maps, and their implementations
* Concurrent programming and thread safety with collections
* Performance implications of different collections Generics and the new collection libraries they inspired take Java to a new level. If you want to take your software development practice to a new level, this book is essential reading.

Java Generics and Collections covers everything from the most basic uses of generics to the strangest corner cases. It teaches you everything you need to know about the collections libraries, so you'll always know which collection is appropriate for any given task, and how to use it.

273 pages, 1ère édition, 1er novembre 2007 

Édition O'Reilly

ISBN10 : 0-59652775-6

ISBN13 : 978-0-596-52775-4

Broché

Commandez sur www.amazon.fr :

21,27 € TTC (prix éditeur 25,01 € TTC) livraison gratuite !
  • Introduction
  • Subtyping and wildcards
  • Comparison and bounds
  • Declaration
  • Evolution, not Revolution
  • Reification
  • Reflection
  • Effective Generics
  • Design Patterns
  • The main interfaces of the Java Collections Framework
  • Preliminaries
  • The Collection interface
  • Sets
  • Queues
  • Lists
  • Maps
  • The Collections class

 
Critique du livre par la rédaction Baptiste Wicht le 1er janvier 2008 

Comme son nom l'indique, ce livre couvre les génériques, introduits dans Java 5 et le framework de collection Java. Ces deux thèmes sont distinctement séparés en 2 parties différentes, mais, ces éléments étant intrinsèquement liés, on retrouve bien entendu des notions de génériques dans la partie collection et vice-versa.

Pour commencer, je vais parler des différentes parties de ce livre et de leurs contenus respectifs et je ferai ensuite part de mes impressions concernant le concernant.

Les auteurs débutent, donc, par la partie sur les Generics. Le premier chapitre présente très brièvement les différentes notions utilisées dans ce livre, à savoir, les Generics, la boucle ForEach, l'(Un)Boxing, les types et les méthodes génériques ainsi que les assertions.

Les chapitres suivants nous parlent du sous-typage, des Wildcards de génériques, de l'usage des generics dans les comparaisons et des arguments génériques multiples.

Le chapitre ? lequelest un un peu plus pratique. Il va nous apprendre à utiliser les Generics dans nos déclarations et classes, constructeurs et méthodes. Et donc implicitement à créer nos premières classes.

Le chapitre 5 enchaîne sur la manière dont ont été implémentés les generics de telle sorte à conserver la compatibilité ascendante. Ce chapitre est très utile car il présente les techniques pour utiliser des librairies normales avec une application ou vice-versa et nous met en garde contre les différents problèmes pouvant subvenir.

Le chapitre suivant est à nouveau très technique et explique en détail, le système de "Reification" des types paramétrés. Il présente les différents principes à respecter lors de l'utilisation de classes génériques.

Les chapitres suivants sont plus pratiques. Le premier traite de l'api de "Reflection" pour les generics et des generics pour "Reflection". Ou comment utiliser les generics avec l'api de reflection et l'amélioration de l'api avec les generics. Le chapitre qui suit ("Effective Generics") traite directement des problèmes principaux pouvant subvenir en utilisant les generics, dont la conservation de la compatibilité des binaires.

Enfin, le dernier chapitre sur les generics traite des design pattern pour lesquels il est intéressant de les utiliser.

J'ai trouvé cette première partie très compliqué à assimiler et assez technique. Ceci est peut-être dû à mon niveau d'anglais qui n'est pas parfait, mais c'est le premier livre anglophone que j'ai autant de peine à suivre. Il faut également avouer que le sujet est très complexe quand on s'y plonge. J'ai du parfois m'y reprendre à plusieurs fois pour comprendre une notion. Néanmoins, il se révèle très complet et est une très bonne source d'informations sur les generics.

La partie suivante est consacrée à l'étude du framework de Collections de Java. Les 2 premiers chapitres présentent les principales interfaces du framework et les principaux concepts utilisés dans le framework, comme les iterators, les performances ou encore le multi-threading.

Le chapitre suivant présente en détail l'interface Collection qui est l'interface de référence pour presque toutes les collections du framework. Les principales méthodes et constructeurs sont présentées en détails ainsi que l'implémentation de Collection.

Les quatre chapitres suivants traitent des principales implémentations du framework. A savoir, les Sets, les Queues, les Lists et les Maps. Chaque type de collection est présenté tout d'abord de manière générale et ensuite chacune des implémentations de ce type est présentée en détails et une conclusion à la fin de chaque chapitre nous aide à choisir une implémentation.

Le dernier chapitre traite de la classe Collections qui offre une série de méthodes pour traiter les collections. Les principales méthodes sont présentées et expliquées. Un cas d'utilisation est presque toujours représenté.

J'ai trouvé cette deuxième partie mieux organisée que la première et plus accessible. Néanmoins, elle se révèle toujours assez difficile à comprendre et à suivre bien que le sujet soit plus simple. J'ai beaucoup aimé la présentation des différentes implémentations qui se révèle très complète et très utile dans le choix d'une implémentation.

En conclusion, je dirais que ce livre n'est pas adapté aux débutants qui veulent débuter dans les generics, mais plutôt à un public avancé qui désire aller jusqu'au bout du sujet. Il se révèle en effet très technique et je n'ai jamais réussi à m'y plonger très longtemps. Néanmoins, c'est une excellente source d'informations du fait du nombre de sujets traités. Un bon livre donc, mais pas à mettre entre toutes les mains.

 
couverture du livre Checking Java Programs

Note 4.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Checking Java Programs

de Ian F. Darwin
Public visé : Débutants, Intermédiaires

Résumé de l'éditeur

This Short Cut tells you about tools that will improve the quality of your Java code, using checking above and beyond what the standard tools do, including:

  • Using javac options, JUnit and assertions
  • Making your IDE work harder
  • Checking your source code with PMD
  • Checking your compiled code (.class files) with FindBugs
  • Checking your program's run-time behavior with Java PathFinder
54 pages, 1ere édition, 1er mars 2007 

Édition O'Reilly

ISBN10 : 0596510233

Format PDF

Commandez sur www.amazon.fr :

  • What It's Not About
  • It Usually Begins with javac
  • Making Your IDE Work Harder
  • Source Code Checking with PMD
  • Static (Class File) Checking with FindBugs
  • Dynamic Checking with NASA's Java PathFinder
  • What's Next ?

 
Critique du livre par la rédaction Baptiste Wicht le 1er décembre 2007 

Tout d'abord, ce livre ne se veut pas un livre complet sur les programmes cités ici. C'est une introduction à l'analyse de programmes. Ce livre est donc destiné aux programmeurs qui n'ont pas encore testés leurs propres outils d'analyse et qui aimeraient en savoir plus sur les possibilités existantes dans ce domaine.

L'auteur va tout d'abord nous parler des warnings du compilateur Java (javac) et de la manière dont on peut les configurer pour n'avoir que ceux qu'on désire vraiment traiter. Il va ensuite nous montrer comment les configurer dans Eclipse. L'auteur utilisera Eclipse pour tous les exemples concernant l'intégration avec un IDE.

Après avoir vu les possibilités du compilateur Java, on va passer dans le vif du sujet avec la présentation de trois outils pour trois besoins différents. Tout d'abord, on va découvrir un outil d'analyse de code source, PMD. L'auteur va nous montrer comment faire marcher PMD de manière standalone, ensuite dans Ant, puis dans Eclipse et enfin, il va nous montrer comment étendre PMD avec de nouvelles règles. On va également découvrir CPD qui est un utilitaire de PMD permettant de détecter des portions de code copiées-collées.

L'auteur va suivre cette structure pour les 3 programmes présentés dans l'article, ce qui permet de s'y retrouver facilement. A la fin de chaque chapitre sur un outil, on va retrouver un résumé avec les points importants de chaque partie de la présentation. Ce résumé permet très succinctement de placer l'outil dans son contexte et de découvrir les principaux avantages du produit. Ce qui peut se révéler très intéressant si on revient sur le livre un moment après l'avoir lu.

Ensuite, l'auteur va nous présenter un outil d'analyse statique, FindBugs. Il va nous montrer l'utilisation en ligne de commande ou avec l'interface graphique de cet outil et nous montrer ce qu'on peut faire avec. Une courte partie est consacrée à une partie peu connue de FindBugs, le datamining. Cela permet de faire des comparaisons entre plusieurs analyses FindBugs pour vérifier l'avancement des erreurs, le nombre d'erreurs résolues et le nombre d'erreurs supplémentaires. On peut également suivre l'avancement du projet avec cet utilitaire étant donné qu'il nous donne par exemple le nombre de classes du projet.

Enfin, l'auteur nous présente le dernier outil, un outil d'analyse dynamique, Java PathFinder développé par la NASA. Cet outil permet de tester tous les chemins d'exécution possible de votre programme et permet de détecter certains problèmes comme des DeadLocks ou des exceptions non gérées. Il se révèle très utile dans un programme multi-threadé pour trouver des problèmes de concurrence.

En conclusion, ce livre est une très bonne introduction à l'analyse de programmes Java et vous permettra de découvrir trois excellents programmes d'analyse. Les programmes présentés ne sont qu'une sélection, il en existe d'autres, mais ils sont choisis parmi les meilleurs et dans un tel article, il n'aurait servi à rien de présenter plusieurs programmes de même catégorie. L'article se lit bien, mais certains passages sont plus difficiles à suivre. Il m'a fallu revenir plusieurs fois sur le même paragraphe pour bien le comprendre, mais en général, la lecture se révèle fluide et agréable. Je le conseille donc à tous les programmeurs Java qui aimeraient se lancer dans l'analyse de leurs programmes mais ne savent pas par où commencer.

 
couverture du livre Le guide de Survie

Note 4.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Le guide de Survie

Java: L'essentiel du code et des commandes

de Timothy Fisher
Public visé : Débutants, Intermédiaires

Résumé de l'éditeur

Ce Guide de survie vous livre tout le code dont vous avez besoin pour réaliser rapidement et efficacement vos projets de développement en Java. Facile à transporter, facile à utiliser - finis les livres encombrants ! Plus de 100 fragments de code personnalisables pour programmer du Java fonctionnel dans toutes les situations.

232 pages, 1er mars 2007 

Édition CampusPress

ISBN10 : 2744021628

Commandez sur www.amazon.fr :

15,20 € TTC (prix éditeur 16 € TTC) livraison gratuite !

Java: Le guide de Survie

  • Introduction
  • Les bases
  • Interagir avec l'environnement
  • Manipuler des chaines
  • Travailler avec des structures de données
  • Dates et Heures
  • Retrouvez des motifs avec des expressions régulières
  • Nombres
  • Entrées/Sorties
  • Travailler avec des répertoires et des fichiers
  • Clients Réseau
  • Serveurs Réseau
  • Envoyer et recevoir des emails
  • Accès aux bases de données
  • XML
  • Utiliser des Threads
  • Programmation dynamique par réflexion
  • Empaquetage et documentation des classes
  • Index

 
Critique du livre par la rédaction Vincent Brabant le 1er septembre 2007 

Une excellente FAQ de poche

Ce livre de poche, complément idéal de l'Aide-Mémoire Java publié chez Dunod, se présente comme un guide de survie. C'est en fait une bonne petite FAQ couvrant les API de bases de Java. Que ce soit les entrées/sortie, la manipulation des chaines de caractères, des dates, des nombres. Mais cela couvre également d'autres domaines comme l'écriture/lecture de fichiers ZIP, l'envoi/réception de mails via JAVAMail, la transformation XML par XSLT, ....

Je vous laisse découvrir par vous-même la table des matières pour que vous sachiez exactement ce qu'il couvre.

La façon dont le livre est découpé, et dont les exemples de code sont présentés, permet de trouver rapidement ce que l'on cherche.
En effet, quasi chaque sous-chapitre d'un chapitre commence par un bout de code, en blanc sous fond noir. Ce qui fait que lorsqu'on feuillete ou parcourt rapidement le livre ou un chapitre à la recherche d'une solution à notre problème, notre regard est directement attiré sur le code, ce qui en facilite grandement sa recherche.

Chaque code est accompagné d'un texte explicatif, lorsque c'est nécessaire, mais surtout d'autres détails et/ou astuces supplémentaires y sont donnés.

Les bouts de code sont toujours très courts mais toujours utilisables.

J'ai noté quelques exemples pour lesquels je ne suis personellement pas toujours d'accord. Ainsi, pour voir si une chaîne de caractères contient un nombre, il utilise le parseInt() de la classe Integer enrobé dans un try-catch avec NumberFormatException. Sachant qu'une exception coute cher, je préfère utiliser d'autres techniques que cela pour vérifier que c'est bien un nombre.
Aussi, lorsqu'il s'agit d'additionner et de soustraire des dates, ou de calculer la différence entre deux dates, son auteur propose à chaque fois d'additionner/soustraire des millisecondes ou de convertir en millisecondes.
J'aurais préféré qu'il propose des exemples de code où il utilise JodaTime, tout comme il propose des exemples de code avec JavaMail pour la gestion des mails.
JodaTime est vraiment l'API qu'il vous faut si vous devez manipuler des dates et des intervalles de dates. D'ailleurs, une JSR a été créée récemment pour introduire JodaTime dans une prochaine version du JDK

A part cela, je n'ai trop rien à dire. Une vraie petite FAQ de poche.

 
couverture du livre Swing la synthèse

Note 4.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Swing la synthèse

Développement des interfaces graphiques en Java

de Valérie Berthié et Jean-Baptiste Briaud
Public visé : Débutants

Résumé de l'éditeur

Swing est une librarie Java qui permet de créer et de gérer des interfaces graphiques évoluées.

Le but de cet ouvrage n'est pas de présenter la liste exhaustive des composants Swing, mais d'expliquer les principes de cette bibliothèque de classes et d'en offrir une vue d'ensemble.

Les composants les plus courants sont analysés en détail, amenant l'explication des concepts de layout, d'événement, de drag and drop et d'architecture MVC, ainsi que l'étude des composants plus complexes. Enfin, des problématiques plus avancées sont abordées, telles que le parralélisme, le multifenêtrage, les tests ainsi qu'une ébauche de framework.

La démarche s'appuie sur de nombreux exemples correspondant à des cas d'utilisation dans le monde professionnnel. L'un d'eux est enrichi tout au long de l'ouvrage, au fur et à mesure de la présentation de ces concepts.

Cet ouvrage s'addresse donc à des développeurs devant programmer une interface graphique avec Swing, à des architectes devant concevoir un système où Swing intervient ou encore à des chefs de projet ou des décideurs ayant à comprendre les principes globaux de Swing. Tous pourront acquérir le recul nécessaire aussi bien lors du développement que lors de choix techniques ou architecturaux.

348 pages, 2ème édition, 1er novembre 2005 

Édition Dunod

ISBN10 : 2100492195

Broché

Commandez sur www.amazon.fr :

35,15 € TTC (prix éditeur 37,00 € TTC) livraison gratuite !
  • Concepts fondamentaux, premiers pas avec Swing
  • Les layouts
  • Les événements
  • Les composants plus complexes
  • Les composants texte
  • Le drag and drop
  • Concepts avancés
  • Les apports des dernières versions de Java
  • Le formalisme UML

 
Critique du livre par la rédaction Baptiste Wicht le 1er août 2007 

Ce livre est destiné à toutes les personnes utilisant Swing. Il va vous expliquer les principaux concepts de Swing. Vous allez les apprendre via une série d'exemples ludiques. A la fin de chaque chapitre, vous allez pouvoir appliquer les différentes notions à une petite application.

On va commencer par voir les concepts fondamentaux de Swing. C'est-à-dire la notion de composants, de container, les fenêtres ainsi que les looks and feels. On va continuer ensuite avec la gestion des événements. Puis on va partir sur les composants plus complexes comme la JList, la JTable et le JTree. On va ainsi voir la notion de modèles, de renderers ainsi que d'editors. Sans oublier l'architecture MVC de Swing. Après avoir découvert toutes ces notions, un chapitre entier sera consacré aux composants texte avec notamment la gestion des Document, des Action ainsi que de l'undo-redo. Puis un autre chapitre pour le drag and drop. Vous y découvrirez 2 manières de faire du drag-and-drop, la deuxième étant seulement disponible depuis le JDK 4.

Après nous avoir parlé de tous les concepts de "base" de Swing, l'auteur va nous expliquer le concept de threading avec Swing. Un concept très important mais souvent mal compris par les débutants et même par les utilisateurs plus expérimentés. Ce concept sera expliqué avec une série de tests pour montrer la différence de performances de Swing avec ou sans respect de l'Event Dispatching Thread. On va également apprendre quels sont les nouveautés qui ont vu le jour dans les dernières versions de Java (1.4 et 5.0 pour ce livre). Puis vient le dernier chapitre sur le formalisme UML, mais je ne trouve pas que ce chapitre apporte grand-chose au livre vu la faible complexité des diagrammes UML utilisés.

En conclusion, ce livre va vous apprendre les principaux concepts de Swing et d'une très bonne manière. Après la lecture de ce livre, vous devriez parfaitement maîtriser les bases de Swing et vous devriez pouvoir vous lancer dans le développement d'interfaces graphiques en Swing. Néanmoins, ce livre n'est pas un catalogue Swing montrant tous les composants et leurs fonctions, la Javadoc et les tutoriaux de Sun étant nettement suffisants à ce niveau-là. On peut néanmoins regretter le manque de clarté de certains chapitres, comme celui sur les Javabeans ou encore la brièveté du chapitre sur l'undo-redo ou celui sur la deuxième manière de faire du drag-and-drop. Mais mis à part ces petits défauts, ce livre reste une excellente introduction au framework Swing et je ne peux que vous le conseiller.

 
couverture du livre SCJP

Note 4.0drapeaucdrom
Détails du livre
Sommaire
Critiques (1)
 
 

SCJP

Sun Certified Programmer for Java 5: (Exam 310-055)

de Kathy Sierra et Bert Bates
Public visé : Intermédiaires, Expérimentés

Résumé de l'éditeur

100% complete coverage of all official objectives for Sun Java exam 310-055.
Exam Objective Highlights in every chapter point out exam objectives to ensure you're focused on passing the examReal-world exercises--Step-by-step instruction modeled after the hands-on exam questions.
Exam Watch sections in every chapter highlight key exam topics covered.
Simulated exam questions match the format, tone, topics, and difficulty of the real exam.

Covers all exam 310-055 topics, including:

  • Declarations and Access Control
  • Object Orientation
  • Assignment and Initialization
  • Operators
  • Flow Control, Exceptions, and Assertions
  • I/O, Formatting, and Parsing
  • Generics
  • Collections
  • Inner Classes
  • Threads
  • Java Development

The best fully integrated study system available.
CD-ROM includes:

Complete MasterExam practice testing engine, featuring:

  • One full practice exam
  • Detailed answers with explanations
  • Score Report performance assessment tool
  • Electronic book for studying on the go
  • Bonus downloadable MasterExam practice test (with free online registration)
825 pages, 1ère édition, 1er décembre 2005 

Édition McGraw-Hill/Osborne Media

ISBN10 : 0072253606

Broché

Commandez sur www.amazon.fr :

38,20 € TTC (prix éditeur 38,20 € TTC) livraison gratuite !
  • Language Fundamentals
  • Declarations and Access Control
  • Operators and Assignments
  • Flow Control, Exceptions, and Assertions
  • Object Orientation, Overloading and Overriding, Constructors, and Return Types
  • Java.lang-The Math Class, Strings, and Wrappers
  • Objects and Collections
  • Inner Classes
  • Threads
  • Development
  • APPENDIX: About the CD

 
Critique du livre par la rédaction Gildas CUISINIER (hikage) le 1er août 2007 

Avant tout, je me permettre de bien remettre ce livre dans son contexte : C'est un guide pour la certification SCJP !
Donc si c'est un livre pour apprendre le language Java que vous cherchez, passez votre chemin.

Cela étant dit, ce livre très utile et très intéressant, les deux auteurs du livre sont les co-créateurs de l'examen et donc connaissent très bien le sujet traité par le livre
Fréquemment ils mettent en avant ce qui est important de savoir, tout comme ils informent le lecteur lorsqu'un sujet est hors propos pour la certification.

Le livre en lui même est très agréable à lire, malgré des sujets parfois difficiles à appréhender. Personnellement j'ai dévoré ce livre une première fois, pour le relire par après plus en détail.

L'organisation du livre quant à elle est très clair. Un chapitre reprend un sujet important pour le décortiquer en détail.
Et pour chacun chaque section, un lien est fait vers le ou les objectifs de la certification que celle-ci couvrera.
En fin de chapitre est présent un "Two-Minute Drill", un rappel très succint des informations traités par le chapitre, et un mini test de tester vos acquis sur les sujets du chapitre.

En fin de livre, un examen blanc complet est présent, celui-ci contient des questions du même style que celles qui seront posées durant l'examen.
Enfin, un examen supplémentaire est disponible sur le CD-Rom accompagnant le livre, ainsi qu'un autre en téléchargement sur le site du livre.

En conclusion, je dirai que pour ma part ce livre à répondu à son objectif, c'est grâce à lui que j'ai réussi mon examen SCJP 5.

 
couverture du livre Java Tête la première

Note 4.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Java Tête la première

Couvre Java 5.0

de Kathy Sierra, Bert Bates
Traducteur(s) : Marie-Cécile Baland
Public visé : Débutants

Résumé de l'éditeur

On sait bien ce que vous pensez. ; mais que vient faire un canard dans le chapitre sur la gestion de la mémoire ? Est-ce qu'une fille dans son bain peut vraiment illustrer la subtilité d'un sujet comme le polymorphisme ? Préparez-vous à tester votre ouverture d'esprit. " Java - Tête la première " mélange jeux, images, interviews et vous amène à être actif de différentes manières. Rapide, réel, concret et amusant. Ce livre est tout cela.
Il existe mille et une façons d'apprendre. Ce livre en a choisi une bien spécifique. Sous des dehors amusants et ludiques, cet ouvrage n'en demeure pas moins parfaitement, rigoureux. Mais la différence réside dans les jeux, les énigmes à résoudre, toutes ces images, bref, la façon dont vous allez apprendre.
Cette seconde édition de " Java - Tête la première " est une introduction à la programmation orientée objet et à java. Elle se concentre sur java 5.0, la dernière version du langage java. Celle-ci représentant une mise à jour importante de la plate-forme, nous vous proposons une nouvelle édition de " Java - Tête la première ", avec beaucoup plus de code, de jeux, etc. Les sujets suivants seront abordés : les bases du langage ; le développement orienté objet ; la manière d'écrire, de tester et de déployer des applications ; l'utilisation de la bibliothèque d'API java ; le formatage des dates et des nombre ; la gestion des exception ; le multithreading ; la programmation avec Swing ; le réseau avec RMI et les sockets.
L'approche des auteurs est concentrée sur la pédagogie. Les concepts s'appuient sur des images et sur des exercices ludiques. Les différents points n'en sont alors que mieux mémorisés. Vous allez réellement penser comme un développeur orienté objet.
Si vous voulez apprendre Java mais qu'en même temps vous aimez sortir et vous amuser, alors feuilletez ce livre. Il est fait pour vous !

687 pages, 2ème édition, 1er novembre 2006 

Édition O'REILLY

ISBN10 : 2841774112

Commandez sur www.amazon.fr :

46,55 € TTC (prix éditeur 49,00 € TTC) livraison gratuite !
  1. Intro
  2. Jetons nous à l'eau : on pique une tête
  3. Voyage à Objectville : oui, il y aura des objets
  4. Maîtrisez vos variables : types primitifs et références
  5. Le comportement des objets : l'état des objets affecte le comportement des méthodes
  6. Méthodes extra-fortes : contrôle de flots, opérations et autres
  7. Utiliser la bibliothèque Java : pour éviter de tout écrire vous-même
  8. Mieux vivre à Objectville : planifier l'avenir
  9. Le polymorphisme dans tous ses états : interfaces et classes abstraites
  10. Vie et mort d'un objet : constructeurs et gestion de la mémoire
  11. Affaires de nombres : math, formatage, classes, enveloppes et static
  12. Comportements à risque : gestion des exceptions
  13. Une histoire très graphique : IHM, gestion des événements et classes internes
  14. Travaillez votre Swing : gestionnaires d'agencement et composants
  15. Sauvegarder les objets : sérialisation et E/S
  16. Établir une connexion : sockets et threads
  17. Structures de données : collections et génériques
  18. Déployez votre code : packages et déploiement
  19. Informatique distribuée : RMI plus une touche de servlets, d'EJB et de Jini
  20. Annexe A : Recettes de code
  21. Annexe B : Dix notions importantes qui ne rentraient pas dans le reste du livre
  22. Index

 
Critique du livre par la rédaction Anis Frikha (afrikha) le 1er juin 2007 

J'ai trouvé ce livre tout simplement excellent. Les auteurs de ce livre abordent Java d'une manière très originale qui consiste à combiner images, textes et jeux, ce qui permet de démystifier bon nombre de sujets délicats, ainsi on peut y trouver, par exemple, un dialogue entre une variable locale et une variable d'instance !

Chaque chapitre est clôturé par une série d'exercices très bien faits et ordonnés par difficulté croissante. Vous pouvez donc vous retrouver à jouer le rôle du compilateur ou bien de la JVM ce qui peut être très instructif.

J'ajouterais que pour tirer pleinement parti de ce livre, il vaut mieux connaître déjà un langage de programmation et qu'il soit de préférence orienté objet (mais ce n'est pas obligatoire). Si vous faites partie de cette catégorie de gens alors ce livre constitue un très bon investissement. Dans le cas contraire, passez votre chemin.

 
couverture du livre Les Cahiers du programmeur Swing

Note 5.0drapeau
Détails du livre
Sommaire
Critiques (3)
 
 

Les Cahiers du programmeur Swing

de Emmanuel Puybaret
Public visé : Débutants,Expérimentés

Résumé de l'éditeur

Ce cahier montre aux développeurs Java comment exploiter la très riche bibliothèque standard Swing à travers la création d'une application graphique 3D ergonomique et fiable.

Cet ouvrage décrit la création d'un logiciel libre d'aménagement d'intérieur développé avec Java 5 et Swing, de sa conception UML jusqu'à sa ditribution, en passant par l'utilisation d'Eclipse, dont les astuces de productivité sont dévoilées. Le développeur y découvrira comment exploiter efficacement les nombreuses fonctionnalités de Swing : création d'arbres, de tableaux et de boîtes de dialogue, dessin dans un composant graphique, glisser-déposer, gestion d'opérations annulables, intégration d'un composant 3D, ...

499 pages, 1ère édition, 7 décembre 2006 

Édition Eyrolles

ISBN10 : 2212120192

Broché

Commandez sur eyrolles.com : 37.05 € TTC seulement (au lieu de 39 € TTC : prix public)

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39,00 € TTC) livraison gratuite !
  • L'étude de cas : Sweet Home 3D
  • Mise en place de l'environnement de développement
  • Choix technique : Swing ou SWT ?
  • Arbre du catalogue des meubles
  • Tableau des meubles du logement
  • Modification du tableau des meubles avec MVC
  • Gestion des actions annulables
  • Composant graphique du plan
  • Vue 3D du logement
  • Enregistrement et lecture du logement
  • Glisser-déposer et copier-coller
  • Edition des préférences utilisateur
  • Bibliographie
  • Index

 
Critique du livre par la rédaction Eric Reboisson le 1er mai 2008 

Je viens de terminer la lecture du livre SWING dans la collection "Les cahiers du programmeur", un ouvrage sur l' APISwing qui permet de concevoir des interfaces graphiques avec le langage de programmation Java. Place maintenant à une petite présentation du contenu et à mes impressions sur cette publication dont le fil rouge est une application pour la modélisation 3D d'un logement.

Un bon point pour commencer, le sommaire complet et les titres de chapitres détaillés permettent d' accéder rapidement à l'information. Ensuite pour chaque chapitre, les grands thèmes couverts sont annoncés, on sait donc d'avance ce que l'on va découvrir, c'est structuré et ça suscite l'envie de lire. Pour la matière, toutes les phases de création du projet Sweet Home 3D sont présentées : on débute par l'idée et les phases inhérentes au démarrage d'un projet (cahier des charges, conception...), puis l'installation des outils de développement, la programmation proprement dite et les cycles de tests associés pour finir avec le déploiement de l'applicatif. Le comparatif avec d'autres API graphiques (AWT, SWT, JFace) est le bienvenu pour expliquer les choix qui peuvent conduire à l'utilisation ou non d'un des outils. On pourra lire également sur chaque page des petits encarts pour agrémenter les explications du livre (B.A.-BA, A retenir, Astuces, Pour aller plus loin, Attention...)

Ce livre ne traite donc pas uniquement de Swing et on puisera énormément d'informations sur (entre autres) :

  • Les fondations d'un projet informatique (cahier des charges, référentiel des sources)
  • Les nouveautés de Java 5 (annotations, généricité,)
  • Les designs patterns (MVC, Singleton, Décorateur, Proxy...)
  • Le déploiement avec Java Veb Start
  • ANT

Le livre expose des extraits de code commentés sur l'implémentation de l'application, des scénarios fonctionnels, des diagrammes de classes UML et des copies d'écrans pour illustrer les différentes étapes. J'ai cherché ce qui pouvait manquer dans le contenu mais tout est là.

C'était une découverte de la collection "Les cahiers du programmeur", et je dois dire que j'ai été enchanté tant par la qualité du contenu technique que par la pédagogie adoptée pour tenir le lecteur en haleine, mais aussi par la mise en page très riche et lisible à la fois. Je donne donc la note maximale et je ferai simple pour la conclusion : tous les livres devraient être comme ça, vous pouvez donc l'acheter les yeux fermés !

Critique du livre par la rédaction Vincent Brabant le 1er avril 2007 

Tout d'abord, je dois vous signaler, avant que vous n'alliez plus loin dans la critique, que j'ai été relecteur technique de ce livre.
Mon avis aurait donc pu être faussé.
C'est la raison pour laquelle j'ai attendu que quelqu'un d'autre fasse une critique de ce livre, avant de publier la mienne :-).

Ce livre est le seul que j'ai lu jusqu'à ce jour qui explique aussi clairement comment développer une application Swing en utilisant le modèle MVC tout en faisant bien la distinction entre le modèle MVC de votre application et le modèle MVC (ou plutôt M-VC) des composants Swing.
Attention que ce livre n'est pas là pour vous faire découvrir tous les composants Swing qui sont à votre disposition, mais plutôt pour vous faire découvrir comment bien découper/structurer votre application Swing.
Malgré cela, on y apprend l'utilisation des JTable, JTree, ..., à afficher le même modèle sous des vues différentes (on visualise la même pièce en 3D, en 2D et sous forme de table), implémenter l'Undo/Redo, le Drag and Drop, l'internationalisation d'une application, ...
On y apprend de plus comment découper un projet, comment les personnes ont raisonné pour finalement arriver au design de cette application.
Tout au long de l'ouvrage, l'auteur compare également Swing et AWT avec SWT et JFace, nous fait découvrir des modules Eclipse intéressants.
L'étude de cas que l'auteur a choisi pour ce livre est certainement pour beaucoup dans la qualité de l'ouvrage.
Dès le premier chapitre, on a envie d'en savoir plus, de connaitre comment l'auteur s'y est pris pour réaliser son étude de cas.
Sachez également que l'auteur a aussi mis son étude de cas à la disposition de tous, sous licence open source, et qu'elle est totalement opérationelle.

En conclusion, je ne peux que conseiller ce livre à tous ceux qui programment ou désirent programmer en Swing.
Ce livre me semble assez unique dans sa façon d'aborder Swing.
Pourquoi je ne donne que 4.5/5 à ce livre ? C'est la question que l'auteur m'a posée.
Je lui ai répondu que je mettrais 5/5 au livre qui m'expliquerait Swing à la façon "Head First/Tête première". Et le système des étoiles ne me permet pas de lui donner 4.9/5.

Critique du livre par la rédaction Baptiste Wicht le 1er février 2007 

Ce livre est tout simplement génial. C'est la première fois que je lis un livre d'informatique aussi prenant, on a à chaque fois envie d'aller plus loin et d'avancer dans les chapitres.

Ceci est surtout du à la structure qu'a utilisée l'auteur pour écrire ce livre. Il n'en a pas fait un simple catalogue Swing montrant toutes les méthodes et classes de Swing et leur utilisation; il crée plutôt un projet qu'on va faire avancer tout au long du livre en lui ajoutant de nouvelles fonctionnalités. En plus de toutes les informations techniques que l'on obtient durant la lecture des différents chapitres, l'auteur nous fait aussi part de son expérience dans le travail en groupe et le développement de projet. En effet, on va voir comment découper le projet en plusieurs scénarios bien distincts, comment appliquer la méthode XP, comme utiliser CVS pour archiver et partager les fichiers du projet, etc. L'auteur va aussi traiter de la différence SWT/SWING/AWT.

Les domaines techniques abordés par cette application sont très vastes. On va voir comment créer des nouveaux composants Swing en respectant l'architecture MVC et comment faire une application respectant elle aussi le principe MVC. On va aussi voir comment utiliser les composants complexes que sont le JTable et le JTree. On va aussi apprendre à gérer des actions annulables dans l'application et la façon d'utiliser le glisser-déposer dans votre application. On passera aussi sur l'enregistrement de préférences utilisateurs et des données de l'application. En plus, on verra aussi comment visualiser une vue en 2D et en 3D !

En conclusion, je conseille ce livre non seulement à toutes personnes développant une application Swing mais aussi à toute personne développant une application graphique en Java, car ce livre dans ses métiers sait se montrer très général, de sorte que la plupart des informations sont utilisables pour une application graphique non Swing.

 
couverture du livre Mieux programmer en Java

Note 4.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Mieux programmer en Java

68 astuces pour optimiser son code

de Petter Haggar
Public visé : Débutants,Expérimentés

Résumé de l'éditeur

Un ouvrage pratique et concret
Tous les programmeurs vous le diront : le temps passé au débogage représente une grande part du développement de programmes et de d'applications. Réduire cette phase de débogage, programmer "juste" du premier coup : tels sont les objectifs atteints par ce livre qui expose en détail les pièges classiques de la programmation Java et la manière de les éviter. En proposant des solutions aux principaux problèmes rencontrés en Java, l'ouvrage va droit au but : pas de discours inutiles mais des recommandations concrètes, répondant aux attentes des programmeurs.

Une structure divisée en ateliers
Les 68 ateliers qui composent cet ouvrage abordent les princpales difficultés de la programmation Java : objets, exceptions, calsses et interfaces, tests d'égalité, multithreadiing, et ce à l'aide d'une multitude d'exemples très détaillés. En toutre, 18 d'entre eux sont consacrés à la manière d'écrire un code plus performant et donc plus rapide.

A qui s'adresse ce livre ?

  • Aux étudiants de 1er cycle universitaire (IUT, Deug, ...) et aux élèves d'écoles d'ingénieurs.
  • Aux programmeurs Java débutants, intermédiaires ou avancés.
224 pages, 1ère édition, 1er juillet 2000 

Édition Eyrolles

ISBN10 : 2212091710

Broché

Commandez sur www.amazon.fr :

28.50 € TTC (prix éditeur 30,00 € TTC) livraison gratuite !
  • Techniques générales
  • Objets et tests d'égalité
  • Gestion des exceptions
  • Performances
  • Programmation multithread
  • Classes et interfaces
  • Annexes

 
Critique du livre par la rédaction Baptiste Wicht le 1er janvier 2007 

Ce livre présente 68 méthodes d'optimisation pour du code Java. Néanmoins, il faut bien faire attention au mot optimisation : pour ceux qui s'attendent à n'avoir que des astuces pour avoir un code plus rapide, ce n'est pas le cas. Seules 18 astuces permettent d'optimiser les performances de votre application. Les autres astuces permettent de produire un code plus sûr et plus stable.

Ces astuces sont parfois plus des explications sur comment faire quelque chose qu'une réelle astuce. Mais elles sont néanmoins très intéressantes. Avec ces astuces, vous apprendrez à faire correctement des tests d'égalité, à avoir un code multithread sécurisé ou encore à gérer correctement vos exceptions. Vous apprendrez aussi à implémenter des classes constantes et à redéfinir la méthode equals.

La partie sur les performances se révèle à mon goût un peu faible. Une astuce sur l'optimisation manuelle du code s'avère très intéressante. Les autres étant plus basiques, avec par exemple l'utilisation de StringBuffer à la place de String dans une boucle. Mais cette partie traite aussi de concepts plus avancés tels que l'inlining, l'évaluation différée ou encore l'utilisation de variables de pile plutôt que de variables globales. De plus, les comparaisons entre les différentes techniques sont expliquées directement en bytecode ce qui permet de voir directement ce que ça donne.

Une chose que je trouve dommage est que ce livre n'a pas été mis à jour depuis sa première édition. Il utilise donc Java 1.2, mais la plupart des astuces présentées ici sont toujours valables avec les dernières versions de Java.

En conclusion, ce livre vous montrera différentes manières de mieux coder en Java et d'optimiser les performances de vos programmes. Mais ce livre n'est pas la solution miracle à vos problèmes de performances.

 
couverture du livre Exercices en Java

Note 3.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Exercices en Java

Couvre Java 5.0

de Claude Delannoy
Public visé : Débutants

Résumé de l'éditeur

Conçu pour les étudiants en informatique, ce recueil d'exercices corrigés est le complément idéal de Programmer en Java du même auteur ou de tout autre ouvrage d'initiation au langage Java. Cette nouvelle édition a été mise à jour pour tenir compte des nouveautés de Java 5.0. Elle comporte deux nouveaux chapitres (les types énumérés et les génériques), soit 17 exercices supplémentaires. Les 160 exercices sont classés par thèmes en 16 chapitres. Chaque chapitre débute par la liste des nations nécessaire la résolution des exercices (section Prérequis). Certains exercices portent sur une notion précise indiquée dans l'énoncé. D'autres, appelés Exercices de synthèse, font appel à la mise en rouvre de plusieurs notions étudiées dans les exercices chapitres précédents, et nécessitent donc un effort de réflexion plus fourni. Chaque énoncé d'exercice est suivi d'une ou plusieurs solutions détaillées.

313 pages, 2ème édition, 1er août 2006 

Édition Eyrolles

ISBN10 : 2212119895

Commandez sur eyrolles.com : 18,91 € TTC seulement (au lieu de 19,90 € TTC : prix public)

Commandez sur www.amazon.fr :

19,90 € TTC (prix éditeur 18,91 € TTC) livraison gratuite !
  1. Les opérateurs et les expressions
  2. Les instructions de contrôle
  3. Les classes et les objets
  4. Les tableaux
  5. L'héritage et le polymorphisme
  6. La classe String et les chaînes de caractères
  7. Les exceptions
  8. Les bases de la programmation événementielle
  9. Les principaux contrôles de Swing
  10. Les boîtes de dialogue
  11. Les menus
  12. Les événements de bas niveau
  13. Les applets
  14. Les flux et les fichiers
  15. La programmation générique

 
Critique du livre par la rédaction Vincent Brabant le 1er janvier 2007 

Tout d'abord, je dois vous dire que c'est la première fois que j'ai un livre de Claude Delannoy dans mes mains. Et je suis parti du principe que ce livre doit m'offrir des exercices pour programmer en Java (mais aussi en Java 5, vu que c'est le pourquoi de la 2ième édition).

Les moins :
  • Rien trouvé sur les collections
  • Rien trouvé sur la nouvelle boucle for each (for : )
  • Explications quelques fois trop succinctes, voire même complètement absentes
Les plus :
  • Bien structuré
  • Respect des conventions (une classe commence par un Majuscule, une méthode par une minuscule, CamelAnnotation, ...)
  • La généricité y est bien abordée
  • Les énumérations y sont bien expliquées
  • Les exercices permettent de vous entraîner pour la certification (mais attention, ce livre ne suffit pas à vous préparer à la certification !!!)
Mon évaluation de l'ouvrage a été guidée par les points suivants :
  • Les nouveautés contenues dans Java 5 sont vraiment traitées de façon inégale.
  • Il n'y a pas vraiment d'exercices concernant les collections, et leur gestion, et je n'en ai pas vu non plus concernant les Threads.
  • Les solutions des exercices sont quelques peu légères voire même absentes, et il n'y a aucun exercice sur l'api JDBC et la manipulation des fichiers XML.

Conclusion : un bon livre d'exercices, mais décevant un peu pour ce qui est des exercices concernant Java 5. En fait, ce livre fait très bien la paire avec le livre desTP informatiques d'Alexandre Brillant, couvrant Java 5. Mais le fait de devoir acheter les 2 livres fait que cela revient assez cher l'exercice. Je conseillerais alors, pour la somme des 2 livres, d'acheter un autre livre (mais en anglais, malheureusement, Comment Programmez en Java, de chez Deitel et Deitel).

 
couverture du livre Les expressions régulières par l'exemple

Note 5.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Les expressions régulières par l'exemple

de Vincent Fourmond
Public visé : Expérimentés

Résumé de l'éditeur

Les chaînes de caractères, qui sont si simple en apparence, recèlent des difficultés redoutables dès qu'il faut écrire un programme pour les analyser, par exemple pour extraire des dates. Comme elles ne sont pas structurées, on ne peut rechercher que des régularités : c'est alors qu'interviennent les "expressions régulières".

  • les solutions aux exercices du livre
  • Que faire quand ça ne marche pas ?

Cet ouvrage vous apprendra comment :

  • construire une expression régulière;
  • enrichir votre syntaxe;
  • imbriquer à bon escient des expressions régulières dans vos programmes;
  • écrire des expressions régulières en Perl, Javascript, PHP, Java,C#, Python,C++/Qt, Emacs/Lisp, C/POSIX, Grep et Sed.;

44 exercices corrigés en détail, de très nombreux exemples, des tableaux aide-mémoires et une grille d'aide au débugage vous amèneront à une maîtrise complète de cet outil efficace, ludique et polyvalent.

126 pages, 1ème édition, 1er juillet 2005 

Édition Technique & Pratiques

ISBN10 : 2-914-01065-6

Format poche

Commandez sur www.amazon.fr :

9.31 € TTC seulement (au lieu de 9.80  € TTC : prix éditeur) livraison gratuite ! (voir conditions)
  • Avant propos
  • Qu'est ce qu'une expression régulière
  • Débuter avec les expressions régulières
  • Enrichir ses expressions régulières
  • Bien utiliser les expressions régulières
  • Syntaxe dans dix langages
  • Solutions des exercices
  • Que faire quand ça ne marche pas?

 
Critique du livre par la rédaction Fabrice SZNAJDERMAN

Ce livre au format poche contient l'essentiel de ce qu'il faut savoir sur les expressions régulières. Au cours des chapitres on trouvera une alternance en explication et mise en application directe par des petits exercices rapides (les corrigés sont disponibles à la fin du livre).

L'approche est progressive. Le premier chapitre introduit par un exemple simple les différentes notions.

Le deuxième chapitre va un peu plus loin en expliquant le fonctionnement des différents opérateurs basiques.

Le chapitre 3 explique de manière plus concrète les expressions régulières via des cas d'utilisations.

Le chapitre 4 donne des conseils de bonnes pratiques avec les expressions régulières.

Le chapitre 5 fait un tour d'horizon des langages proposant des outils pour les expressions régulières.

Deux annexes dans ce livre :

  • les solutions aux exercices du livre
  • que faire quand ça ne marche pas !
 
couverture du livre Java en concentré

Note 4.5drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Java en concentré

Manuel de référence pour Java

de David Flanagan
Traducteur(s) : Alexandre Gachet et Anne Gachet
Public visé : Débutants
Introduction : Couvre Java 5.0

Résumé de l'éditeur

Java in a Nutsbell fait peau neuve et devient Java en concentré. Les éléments qui ont fait le succès des précédentes éditions sont toujours là : découpage thématique, nombreux exemples et couverture exhaustive des classes des paquetages fondamentaux, avec en prime les nouveautés apportées par Java 5.0 et l'inventaire des outils de développement disponibles. Le must des manuels de référence. Cet ouvrage est avant tout un guide de référence, mais il servira également de tutoriel pour les programmeurs avertis qui souhaitent découvrir Java rapidement. La partie " tutoriel N donne aux développeurs tous les éléments pour comprendre ce qui fait la spécificité d'un programme écrit en java, depuis la syntaxe du langage jusqu'aux outils de développement java, en passant par les différents mécanismes de sécurité. Les notions clés sont présentées sans fioriture, mais illustrées par des exemples réalistes. Un chapitre entier inventorie les nouveautés introduites dans la version 5.0 du langage et notamment : les types génériques ; les annotations ; les types énumérés ; les conversions boxing et unboxing ; l'instruction for/in ; les méthodes varargs ; l'importation de membres statiques. La partie " référence " passe en revue les classes des paquetages essentiels de java et explique comment mener à bien des tâches courantes comme la manipulation de texte, le traitement de données au format XML, le recours aux expressions régulières ou la gestion des entrées/sorties. On trouvera une description des paquetages java. io, java.lang, java.matb, java.net, java.nio, java.security, java.text, java.util, java.crypto, javax.net,jâvax.net.ssl javax.security.autb, javax.xml, org.w3c.dom et org.xml.sax. Cet ouvrage convient à des progammeurs aguerris.

David Flanagan est diplômé en informatique du MIT (Massachusetts Institute of Technology). Programmeur consultant, spécialiste de java et de JavaScript, il est l'auteur de nombreux livres sur Java.

1418 pages, 5ème édition, 1er février 2006 

Édition O'Reilly

ISBN10 : 284177371X

18 x 6 x 24 cm

Commandez sur www.amazon.fr :

51,30 € TTC (prix éditeur 54 € TTC) livraison gratuite !
  1. Introduction
    1. Qu'est ce que Java ?
    2. Les avantages clés de Java ?
    3. Un exemple de programme
  2. La syntaxe Java
    1. Programmes Java dans leur ensemble
    2. Types de données primitifs
    3. Expressions et opérateurs
    4. Instructions
    5. Méthodes
    6. Introduction aux classes et objets
    7. Tableaux
    8. Types références
    9. Paquetages et espace de désignation en Java
    10. Structure des fichiers Java
    11. Définir et exécuter des programmes Java
    12. Différences entre C et Java
  3. La programmation orientée objet en Java
    1. Syntaxe de la définition des classes
    2. Champs et méthodes
    3. Création et initialisation d'objets
    4. Destruction et finalisation d'objets
    5. Sous-classes et héritage
    6. Masquage des données et encapsulation
    7. Classes et méthodes abstraites
    8. Méthodes importantes de java.lang.Object
    9. Interfaces
    10. Types emboîtés
    11. Résumé des modificateurs
    12. Caractéristiques de C++ absentes en Java
  4. Nouveautés du langage Java 5.0
    1. Types génériques
    2. Types énumérés
    3. Annotations
  5. La plate-forme Java
    1. Vue d'ensemble de la plate-forme Java
    2. Texte
    3. Nombre de Maths
    4. Dates et heures
    5. Tableaux
    6. Collections
    7. Threads et programmation concurrente
    8. Fichiers et répertoires
    9. Flux d'entrée et de sortie avec java.io
    10. Interconnexion de réseaux avec java.net
    11. Entrées/sorties et interconnexion de réseaux avec java.nio
    12. XML
    13. Types, réflexion et chargement dynamique
    14. Persistence des objets
    15. Sécurité
    16. Cryptographie
    17. Fonctionnalités diverses
  6. La sécurité en Java
    1. Risques liés à la sécurité
    2. Sécurité de la machine virtuelle Java et vérification des fichiers de classe
    3. Authentification et cryptographie
    4. Contrôle d'accès
    5. Sécurité pour tout le monde
    6. Classes de permissions
  7. Conventions de programmation et de documentation en Java
    1. Conventions liées à l'attribution des noms et à la capitalisation
    2. Conventions de portabilité
    3. Commentaires de documentation en Java
    4. Conventions propres aux JavaBeans
  8. Outils de développement Java
  9. Guide de référence

 
Critique du livre par la rédaction Ricky81

Voila le livre idéal pour découvrir ou redécouvrir la plate-forme Java.
Clair et concis (malgré la taille), il vous servira également de guide de référence lorsque vous aurez le malheur de ne pas pouvoir accéder facilement à des ressources en ligne ou à la Javadoc.

Cette nouvelle édition introduit les nouveautés de Java 5 en se concentrant sur l'essentiel (logique, puisque l'ouvrage anciennement "Java in a Nutshell" s'appelle désormais "Java enconcentré").
Bien entendu, vous ne trouverez pas tous le détail d'une API comme les Generics, mais suffisamment pour ensuite vous débrouiller et fouiller la partie "Guide de référence".

Ce livre en impose, tant par le nombre de pages (dont les 400 premières constituent la matière grise) que par la densité des informations.
Certains passages auraient certes pu être adaptés à Java 5, mais le travail serait considérable et certains passages risqueraient de devenir trop complexes et risqueraient de mettre en arrière plan les concepts illustrés.

Mention spéciale aux traducteurs Anne et Alexandre Gachet qui ont réalisé un travail de grande qualité. On ne leur reprochera pas les quelques coquilles relevées compte tenu du nombre impressionnant de pages.

Bref, vous l'aurez compris, cet ouvrage est plus qu'un livre de chevet, une vraie bible comme on aimerait en voir plus souvent.

 
couverture du livre Les cahiers du programmeur

Note 4.5drapeaucdrom
Détails du livre
Sommaire
Critiques (1)
 
 

Les cahiers du programmeur

Java 1.4 et 5.0

de Emmanuel Puybaret
Public visé : Débutants

Résumé de l'éditeur

A travers la réalisation d'un forum de discussion et plus de 50 études de cas, ce cahier montre à tous les programmeurs comment exploiter la richesse de Java pour créer sans mal des applications fiables et évolutives. Ce cahier met à la portée de tous les développeurs les meilleures pratiques Java, depuis l'installation des outils de développement et la création d'un premier objet jusqu'à la programmation multitâche, en passant par l'accès aux bases de données, la conception d'interfaces utilisateur, la gestion de formulaires, de fichiers, la maîtrise des subtilités objet...

367 pages, 3ème édition, 1er mars 2006 

Édition Eyrolles

ISBN10 : 221211916X

21 x 2 x 24 cm

Commandez sur eyrolles.com : 27,55 € TTC seulement (au lieu de 29,00 € TTC : prix public)

Commandez sur www.amazon.fr :

27,55 € TTC (prix éditeur 29 € TTC) livraison gratuite !
  1. Présentation des études de cas
  2. Principes du langage et installation de l'environnement
  3. Création de classes
  4. Contrôle des traitements avec les opérateurs, boucles et branchements
  5. Réutilisation des classes
  6. Les classes de base de la bibliothèque Java
  7. Abstraction et interface
  8. Gestion des erreurs avec les exceptions
  9. Lecture et écriture des fichiers
  10. Interfaces utilisateur avec Swing
  11. Connexion à la base de données avec JDBC
  12. Programmation Web avec les servlets, JSP et JavaBeans
  13. Interface utilisateur du forum
  14. Echanger des informations avec XML
  15. Messagerie instantanée avec la programmation multitâche

 
Critique du livre par la rédaction Vincent Brabant

Cette 3ème édition du cahier des programmeurs Java d'Emmanuel Puybaret est un remaniement total comparé à la 1ère édition :

  • une centaine de pages en plus
  • 1 CD-ROM est maintenant joint avec
  • 2 nouveaux chapitres, couvrant java.io et XML
  • dernier chapitre fortement enrichi d'une partie dédiée à la synchronisation et au multi-threading, superbement bien expliqué
  • rajout d'appartés (notes marginales) à l'intention des développeurs C, C++ et C#
  • rajout d'appartés concernant les principales nouveautés du JDK 5.0

J'avais déjà lu la 1ère édition de ce livre, et la façon dont Emmanuel Puybaret explique les choses ma plue énormément. Les illustrations apportent beaucoup à la compréhension. Le code vous est expliqué, décortiqué. Vous n'avez presque plus l'impression de lire, mais de l'entendre vous parler. Ce livre est captivant. J'ai eu des difficultés à m'en détacher contrairement à d'autres livres, pour lesquels il m'a fallu me faire violence pour les lire jusqu'au bout (Le livre d'Anne Tassot en est un exemple).

Ce livre est AMHA le meilleur de la collection "Cahiers du programmeur", du point de vue approche pédagogique, illustration des propos, ... Emmanuel Puybaret a une approche pédagogique qui fait merveille.

Deux bémols :

  • Le chapitre XML m'a paru très pauvre. Mais XML est tellement vaste, et ses librairies Java également, qu'un livre dédié qu'à cela ne suffirait pas.
  • Le prix est passé de 23 à 29

A conseiller à tous les débutants Java.

 
couverture du livre Aide-Mémoire de Java

Note 5.0drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Aide-Mémoire de Java

de Vincent Granet, Jean-Pierre Regourd
Public visé : Débutants,Expérimentés

Résumé de l'éditeur

Etudiants en formation initiale ou continue, cet ouvrage constitue une base de référence pour vous initier au monde Java. Forts de leur expérience d'enseignants, les deux auteurs traitent les fonctionnalités de ce langage de façon didactique, suivant une progression logique. L'ensemble des possibilités offertes par Java est ainsi couvert : du modèle objet à l'environnement de programmation, des processus aux entrées-sorties, des API aux exceptions, de la généricité au graphisme : chaque notion est appuyée par un ou plusieurs exemples et cas pratiques. Aucune connaissance en Java n'est pré-requise. Vous pouvez donc aborder cet ouvrage en toute quiétude, pour mieux réussir vos examens et développer les bons réflexes de programmation en Java !

246 pages, 1er septembre 2005 

Édition Dunod

ISBN10 : 2-10-049145-8

Commandez sur www.amazon.fr :

15.20 € TTC seulement (au lieu de 16  € TTC : prix éditeur) livraison gratuite ! (voir conditions)

Aide-Mémoire de Java

  • Avant-propos
  • Java, les bases
  • Les Objets de base
  • Le modèle Objet de Java
  • Les mécanisme de programmation par objets
  • La généricité
  • Le contrôle de l'exécution
  • Les entrées-sorties
  • L'API
  • L'environnement Java
  • Bibliographie
  • Annexe
  • Index

 
Critique du livre par la rédaction Joseph Pachod le 1er mai 2007 

Un livre indispensable pour tout débutant en Java et souvent nécessaire pour développeur confirmé devant aborder des sujets dont il n'a pas l'habitude.

Ce petit livre couvre succinctement l'essentiel de la programmation Java, avec à la fois les explications sur le fonctionnement fondamental de chaque fonctionnalité et des exemples pertinents.

Bien sûr, si vous voulez aborder un aspect bien spécifique, ce livre ne vous sera pas suffisant, mais il offrira sans doute déjà assez d'informations pour bien débuter. De toutes façons, jamais un livre généraliste sur Java ne donnera jamais assez d'éléments sur un point précis des très vastes bibliothèques disponibles.

Au final : un must have.

Critique du livre par la rédaction Vincent Brabant

Un livre à avoir dans votre poche

Cet aide-mémoire, de petit format, devrait être tout le temps dans votre poche.

Dès les premières pages de cet aide-mémoire, je fus surpris par sa qualité tant du point de vue du texte, que du point de vue des bouts de code Java donnés.

Ainsi, d'entrée de jeu (chapitre 1 et 2), on vous apprend comment afficher la date du jour dans un format donné, la nouvelle boucle ForEach, la classe StringBuilder, la classe Collator (Est-ce que Éléonor précède Fabian ou pas ?), les énumérations (enum).

J'aime également beaucoup la façon dont les auteurs vous expliquent les mécanismes de la programmation par objet, la généricité (nouveauté du JDK 5.0) et le contrôle d'exécution.

Le chapitre 8, dédié aux API Java, aborde les collections, les tables, les URL et Sockets, AWT, Swing et les applets. Cela ne couvre évidemment pas tout ce qu'un livré dédié à Swing pourrait couvrir, bien évidemment, mais vous y avez vraiment l'essentiel (composants, événements, conteneurs et systèmes d'agencement (layout))

Dans le dernier chapitre (le 9), ils y ont même consacré une petite partie sur la sécurité, et l'utilitaire policytool.

J'oubliais également la partie consacrée aux entrées-sorties, ainsi que celle consacrée aux threads.

Quand je vous dis que malgré sa petite taille, il couvre une multitude de choses, je n'exagère pas. Ce n'est pas un ouvrage de référence, qui passe en revue toutes les API du JDK. Mais un excellent aide-mémoire, illustré abondamment d'extraits de code, très bien pensés.

Un excellent rapport qualité/prix

 
couverture du livre Refactoring des applications Java/J2EE

Note 4.5drapeau
Détails du livre
Sommaire
Critiques (4)
 
 

Refactoring des applications Java/J2EE

de Jean-Philippe Retaillé
Public visé : Expérimentés

Résumé de l'éditeur

Améliorer la qualité et l'évolutivité des applications Java/J2EE. Le refactoring consiste à refondre le code source d'une application existante ou en cours de développement pour en améliorer la qualité, avec pour objectif une réduction des coûts de maintenance et une meilleure évolutivité. L'ouvrage passe en revue les différentes techniques de refactoring utilisées en environnement Java/J2EE : extraction de méthodes, généralisation de type, introduction de design patterns, programmation orientée aspect, optimisation de l'accès aux données, etc. Un livre pratique illustré d'une étude de cas détaillée. L'ouvrage décrit dans le détail le processus de refactoring d'une application Java/J2EE : mise en place de l'infrastructure et des outils, analyse de la conception et du code de l'application, mise en oeuvre des techniques de refonte, tests de non régression. Cette démarche est illustrée par une étude de cas complète : refactoring d'une application J2EE Open Source à l'aide d'outils tels que Eclipse, CUS, JUnit et PMD.

Commentez Donner une note à l´article (3)

376 pages, 1er septembre 2005 

Édition Eyrolles

ISBN10 : 2-212-11577-6

Commandez sur eyrolles.com : 39,90 € TTC seulement (au lieu de 42,00 € TTC : prix public)

Commandez sur www.amazon.fr :

39,90 € TTC (prix éditeur 42 € TTC) livraison gratuite !
  • Remerciements

Avant-propos

  • Objectifs de cet ouvrage
  • Organisation de l'ouvrage
  • A propos des exemples
  • A qui s'adresse l'ouvrage ?

Chapitre 1: L'évolution logicielle et le refactoring

  • La problématique de l'évolution logicielle
  • Le périmètre d'intervention du refactoring
  • Le refactoring au sein des méthodes agiles
  • Conclusion

Chapitre 2: Préparation du refactoring

  • La gestion de configuration
  • Gestion des tests et des anomalies
  • Conclusion

Chapitre 3: L'analyse du logiciel

  • L'analyse quantitative du logiciel
  • L'analyse qualitative du logiciel
  • Sélection des candidats au refactoring
  • Conclusion

Chapitre 4: Mise en oeuvre du refactoring

  • Support du refactoring de code dans Eclipse
  • Les techniques de refactoring du code
  • Conclusion

Chapitre 5: Les tests unitaires pour le refactoring

  • Les tests unitaires avec JUnit
  • Les simulacres d'objets avec EasyMock
  • Analyse de couverture avec EMMA
  • Utilisation des test unitaires pour le refactoring
  • Conclusion

Chapitre 6: Le refactoring avec les design patterns

  • Les design patterns
  • Utilisation des modèles comportementaux
  • Amélioration de la structure des classes
  • Conclusion

Chapitre 7: Refactoring avec la POA (Programmation Orientée Aspect)

  • Principes de la programmation orientée aspect
  • Modularisation des traitements
  • Optimisation des traitements
  • Analyse du logiciel et tests unitaires
  • Conclusion

Chapitre 8: Refactoring de base de données

  • La problématique du refactoring avec les bases de données
  • Refactoring de la structure de la base
  • Refactoring des requêtes SQL
  • Refactoring de l'utilisation de JDBC
  • Conclusion

Chapitre 9: Présentation de l'étude de cas

  • Cahier des charges du logiciel
  • JGenea, une solution Java pour le généalogie
  • Architechture de JGenea Web
  • Récupération de JGenea Web
  • Fonctionnalités d'Éclipse utiles pour l'étude de cas
  • Conclusion

Chapitre 10: Analyse de JGenea Web

  • Analyse quantitative
  • analyse qualitative
  • Conclusion

Chapitre 11: Refactoring de JGenea Web

  • Réorganisation et mise à niveau
  • Application des techniques de base
  • Utilisation des Design Patterns dans la gestion des accès aux données
  • Modularisation avec un aspect
  • Pour aller plus loin

Annexe

  • Installation d'Eclipse
  • Installation de PMD sous Eclipse
  • Installation de Checkstyle sous Eclipse
  • Installation de Metrics sous Eclipse
  • Téléchargement d'EMMA
  • Téléchargement du client CVS pour Windows
  • Téléchargement de StatCVS
  • Téléchargement de Tomcat
  • Installation et configuration du plugin Tomcat de Sysdeo pour Eclipse
  • Installation du plug-in AJDT pour Eclipse
  • Script DDL de JGenea Web
  • Références

 
Critique du livre par if_zen le 1er février 2010 

J'ai trouvé l'ouvrage très intéressant dans ses premiers chapitres, où il expose les différents types de refactoring à considérer, les manières de les mettre en oeuvre.
De plus, les façons d'analyser l'existant sont bien expliquées, et de nombreux outils sont proposés pour arriver à nos fins. Bien qu'il date de 2005, son contenu reste tout à fait d'actualité.

Après, j'ai trouvé que ça s'est gâté. On passe de hors sujet en hors sujet, même si ceux-ci s'avèrent agréables à lire. Une bonne partie du livre nous explique comment utiliser Eclipse pour renommer les méthodes, réorganiser le contenu des classes, présente quelques design patterns et la POA, la façon d'écrire des tests unitaires... Je trouve qu'on s'écarte souvent du sujet principal.

J'espérais trouver un livre dans lequel obtenir plus d'informations sur la manière de refondre le code plus en profondeur. Ceci dit, le livre précise bien qu'un refactoring s'applique à du code dont les fondements sont sains, mais cela ne suffit pas à combler ma déception.
La lecture de ce livre n'aura cependant pas été une perte de temps, car de nombreuses idées traversent l'esprit pendant la lecture de ce dernier par rapport à mon cas personnel, et les techniques/outils présentés le sont très bien.

Critique du livre par la rédaction christopheJ

On finit tous un jour par se retrouver sur un projet avec du code hérité au lourd passif... Le genre de code qui évolue au jour le jour. Le code pour lequel personne ne trouve le temps de prendre du recul pour essayer de l'alléger, réécrire les morceaux peu performant, redondant ou trop contraignant... C'est alors que cet ouvrage est utile.

Il présente une approche progressive du refactoring. On commence avec les choses de bases (renommage de variable, changement de nom de méthode) pour finir sur des choses plus compliquées (applications de pattern, refactoring de la base de données ...). L'approche est très graduelle, on ne se sent pas perdu et les outils (audit de code ou test) sont clairement expliqués.

Ce qui est intéressant, c'est que l'auteur pose toutes les conditions pour que cela se passe bien. Il explique comment déterminer les points sensibles qui seront soumis à refactoring, comment s'assurer que le comportement du logiciel sera le même après refactoring. Il détaille bien les outils de mesures mais aussi leur piège et faux positifs. Pour chaque technique il indique quand l'utiliser et quels sont les risques qui lui sont propres. Par exemple, vous avez sans doute déjà utilisé les fonctions de renommage de votre IDE, mais qu'en est-il en cas de chargement dynamique de la classe ou d'introspection sur la méthode ?
Chaque technique est accompagnée d'un exemple et de capture d'écran pour Eclipse.

Enfin, ce qui ajoute beaucoup de valeur à ce livre, c'est l'étude de cas qui occupe environ un cinquième du volume. On a tous lu des livres avec des exemples (parfois à peine plus complexes qu'un "Hello World"). On pense avoir compris et quand on arrive sur un vrai cas, on se pose encore des questions, on hésite, on ne sait plus ... Ici l'étude de cas se fait sur une vraie application, pas juste trois classes et deux JSP. Cette étude de cas permet de mettre en application les techniques décrites dans la première partie de façon guidée. Et si vous ne voulez pas faire les premières étapes (renommage) mais uniquement la refonte des DAO ou des actions Struts, il existe une version de chacune des étapes sur le CVS.

En conclusion, un livre obligatoire à lire si l'on se retrouve un jour avec du code hérité.

Critique du livre par la rédaction Vincent Brabant

Un excellent ouvrage sur le refactoring.

Ce livre est un bijou, une merveille, un joyau.

Je me suis vraiment régalé à la lecture de ce livre. Il commence tout d'abord par vous expliquer la raison d'être du refactoring, ce que c'est et ce que ce n'est pas.

Ensuite, il vous explique les préparations à faire (création de branches, de clichés, s'assurer qu'on a bien les tests unitaires, ...) avant d'effectuer un refactoring de votre application.

Puis, il vous explique la mise en oeuvre du refactoring, à l'aide de l'EDI Eclipse.

Il vient ensuite vous montrer comment combiner les tests unitaires avec le refactoring, et l'utilisation de simulacre d'objets avec EasyMock, mais également l'analyse de couverture avec EMMA.

Toute un chapitre est également consacré aux design patterns, et comment ils peuvent vous venir en aide dans le cas du refactoring.

L'auteur aborde également, avec élégance, la problématique du refactoring avec les bases de données. Et cela est vraiment enrichissant.

La troisième partie du livre est entièrement consacrée à l'étude de cas: un programme de généalogie.

A travers cette étude de cas, l'auteur vous apprendra comment, grâce à une analyse quantitative et une analyse qualitative, trouver les parties de code nécessitant un refactoring.

Une fois ces parties détectées, il va appliquer différents refactoring appris lors de la deuxième partie du livre.

Conclusion :Sans discussion, un excellent achat.

Critique du livre par la rédaction Stessy

Quelle personne ne s'est jamais retrouvée en face d'un code qu'elle avait ou n'avait pas produit et qui parfois se révèle être une cochonnerie en terme de maintenance et d'évolutivité.

Eh bien moi je me suis retrouvé dans le cas ou ce code ne m'appartenait pas et, qui plus est, était mal agencé pour me permettre de le faire évoluer sereinement sans devoir tout réécrire de A à Z.

Je me suis donc retroussé les manches et ai commencé à proprement parler le refactoring de l'application.

Je dois bien avouer que je ne m'en serait jamais sorti si je n'avais pas suivi les conseils précieux distillés dans cet ouvrage.

L'auteur commence d'abord par expliquer le pourquoi du refactoring.

Ensuite viennent les pré-processus indispensables pour effectuer un refactoring robuste tels que le versioning des différentes ressources, la mise en oeuvre des tests unitaires,...

Le troisième chapitre est pour moi le plus théorique. Il aborde les méthodes qui permettent d'analyser le code tant de manière quantitative que qualitative.
Je dois bien avouer que j'ai du relire ce chapitre une seconde fois pour bien comprendre à quels moments, et quels endroits du code, le refactoring devenait une nécéssité voire même une obligation.

Chapitre 4. Là, on rentre réellement dans la mise en oeuvre du refactoring. Chaque technique de refactoring abordée dans ce chapitre est basée sur un plan bien précis. Ce plan est décomposé en 4 parties :

  • les objectifs de cette technique ainsi que les risques pouvant survenir
  • les moyens de détection
  • le refactoring proprement dit
  • un exemple concret de mise en oeuvre

Le chapitre suivant traite de l'utilisation de test unitaires en combinaison avec le refactoring. Il explique également comment créer des simulacres d'objets qui permettront, comme le terme l'indique, de simuler des objets.

C'en est terminé avec la première partie de l'ouvrage.

La seconde partie traite des techniques avancées pour effectuer le refactoring d'une application telles que les design patterns, SOA.

Ce qui m'a le plus surpris dans cette partie, c'est le refactoring de la base de données.
Comme quoi on en apprend tous les jours.

La dernière partie reprend une étude de cas complète. Cette partie de l'ouvrage met en pratique la totalité des techniques abordées lors des chapitres précédents, en passant :

  • par l'analyse quantitative et qualitative,
  • par le refactoring de l'application,
  • par la mise en oeuvre des tests unitaires

En conclusion, cet ouvrage est un petite merveille. A recommander chaudement.

 
couverture du livre Au coeur de Java 2, Volume 2, Fonctions avancées JDK 5.0

Note 3.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Au coeur de Java 2, Volume 2, Fonctions avancées JDK 5.0

de Cay S Hortsmann & Gary Cornell
Public visé : Expérimentés

Résumé de l'éditeur

Plus de 250 000 programmeurs ont utilisé Au coeur de Java 2 Volume 1- Notions fondamentales pour consolider leur savoir sur la technologie Java. Ce second volume va plus loin encore et constitue un guide complet pour résoudre les problèmes quotidiens des développeurs. La cinquième édition du volume 2 entre en détail dans des sujets tels que la programmation de l'interface utilisateur et les fonctions professionnelles de la plate-forme java 2, édition standard (JSETM). Totalement mis à jour, cet ouvrage traite les multithreads, qui permettent d'exécuter des tâches en parallèle, l'API JDBC 2.0, CORBA, le glisser-déposer et le modèle de sécurité Java 2. Ce dernier a été revu pour le JDK 5.0, de façon à prendre en compte les algorithmes de cryptage AES et RSA. Les techniques de Swing avancées sont abordées, dont les composants GUI complexes d'arbres et de tables, les indicateurs de progression et l'implémentation Java d'une interface à "plusieurs documents". Un chapitre décrit les techniques de conception des cadres de collections et l'exploitation des données structurelles fondamentales autorisées par la bibliothèque standard Java. Cette édition explique aussi comment internationaliser des applications Java, générer du XML et utiliser les transformations XSL. Le chapitre consacré au XML a été mis à jour pour inclure l'API XPath. Enfin, un nouveau chapitre a été ajouté il traite des annotations et des métadonnées, des fonctionnalités ajoutées au JDK 5.0.

858 pages, 1er juin 2005 

Édition Campus Press Référence

ISBN10 : 2-7440-1962-3

Commandez sur www.amazon.fr :

42,75 € TTC (prix éditeur 45,00 € TTC) livraison gratuite !
  1. Multithreads
  2. Collections
  3. Programmation des bases de données
  4. Objets distribués
  5. Swing
  6. JavaBeans
  7. La sécurité
  8. Internationalisation
  9. Méthodes natives
  10. XML
  11. Annotations

 
Critique du livre par la rédaction Vincent Brabant

Ce second tome complète à merveille le premier (voir critique du 1er tome sur developpez.com)

Le 1er chapitre a été entièrement réécrit, pour aborder la nouvelle API concernant la Concurrence introduite dans la version 5 de Java. Cette nouvelle API met à votre disposition tout un ensemble de classes et interfaces vous permettant de construire plus facilement des applications mutithreads performantes que ce qui était possible jusqu'à présent.

Le second chapitre, couvrant les Collections, a été étendu pour aborde la notion de Queue, la classe PriorityQueue, .... Ce chapitre explique également les tables de hachage, et pourquoi il est important de choisir un bon code de hachage. Il aborde également la notion de Weak Reference, bien que cela soit traité de façon plus superficielle que dans le livre HardCore Java, de chez Oreilly.

J'ai une remarque négative à faire à l'encontre des traducteurs. Pourquoi ont il traduit les noms des classes et/ou interfaces en français dans les figures montrant les anciennes classes, comme Vector, Map et Properties. Mais cela ne concerne qu'une figure sur une page dans tout le livre.

Je n'ai pas eu l'impression qu'il y a beaucoup de modification concernant les chapitre 3 à 10 par rapport à l'ancienne version. Même si le chapitre sur la sécurité couvre maintenant AES et RSA, et que le chapitre XML couvre XPATH. Mais cela est assez concis et rien de tel qu'un ouvrage de référence sur XML et XPATH. Et que les exemples ont été revus. Par exemple, dans le chapitre 9, il expliquent comment appeler une méthode printf depuis Java.

Le chapitre 11 concernant les annotations est quant à lui tout à fait nouveau et vous explique en détails. Il aborde également BCEL, qui vous permet de manipuler directement du ByteCode.

Pour ceux qui possèdent une ancienne édition de ce deuxième tome , l'achat de celui ci vous sera utile si vous voulez connaitre les nouveautés introduites au niveau du Multithreading, des collections, des certificats RSA et AES, et connaitre les annotations. Pour ceux qui ne possedent pas d'ancienne édition de ce deuxième tome, je ne peux que vous conseiller ce livre de référence. En tout cas, si vous avez acheté récemment la dernière édition du Tome 1, n'hésiter pas à acheter son compagnon.

 
couverture du livre Cahiers du programmeur : Java/XML

Note 4.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Cahiers du programmeur : Java/XML

de Renaud Fleury avec la contribution de Caroline de Vasson
Public visé : Expérimentés

Résumé de l'éditeur

Au fil de la refonte d'un système d'information de site e-commerce, ce cahier illustre les meilleures pratiques J2EE à mettre en oeuvre tant pour la modélisation et la présentation de flux XML que pour la conception de services web. Le couple Java/XML est incontournable pour le développeur J2EE professionnel qui doit mettre en place des applications de gestion portables, ouvertes et fiables. On verra dans ce cahier comment stocker et restituer dans un format homogène des données hétérogènes, valider des flux XML, écrire un mapping objet/XML en utilisant des outils open source tels que Xerces, Xalan, Ant, Castor, Eclipse, Axis, eXist...

217 pages, 1ère édition, 1er décembre 2004 

Édition Eyrolles

ISBN10 : 2212113161

21 x 2 x 24 cm

Commandez sur eyrolles.com : 27,55 € TTC seulement (au lieu de 29,00 € TTC : prix public)

Commandez sur www.amazon.fr :

27,55 € TTC (prix éditeur 29,00 € TTC) livraison gratuite !
  1. Cahier des charges
  2. Installation de l'environnement de développement
  3. XML, pour configurer et transporter des données
  4. Modélisation et visualisation des objets métier via XML
  5. Struts, partie émergée de l'application ?
  6. Les bases de données XML natives : grand déstockage d'Automne ?
  7. Conception de services web

 
Critique du livre par la rédaction Ioan Calapodescu

Le couple Java/XML est désormais un incontournable pour le développeur J2EE. La découverte des intéractions entre ces deux technologies est le but avoué de cet ouvrage. La tâche est difficile, mais l'auteur, Renaud Fleury, en viens à bout de manière fort élégante.
Ce ouvrage est destiné à toute personne désirant faire du développement web avec J2EE et XML. Que vous soyez un développeur J2EE débutant désirant vous ploger dans le développement web, un développeur J2EE confirmé désirant découvrir (ou redécouvrir) la technologie XML ou encore un chef de projet désirant avoir un apercu clair des possibilités offertes par le couple J2EE/XML, ce livre est fait pour vous.
Le parti pris de cet ouvrage est de faire découvrir les vastes possibilités de Java/XML grâce à la réalisation, tout au long du livre, d'un projet de site web totalement axé sur XML : le projet Octopuss.

Le principal atout de cet ouvrage est justement le projet Octopuss. Il est particulièrement agréable de découvrir de manière pratique ces technologies, parfois complexes. Ainsi, l'auteur commence tout simplement par un cahier des charges : exposition des besoins, spécifications fonctionnelles et techniques, méthodologies de développement, etc. Vous pouvez d'ailleurs découvrir ce premier chapitre sur le site d'Eyrolles : extraits du livre Java / XML.
Après une partie dédiée à l'installation des outils de développement (Eclipse, Tomcat, Log4j, etc.), on passe dans le vif du sujet : le développement de l'application. Chaque chapitre va vous permettre de découvrir une nouvelle facette de XML et son application pratique avec le projet Octopuss. Vous pourrez ainsi faire le tour du monde XML : les notions et API fondamentales (XML, XSL, XML Schema, JAXP, SAX, DOM, etc.), le data-binding (JAXB, Castor, etc.), les frameworks d'application (Struts, Cocoon, Barracuda), les bases de données XML natives et la conception de services Web.
On pourra aussi apprécier la mise en page claire, la présence de nombreux schémas explicatifs et de nombreux cadres présentant des définitions, liens web intéressants, etc.

La seule chose que l'on pourra regretter après la ecture de cette ouvrage est l'absence d'un CD. Celui-ci aurait pu contenir les outils de développement (outils libres et gratuits), ainsi que les codes sources du projet Octopuss. Je pense que cela aurait renforcé le côté pratique de l'ouvrage et aurait permis de se focaliser plus directement sur le côté technique.
Les codes sources de l'application sont téléchargeables :Java/XML Téléchargements.
Une dernière remarque que l'on pourrait faire est le fait que certaines technologies ne sont que survolées. A dire vrai, j'aurais lu avec plaisir quelques chapitres de plus. ;-)

Pour conclure, je dirais que cet ouvrage devrait trouver sa place dans la bibliothèque de tout développeur J2EE : un guide utile, agréable et pratique des technologies Java/XML.

 
couverture du livre Ant précis & concis

Note 5.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Ant précis & concis

de Stefan Edlich
Traducteur(s) : James Guérin
Public visé : Débutants

Résumé de l'éditeur

Développé par l'Apache Software Foundation sous licence Open Source, Ant est un système de gestion de build comparable à Make. Sa portabilité est garantie par l'usage du langage java et du format XML pour les fichiers de build.
Ant - précis & concis référence les éléments de base (projets, propriétés, cibles et tâches) et décrit par l'exemple un fichier build. Les concepts fondamentaux de cet utilitaire sont expliqués afin de permettre une bonne compréhension du fonctionnement de Ant (jeux de fichiers, de modèles, les Classpath, arguments de la ligne de commande, etc.). Les tâches de base incluses par défaut dans toutes les distributions de Ant sont listées et détaillées. Un aperçu des tâches optionnelles complète ce guide, qui s'appuie sur la version 1.4.1 de Ant.

Les développeurs java qui désirent apprendre rapidement Ant trouveront dans cet ouvrage une introduction à son utilisation et ceux plus expérimentés qui recherchent une commande particulière y verront un précieux aide-mémoire.

110 pages, 30 juin 2002 

Édition O'Reilly

ISBN10 : 2841771598

Commandez sur www.amazon.fr :

8,55 € TTC (prix éditeur 9,00 € TTC) livraison gratuite !
  1. Introduction
  2. En trois étapes vers le fichier build
  3. Éléments de base de Ant
  4. Concepts fondamentaux
  5. Paramètres de la ligne de commande
  6. Propriétés prédéfinies
  7. Tâches personnalisées
  8. Perspectives : Ant 2
  9. Tâches prédéfinies
  10. Référence des tâches standard
  11. Tâches optionnelles

 
Critique du livre par la rédaction l'équipe Java

Ant est devenu un outil indispensable au développeur Java, quel que soit son domaine de prédilection : J2SE, J2EE, etc. Sa portabilité, sa facilité d'utilisation et son intégration à de nombreux EDI/RAD du marché (grâce à des plugins, voir même par défaut avec NetBeans), en font un outil incontournable. Voici quelques liens grâce auquels vous pourrez en apprendre un peu plus :

Présentation de Ant par Ludovic Fernàndez

Forum d'entraide Ant

Autres outils pour le développeur Java

 
couverture du livre Programmation Orienté Aspect pour Java / J2EE

Note 4.5drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Programmation Orienté Aspect pour Java / J2EE

de R.Pawlak, J.Ph.Retaillé et L.Seinturier
Public visé : Expérimentés
Introduction : Un nouveau paradigme

Résumé de l'éditeur

La POA, un nouveau paradigme de programmation étendant l'existant

La programmation orientée aspect (POA) fait partie, comme la programmation orientée objet (POO), de la lignée des techniques de programmation qui ont permis de simplifier l'écriture des programmes informatiques, en les rendant plus modulaires et plus faciles à faire évoluer. Complémentaire et non concurrent de la POO, la POA peut être implémentée sous forme d'extension à n'importe quel langage existant.

Des concepts de la POA aux implémentations avec Java/J2EE

Écrit par trois experts français qui conjuguent une triple expérience du sujet - recherche théorique, conception d'outils logiciels et mise en oeuvre en entreprise -, cet ouvrage est structuré en quatre parties. La première partie présente les principes de la POA et introduit les concepts d'aspect, de coupe, de point de jonction, etc. La deuxième partie décrit les principaux outils de POA du monde Java : AspectJ, JAC (Java Aspect Components), JBoss AOP et AspectWerkz. La troisième partie présente plusieurs exemples d'applications types dans lesquelles s'exprime tout le potentiel de la POA. L'ouvrage s'achève sur une étude de cas détaillée montrant comment implémenter la POA dans une application J2EE existante, aussi bien au niveau de la couche métier que de la couche présentation.

446 pages, 1er avril 2004 

Édition Eyrolles

ISBN10 : 2-212-11408-7

Commandez sur eyrolles.com : 42,75 € TTC seulement (au lieu de 45,00 € TTC : prix public)

Commandez sur www.amazon.fr :

42.75 € TTC seulement (au lieu de 45.00  € TTC : prix éditeur) livraison gratuite !
  1. Les concepts de la POA
  2. Principaux outils de POA du monde Java
  3. Applications de la POA
  4. Étude de cas détaillée

 
Critique du livre par la rédaction Eric Reboisson le 1er août 2007 

Le livre "Programmation orientée aspect pour Java / J2EE" définit dans un premier temps ce qu'est la POA (assez succinct, mais précis et suffisant. Pour information, POA c'est AOP en anglais), présente et compare ensuite 4 outils/implémentations de POA (AspectJ, JAC, JBOSS AOP et AspectWerkz) et finit sur une partie concernant les domaines d'application de ce paradigme (Design Patterns, cas concret...)

J'ai apprécié l'approche pragmatique de cet ouvrage, chaque solution est présentée avec une même structure dans ses sous-chapitres. Les solutions sont ensuite utilisées par la suite pour présenter les cas d'utilisation (même si au cours de la lecture j'ai ressenti la préférence des auteurs pour leur bébé JAC). Vous trouverez également dans cet ouvrage des explications sur comment appliquer la POA à votre proche métier ou dans vos techniques habituelles et conventionnelles de programmation. Un bon point pour le style d'écriture des auteurs, l'attention du lecteur est bien entretenue et sa compréhension améliorée. La mise en page est bien conçue dans l'ensemble, les codes sources sont disponibles sur le site de l'éditeur, bref tous les ingrédients sont là.

Ce livre constitue donc, à mon sens une bonne introduction sur le sujet de la POA : assez général pour couvrir un spectre de plusieurs outils, et détaillé pour vous accompagner à comprendre et utiliser les solutions présentées pour une application concrète dans vos projets. Malgré tout (mais je ne pense pas que les auteurs avaient la prétention d'être exhaustif), pour aller plus loin une exploration unitaire des frameworks présentés sera nécessaire. Au final, un livre que je vous conseille pour découvrir la POA.

Critique du livre par la rédaction Lionel Roux (RanDomX)

Dans un style simple et clair, cet ouvrage s'applique à expliquer de manière très didactique les concepts avancés de la POA, avant de passer en revue les principaux outils permettant d'utiliser ce paradigme avec Java. Par ailleurs, il est très pédagogique et au fil des chapitres, l'on se rend compte qu'il distille habilement les bonnes pratiques nécessaires à une bonne appréhension de la POA.

Un soin particulier est apporté à la description des design patterns réécrits en utilisant ce nouveau paradigme, ainsi qu'à l'installation des outils utilisés dans l'ouvrage.

Enfin, l'étude de cas complète permet de fixer les idées afin de maîtriser le concept.

Ce (gros) livre de 446 pages s'avère très complet et permettra au novice de la POA comme à l'expert de trouver ce qu'il cherche. Attention toutefois, une maîtrise parfaite du paradigme objet est nécessaire pour le comprendre aisément.

En conclusion, un ouvrage à recommander aux programmeurs Java / J2EE professionnels désireux d'évoluer.

 
couverture du livre Java & XSLT

Note 4.5drapeau
Détails du livre
Critiques (1)
 
 

Java & XSLT

de Eric M.Burke
Public visé : Expérimentés
Introduction : La puissance de XSLT avec Java

Résumé de l'éditeur

Java vous offre du code portable et XML des données indépendantes de la plate-forme. XSL Transformations (XSLT) permet de transformer les documents XML dans des formats différents. Mais comment transformer ces données, comment les traduire dans un autre langage, comment utiliser XSLT dans un environnement Java ?

Cet ouvrage se concentre sur l'alliance de Java et de XSLT, explicitement conçu pour transformer des documents XML. À travers des cas concrets, le coeur de l'ouvrage aborde les aspects de transformations de documents dans des applications À stand-alone ou des servlets pour des cas aussi variés que les forums de discussion, ou la mise en forme de contenu pour des À appareils sans fil. De nombreux cas pratiques sont abordés dans cet ouvrage : feuilles de style, transformations de À documents, traitement de formulaires.

Citons quelques-uns des thèmes abordés :

- Introduction à XSLT

- Technologies web basées sur Java (détail de l'architecture modèle-vue-contrôleur, utiliser les EJB)

- Traitements XSLT avec Java (XML et SAX, les techniques de cache, interopérer avec DOM et JDOM)

- Feuilles de style et compilation

- XSLT et les Servlets

- Construction d'applications web avec XSLT (modèles XSLT, cookies)

- Internationalisation

- XSLT et les technologies sans fil (WML)

- Optimisation des performances, test

- Référence de l'API JAXP et du langage XSLT.

Java et XSLT aidera le programmeur Java à tirer parti de la puissance de XSLT pour des servlets ou des applications autonomes. Il permettra au développeur de réaliser des applications web complètes. La principale étude de cas est consacrée à une application de forum de discussion, à laquelle deux chapitres sont dévolus.

498 pages, 1er mars 2002 

Édition O'Reilly

ISBN10 : 2-84177-205-5

Commandez sur www.amazon.fr :

40.85 € TTC seulement (au lieu de 43.00  € TTC : prix éditeur) livraison gratuite !
Critique du livre par la rédaction LFE

O'Reilly nous offre ici un livre d'un peu plus de 500 pages, destiné à nous apprendre à utiliser XSLT avec Java.

On pourrait se poser la question suivante : que peut-on raconter sur Java et XSLT en 500 pages ? Et bien, beaucoup de choses très intéréssantes dans ce cas.

Les exemples sont simples, pratiques, sans fioritures inutiles mais permettent de comprendre rapidement les notions exposées. Les textes sont clairs et agréables à lire.

Ce livre n'est pas uniquement centré sur son sujet annoncé mais s'étend un peu sur des sujets annexes, tels que les servlets, la sécurité de ces mêmes servlets par rapport aux threads, aussi bien que par rapport aux utilisateurs. Les notions de bases de XML et des parseurs sont rappelées rapidement mais pas baclées. La génération du XML, par exemple à partir de bases de données est aussi évoquée. Ainsi que bien d'autres sujets périphériques.

En conclusion, un livre complet, assez dense mais très clair et tout à fait abordable, même par des débutants un peu curieux (tels que moi) qui couvre bien son sujet et ses interconnections avec d'autres technologies.

 
couverture du livre Au Coeur de Java 2 JDK 5, Vol.1

Note 5.0drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Au Coeur de Java 2 JDK 5, Vol.1

Notions Fondamentales

de Cay S. Hortsmann, Gary Cornell
Traducteur(s) : Christiane Silhol, Nathalie Le Guillou de Penanros
Public visé : Expérimentés
Introduction : Ouvrage de référence pour le J2SE

Résumé de l'éditeur

"Cet ouvrage aborde les bases du J2SE (Java 2 Platform, Standard Edition). Constituant un didacticiel fort pertinent et un outil de référence incontournable, cet ouvrage se base sur des cas concrets qui ont fait leurs preuves dans le monde réel. Les principales caractéristiques et fonctionnalités de la bibliothèque sont présentées dans des programmes qui, malgré leur simplicité, n'en demeurent pas moins parfaitement opérationnels. Enfin, tous les programmes ont été mis au goût du jour du J2SE 5.0 et constituent donc de très bons points de départ pour vos propres créations. Les exemples proposés ne sont jamais dérisoires, ce livre étant destiné aux programmeurs désireux d'écrire du code pour résoudre des problèmes concrets." (les auteurs)

855 pages, 7ème édition, 1er décembre 2004 

Édition CampusPress

ISBN10 : 2-7440-1833-3

format : 19x23x5 cm, poids : 1575 gr.

Commandez sur www.amazon.fr :

38.00 € TTC seulement (au lieu de 40.00  € TTC : prix éditeur) livraison gratuite !
  1. Une introduction à Java
  2. L'environnement de programmation de Java
  3. Structures fondamentales de la programmation Java
  4. Objets et classes
  5. L'héritage
  6. Interfaces et classes internes
  7. Programmation graphique
  8. Gestion des événements
  9. Swing et les composants d'interface utilisateur
  10. Déployer des applets et des applications
  11. Exceptions et mise au point
  12. Les flux et les fichiers
  13. Programmation générique

Annexes

  1. Les mots clés de Java
  2. Adaptation en amont du code du JDK 5.0

 
Critique du livre par la rédaction Nourdine Falola

Un excellent ouvrage sur le langage Java. Il traite des bases du J2SE et s'adresse au développeur, confirmé dans un autre langage, souhaitant se mettre à Java, comme au développeur Java (intermédiaire ou confirmé) désirant posséder un ouvrage de référence et découvrir les nouveautés du JDK 5.0.

Une mise en page claire et soignée, ainsi qu'une bonne démarche pédagogique appuyée par des exemples simples et pertinents, permettent un apprentissage rapide et efficace du langage.

Des encarts (info, info C++, astuce, attention) informent le lecteur sur des points qu'il est bon de souligner, comme les équivalences/différences avec le C++ ou les pièges à éviter.

Pour chaque nouvel appel à l'API, une brève description de celui-ci est donnée à la fin de la section concernée. Et pour chaque nouveauté du JDK 5.0, son équivalent dans le précédent JDK est proposé, s'il existe. Une annexe regroupe d'ailleurs ces équivalences.

Aucun CD-ROM n'accompagne cette 7ème édition, mais les sources des exemples données dans l'ouvrage sont disponibles au téléchargement sur le site de l'éditeur.

Après avoir acquis les bases du J2SE, nul doute que vous voudrez aborder les fonctionnalités avancées du langage avec "Au Coeur de Java 2, vol.2 - Fonctions Avancées".

Ayant personnellement débuté en Java avec cet ouvrage, et pour avoir été très satisfait de ma rapide progression dans l'utilisation de ce langage, je ne peux que vous le conseiller!

 
couverture du livre Java Efficace

Note 5.0drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Java Efficace

Guide de Programmation

de Joshua Bloch
Traducteur(s) : Alexis Moussine-Pouchkine
Public visé : Expérimentés

Résumé de l'éditeur

Ce guide, écrit par un expert de Sun Microsystems, présente cinquante-sept règles de programmation concourant à l'écriture de programmes efficaces pour la plateforme Java. Fruit de l'expérience des créateurs de Java et des défis de programmation relevés au quotidien, chaque règle illustre divers aspects du langage et de ses difficultés au moyen de conseils, recommandations - ce qu'il faut faire ; ce qu'il ne faut pas faire - et d'exemples détaillés : son bon usage idiomatique, ses subtilités et ses pièges, ses patterns et antipatterns.

Excédant la seule programmation Java, ces règles serviront de viatique pour la programmation objet en général et la production de code clair, correct, efficace, robuste et réutilisable.

Les bibliothèques Java (java.lang, java.util et dans une moindre mesure java.io) sont également abordées, ainsi que la sérialisation.

"J'aurais voulu avoir ce livre il y a dix ans. Certains peuvent penser que je n'ai besoin d'aucun livre sur Java, mais celui-ci fait exception." James Gosling, ancien vice-président de Sun Microsystems, co-créateur du langage Java.

272 pages, 1er juin 2002 

Édition Vuibert

ISBN10 : 2-7117-4805-7

Commandez sur www.amazon.fr :

30,40 € TTC (prix éditeur 32 € TTC) livraison gratuite !

Création et destruction d'objets

  • 1. Privilégier des méthodes de fabrique statiques aux constructeurs
  • 2. Appliquer la propriété du singleton avec un constructeur privé
  • 3. Empêcher l'instanciation avec un constructeur privé
  • 4. Empêcher la duplication d'objets
  • 5. Éliminer les références d'objets obsolètes
  • 6. Éviter les finaliseurs

Méthodes communes à tous les objets

  • 7. Obéir au contrat général lors d'une redéfinition de la méthode equals
  • 8. Toujours redéfinir hashCode lorsque equals est redéfini
  • 9. Toujours redéfinir toString
  • 10. Redéfinir judicieusement clone
  • 11. Envisager l'implémentation de Comparable

Classes et Interfaces

  • 12. Restreindre l'accès des classes et de leurs membres
  • 13. Favoriser l'immuabilité
  • 14. Préférer la composition à l'héritage
  • 15. Prévoir et documenter l'héritage ou bien l'interdire
  • 16. Préférer les interfaces aux classes abstraites
  • 17. N'utiliser les interfaces que pour définir les types
  • 18. Favoriser les classes imbriquées statiques

Équivalents pour constructions du langage C

  • 19. Remplacer les structures par des classes
  • 20. Remplacer une union par une hiérarchie de classes
  • 21. Remplacer les constructions enum par des classes
  • 22. Remplacer les pointeurs de fonctions par des classes et des interfaces

Méthodes

  • 23. Vérifier la validité d'un paramètre
  • 24. Procéder à des recopies défensives en cas de besoin
  • 25. Concevoir avec attention la signature d'une méthode
  • 26. Utiliser la surcharge avec discernement
  • 27. Renvoyer des tableaux vides plutôt que null
  • 28. Écrire des commentaires de documentation pour tous les éléments exposés d'une API

Programmation générale

  • 29. Minimiser la portée des variables locales
  • 30. Connaître et utiliser les bibliothèques
  • 31. Éviter float et double si un résultat exact est requis
  • 32. Éviter les chaînes de caractères là où d'autres types sont plus appropriés
  • 33. Attention à la performance dans la concaténation de chaînes de caractères
  • 34. Faire référence à un objet via son interface
  • 35. Préférer les interfaces à la réflexion
  • 36. Utiliser judicieusement les méthodes natives
  • 37. Optimiser judicieusement
  • 38. Suivre les conventions de nommage généralement acceptées

Exceptions

  • 39. N'utiliser une exception que dans des situations exceptionnelles
  • 40. Utiliser une exception vérifiée pour une situation récupérable et une exception non vérifiée pour une erreur de programmation
  • 41. Ne pas abuser des exceptions vérifiées
  • 42. Préférer l'utilisation d'une exception standard
  • 43. Lever des exceptions en rapport avec l'abstraction
  • 44. Documenter toutes les exceptions levées par une méthode
  • 45. Inclure l'information de contexte dans les messages détaillés
  • 46. Garantir l'atomicité d'une erreur
  • 47. Ne pas ignorer une exception

Threads

  • 48. Synchroniser l'accès à toute donnée partagée et muable
  • 49. Éviter toute synchronisation excessive
  • 50. Ne jamais invoquer wait en dehors d'une boucle
  • 51. Ne pas s'appuyer sur l'ordonnanceur de threads
  • 52. Documenter la sûreté des threads
  • 53. Éviter les groupes de threads

Sérialisation

  • 54. Implémenter judicieusement Serializable
  • 55. Envisager l'utilisation d'une sérialisation sur mesure
  • 56. Rédiger la méthode readObject de manière défensive
  • 57. Fournir une méthode readResolve lorsque cela est nécessaire

Annexes

  • Bibliographie
  • Index des idiomes et patterns
  • Index

 
Critique du livre par la rédaction Baptiste Wicht le 1er février 2007 

Ce livre est fait non seulement pour toutes les personnes qui doivent écrire des librairies qui vont être réutilisées par d'autres, mais aussi pour les simples développeurs qui produiront un code plus solide. En effet, l'auteur de ce livre (chef de projet chez Sun Microsystems) vous donne en une série de 57 conseils pour développer une librairie plus stable, plus performante, plus propre et plus facilement utilisable.

Il commence par parler de la création et de la destruction d'objets et de la façon de les rendre plus performantes. Il traite ensuite des méthodes communes à tous les objets, c'est-à-dire des méthodes héritées d'Object et de comment correctement les implémenter. Le chapitre suivant traite des interfaces et des bonnes pratiques de la conception orientée objet. Puis, il enchaine sur les équivalents du langage C indiquant, par exemple, comment remplacer les unions en Java. Les chapitres suivants traitent des méthodes et de la programmation en général, indiquant par exemple comment optimiser judicieusement son code. Les 3 derniers chapitres sont chacun très spécifiques, parlant tout d'abord des exceptions, puis des threads, et enfin de la sérialisation.

En conclusion, ce livre est indispensable à toute personne voulant écrire une API correctement maintenable et réutilisable. Le style de l'auteur permet de lire ce livre avec une très grande fluidité malgré la grande dose d'informations.

Critique du livre par la rédaction Christophe Jollivet

Programmez-vous correctement?

Ce livre s'adresse à ceux qui connaissent déjà Java, mais souhaitent produire un code solide. Si vous travaillez en équipe, il vous est sans doute arriver d'écrire des classes ou API qui sont ensuite utilisées par vos collègues. Malheureusement, l'usage que font vos collègues de votre travail entraine soit des erreurs de comportement soit des plantages dans votre code. Il peuvent même vous amener à devoir corriger une grande partie de l'application le jour où vous voulez faire évoluer votre API. Si cela vous est arrivé, ce livre est pour vous.

Il est constitué d'une série de57 recommandations. Ces recommandations peuvent se lire dans n'importe quel ordre, et présentent souvent des références les unes vers les autres. Elle sont regroupées par thématiques comme le montre la table des matières ci dessous et sont accompagnées d'exemples de code. Vous y trouverez même quelques critiques sur les API du JDK. Certaines se lisent tres vite (une page et demi), d'autres font près d'une dizaine de pages et demandent des efforts de concentration. Le style rédactionnel est très agréable à lire, même si la densité d'informations est élevée.

Ces conseils fournis par l'auteur d'une partie de java.util vous permettront de comprendre toutes les règles nécessaires au développement d'une API solide. Qu'il s'agissent d'immuabilité, de prévoir ou empêcher l'héritage et la surcharge, gérer la visibilité des méthodes et attributs, utiliser correctement les Exceptions et les Thread, vous trouverez une mine d'informations et surtout de bons conseils dans ce livre.

 
precedentsommairesuivant

  

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 © 2004 - 2013 Equipe JAVA Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.