Développement Desktop Java

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.

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.

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/

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.

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.

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.

É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.

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.

Introduction
Poussé par la notoriété grandissante des dernières versions 5.x et de la très attendue version 6, Rich Client Platform : Plugging into the Netbeans Platform est le deuxième livre présentant Netbeans comme plateforme de client riche. Apportant une nouvelle expérience du développement d'application RCP, le site Netbeans.org restait jusqu'à aujourd'hui la principale source d'information pour apprendre à profiter de la plateforme : API très riche, documents techniques, nombreux tutoriaux offerts par la communauté, sans oublier la mailing-list très active. Cependant, il manquait une introduction aux concepts de base de l'architecture et c'est le défi que les auteurs ont su relever avec qualité au travers des 22 chapitres de ce livre.

Les auteurs
Tim Boudreau, aujourd'hui évangéliste pour la plateforme,il fût un des auteurs du premier livre sur Netbeans RCP; Jaroslav Tulach, garant du projet OpenIDE, il fût un des fondateurs de Netbeans dans les années 1997; enfin Geertjan Wielenga, rédacteur technique des branches module et RCP de Netbeans, son blog https://blogs.oracle.com/geertjan/ n'est plus à présenter aux développeurs ayant déjà utilisé la plateforme.

La critique
Le livre commence par 4 chapitres proposant de faire nos premiers pas avec Netbeans et l'architecture modulaire. Vous y découvrirez d'abord comment créer un nouveau module, puis comment il est structuré (layer.xml, bundle.properties, …). Les auteurs décrivent ensuite les intérêts à découper une application en plusieurs modules et les avantages que Netbeans apporte dans ce domaine : les différents types de modules qui coexistent au sein du contrôleur et les différentes façons de les faire communiquer.

Les 7 chapitres suivants détaillent les principales API au coeur de Netbeans. Vous découvrirez la puissance des Lookups, fournissant entre autre un moyen de dialoguer entre modules, les Filesystems offrant un accès unifié aux sources de données (répertoire/ fichier, jar, xml, …) et l'intégration d'une structure d'information grâce aux Nodes. C'est aussi au travers de ces chapitres que vous apprendrez à utiliser les vues de Netbeans, à organiser les fenêtres et à adapter l'interface en fonction des éléments sélectionnés.

Suivent 8 chapitres qui traitent des API plus spécifiques à l'IDE. Tout d'abord vous apprendrez à réaliser un support complet d'un type de fichier dans l'éditeur de code, exemple basé sur les fichier manifest (.mf) : vues multiples et représentation graphique, coloration syntaxique, auto complétion, liens inter document, mise en évidence des erreurs et drag & drop grâce à la palette. Puis vous verrez comment apporter une meilleure expérience utilisateur avec le panneau des options, la mise à disposition d'une documentation et le centre de mise à jour.

Pour finir, les 4 derniers chapitres proposent une approche plus concrète des concepts étudiés tout au long du livre. Vous verrez tout d'abord avec quelle facilité il est possible d'ajouter le support d'un framework au projet Web standard ; Comment faire communiquer un module et un WebService avec moins de 10 lignes de codes ; Pour finir, 2 exemples fonctionnels complets sont détaillés : le support de l'outil Tidy via un plugin Netbeans et une application RCP de manipulation d'une bande sonore. Le livre se clôt enfin par 3 appendices ciblés sur les bonnes pratiques de design et de performances à privilégier lors du développement de module Netbeans.

En conclusion, ce livre est une parfaite introduction à la prise en main de la plateforme Netbeans. On peut regretter l'oubli des Wizards, formulaire à étapes multiples, bien qu'introduits dans plusieurs chapitres (et sur le blog de Geertjan). Néanmoins ce livre couvre les aspects vitaux pour maîtriser la puissance de la plateforme. Il englobe aussi la version 5,5 et chaque point est décrit par un code source clair et illustré (aussi dispo sur le cdrom). Captivant, structuré et d'un anglais largement abordable, ce livre est indispensable à tous les développeurs de plugins et d'applications RCP et je le conseille vivement aux personnes qui souhaitent en connaître davantage sur la plateforme.

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.

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 !

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.

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.

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.

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.

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

Cet ouvrage, écrit par l'un des acteurs majeurs de la communauté Hibernate, vous présente la démarche de mapping Objet/Relationnel, et en particulier l'implémentation Hibernate 3.0.

Après quelques rappels historiques et l'évocations des solutions passées et présentes, l'auteur nous fait partager toute sa connaissance d'Hibernate à travers des exemples simples et pertinents.
Suffisamment détaché de la documentation officielle, ce livre vous apprendra Hibernate 3.0 de A à Z en illustrant le propos par de nombreux exemples, dans un style agréable à lire et efficace.

Il y en a pour tous les goûts : que ce soit le débutant qui souhaite s'initier à cette solution de gestion de la persistance, le connaisseur qui est à la recherche de conseils et de bonnes pratiques, ainsi que l'expérimenté toujours à l'affût des nouveautés, améliorations, notions avancées, fonctionnalités à venir.

En conclusion, cet ouvrage complet ne devrait pas vous décevoir, et vous accompagnera dans votre démarche de gestion de la persistance avec l'une des (futures) implémentations de la norme EJB 3.0.
Retrouvez la critique complète ici.

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.

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!

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.

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.