Livres Java : Java SE

Détails du livre

Critiques (0)

0 commentaire

Aide-mémoire Java

de Vincent Granet

Public visé : Débutant

Résumé de l'éditeur

Cet ouvrage constitue un solide point de départ pour l'initiation au monde Java. Il a été conçu pour offrir une présentation pédagogique et condensée des aspects fondamentaux et appliqués de ce langage : 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.
Aucune connaissance en Java n'est pré-requise, vous pouvez donc aborder cet ouvrage en toute quiétude, et acquérir les bons réflexes de programmation en Java ! Cette 4e édition tient compte de toutes les nouveautés apportées par Java 8 (chargement de sons et d'images pour les interfaces graphiques, chargement dynamique des classes, lambda-expressions et programmation fonctionnelle).

Édition : Dunod - 310 pages, 4^e édition, 15 juillet 2015

ISBN10 : 9782100727131 - ISBN13 : 9782100727131

Commandez sur www.amazon.fr :

0.00 € TTC (prix éditeur 0.00 € TTC)

Aucune critique n'a été faite pour l'instant

Commenter Signaler un problème

trentks95 - Membre habitué

l 03/01/2020 à 7:16

Aide-mémoire Java

Cet ouvrage constitue un solide point de départ pour l'initiation au monde Java. Il a été conçu pour offrir une présentation pédagogique et condensée des aspects fondamentaux et appliqués de ce langage : 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.
Aucune connaissance en Java n'est pré-requise, vous pouvez donc aborder cet ouvrage en toute quiétude, et acquérir les bons réflexes de programmation en Java ! Cette 4e édition tient compte de toutes les nouveautés apportées par Java 8 (chargement de sons et d'images pour les interfaces graphiques, chargement dynamique des classes, lambda-expressions et programmation fonctionnelle).

[Lire la suite]

Avez-vous lu ce livre ou pensez-vous le lire ?
Souhaitez-vous ajouter une critique de ce livre sur la page de la rubrique ?
Avez-vous un commentaire à faire ?

Détails du livre

Sommaire

Critiques (1)

0 commentaire

Java 7

de Robert Chevallier

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.

Édition : Pearson Education - 250 pages, 1^re édition, 5 août 2011

ISBN10 : 274407537X - ISBN13 : 9782744075377

Commandez sur www.amazon.fr :

20.09 € TTC (prix éditeur 22.00 € TTC)

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 prenom nom le 1^er 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.

Commenter Signaler un problème

Djug - Expert éminent sénior

l 07/10/2011 à 12:17

Bonjour,

La rédaction de DVP a lu pour vous l'ouvrage suivant:
Java 7, de Robert Chevallier

Envoyé par 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.

L'avez-vous lu? Comptez-vous le lire bientôt?

Quel est votre avis?

Détails du livre

Sommaire

Critiques (1)

Java - La maîtrise

Java 5 et 6

de Jérôme Bougeault

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

Édition : Eyrolles - 550 pages, 2^e édition, 7 février 2008

ISBN10 : 2212122500 - ISBN13 : 9782212122503

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 11 avril 2011

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

Détails du livre

Sommaire

Critiques (1)

0 commentaire

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

de Steven-John Metsker, William-C Wake

Public visé : Expert

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.

Édition : Campus Press - 520 pages, 2^e édition, 3 décembre 2009

ISBN10 : 2744023965 - ISBN13 : 9782744023965

Commandez sur www.amazon.fr :

39.09 € TTC (prix éditeur 42.00 € TTC)

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 Nicolas Vallée le 1^er 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.

Commenter Signaler un problème

gorgonite - Rédacteur/Modérateur

l 01/10/2010 à 9:55

Bonjour,

J'ai eu l'occasion de lire l'ouvrage Les Design Patterns en Java : Les 23 modèles de conception fondamentaux, publié en 2ème édition chez Pearson

Envoyé par résumé é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.

consulter ma critique

n'hésitez pas à partager vos avis sur cet ouvrage à la suite de mon post

à tous

couverture du livre Programmation concurrente en Java

Détails du livre

Sommaire

Critiques (2)

10 commentaires

Programmation concurrente en Java

de Brian Goetz

Traducteurs : Eric Jacoboni

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.

Édition : Pearson Education - 370 pages, 1^re édition, 1^er mai 2009

ISBN10 : 2744023337 - ISBN13 : 9782744023330

18,5 cm x 23 cm, 795g

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC)

Les bases
- Thread safety
- Partage des objets
- Composition d'objets
- Briques de base
Structuration des applications concurrentes
- Exécution des tâches
- Annulation et arrêt
- Pools de threads
- Applications graphiques
Vivacité, performances et tests
(list]
Éviter les problèmes de vivacité
Performances et adaptabilité
Tests des programmes concurrents

[*]Sujets avancés

Verrous explicites
Construction de synchronisateurs personnalisés
Variables atomiques et synchronisation non bloquante
Le modèle mémoire de Java

[/list]

Critique du livre par la rédaction prenom nom le 1^er août 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 1^er 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.

Commenter Signaler un problème

benwit - Rédacteur

l 06/08/2010 à 8:08

Je viens de lire "Programmation concurrente en Java" et je vous le recommande vivement.

Une chose m'a particulièrement marqué :
Trop peu de développeurs se soucient de la justesse de leur programme. Un peu comme pour la propreté du code (cf Clean Code), ils sont nombreux à s'arrêter dès que ça fonctionne ! Or en ce qui concerne la concurrence, les conditions limites vont s'exprimer le plus souvent en production et non en développement.

Je ne dis pas qu'il faut faire systématiquement du code multithread (cela à un coût certain) mais au minimum de l'indiquer pour ceux qui viennent après. L'auteur fait d'ailleurs remarqué que même de nombreux frameworks connus ne l'indiquent pas et on est alors obligé de le deviner en se mettant à leur place !!! C'est pourquoi il propose à la fin de son ouvrage des annotations pour l'indiquer explicitement.

Quelle est votre opinion sur le sujet ?
Est-ce que vous y penser en développant ? Est-ce que vous y penser parce que vous avez des comportements étranges en production ?
Etes vous sensibiliser sur le sujet ? Allez vous faire gaffe à l'avenir ?
Que pensez vous de sa proposition des annotations ?

divxdede - Membre éclairé

l 06/08/2010 à 11:16

Bonjour,
La javadoc de l'api standard est bien fichue de ce coté là est indique le plus souvent si une classe est 'thread-safe' ou non.
A mon sens, il s'agit avant tout d'un problème de documentation et l'annotation n'y changera pas grand chose. A savoir lorsqu'elle sera absente, on ne saura pas ce qu'il faut en conclure.

Deaf - Membre éprouvé

l 06/08/2010 à 11:34

Envoyé par benwit

Trop peu de développeurs se soucient de la justesse de leur programme.

Je pense que cela vient du fait que nombre de développeurs ne sont pas à l'aise avec la concurrence. Beaucoup pensent résoudre les problème en métant un 'synchronized' devant LA méthode qui pose problème

Envoyé par benwit

ils sont nombreux à s'arrêter dès que ça fonctionne

Je confirme, la pratique trop souvent répandue est de se poser les questions de concurrence que lorsque des erreurs se produisent. Dès que ça semble rouler, on oublie cette vilaine bête noire...

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

Détails du livre

Sommaire

Critiques (1)

0 commentaire

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

Collections : Les TP Informatiques

de Alexandre Brillant

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.

Édition : ENI - 300 pages, 1^er mai 2007

ISBN10 : 2746036134 - ISBN13 : 9782746036130

Commandez sur www.amazon.fr :

25.65 € TTC (prix éditeur 27.00 € TTC)

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 yolepro le 1^er 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.

Commenter Signaler un problème

-

l 22/11/2020 à 22:24

Java 6 : Entraînez-vous et maîtrisez Java par la pratique
Collections : Les TP Informatiques

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.

[Lire la suite]

Avez-vous lu ce livre ou pensez-vous le lire ?
Souhaitez-vous ajouter une critique de ce livre sur la page de la rubrique ?
Avez-vous un commentaire à faire ?

Détails du livre

Sommaire

Critiques (1)

Hardcore Java

de Robert Simmons Jr

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.

Édition : O'Reilly - 400 pages, 1^re édition, 1^er janvier 2004

ISBN10 : 0596005687 - ISBN13 : 9780596005689

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 19 décembre 2013

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.

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.

Édition : Manning Publications - 696 pages, 1^re édition, 24 janvier 2007

ISBN10 : 1932394842 - ISBN13 : 9781932394849

Broché

Commandez sur www.amazon.fr :

39.35 € TTC (prix éditeur 39.35 € TTC)

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 Hikage le 24 juin 2007

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

Détails du livre

Sommaire

Critiques (1)

Harnessing Hibernate

de James Elliott, Tim O'Brien, Ryan Fowler

Public visé : Débutant

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.

Édition : O'Reilly - 380 pages, 1^re édition, 1^er mai 2008

ISBN10 : 0596517726 - ISBN13 : 9780596517724

Commandez sur www.amazon.fr :

28.12 € TTC (prix éditeur 29.91 € TTC)

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 Petrus le 24 février 2009

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.

Détails du livre

Sommaire

Critiques (3)

1 commentaire

Effective Java

Second Edition

de Joshua Bloch

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.

Édition : Addison Wesley - 384 pages, 2^e édition, 28 mai 2008

ISBN10 : 0321356683 - ISBN13 : 9780321356680

Commandez sur www.amazon.fr :

27.16 € TTC (prix éditeur 38.48 € TTC)

Introduction
Creating and Destroying Objects
Methods Common to All Objects
Classes and Interfaces
Generics
Enums and Annotations
Methods
General Programming
Exceptions
Concurrency
Serialization

Critique du livre par la rédaction olivier pitton le 28 juin 2013

Que vous soyez débutant ou expert en développement Java, cet ouvrage est une référence absolue. Pas de frameworks et autres outils, ce livre reste dans la base de Java, utilisée quotidiennement par tous les développeurs utilisant cette plateforme. En seulement 57 recommandations, vous pouvez découvrir un ensemble de bonnes pratiques sur Java, tant en conception qu'en technique.
Les conseils donnés ne se retrouvent pas dans les ouvrages communs, mais sont uniques et apportent une réelle plus-value au lecteur. En parallèle, beaucoup de recommandations sont décrites avec du code et des exemples d'utilisations précis.
Enfin, les plus célèbres évangélistes du monde Java, comme James Gosling ou le docteur Heinz Gabutz, en font une excellente critique.
En bref, ce livre n'est pas optionnel pour quiconque est désireux de se lancer professionellement dans le monde Java, ou simplement d'en apprendre plus.

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.

Critique du livre par la rédaction joseph_p le 1^er 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 !

Commenter Signaler un problème

dourouc05 - Responsable Qt & Livres

l 20/09/2011 à 21:20

Effective Java: Amazon.fr: Joshua Bloch: Livres anglais et étrangers

La critique.

Vous l'avez lu ? Qu'en pensez-vous ?

olivier.pitton - Membre émérite

l 08/07/2013 à 12:41

Bonjour,

Je pense que ce livre est une référence dans le monde Java. Fini les ouvrages où l'on explique les bases de Java sans aller un minimum dans les profondeurs. 57 recommandations pour apprendre à mieux coder et comprendre, le tout écrit par un vétéran de Sun, et recommandé par les plus grands nom du monde Java.

Le livre est très bien structuré, les conseils sont alimentés par du code et chaque recommandation est à lire et à relire.

En bref, je le conseille à tous.

Détails du livre

Sommaire

Critiques (1)

Filthy Rich Clients

de Chet Haase, Romain Guy

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.

Édition : Prentice Hall PTR - 608 pages, 1^re édition, 19 août 2007

ISBN10 : 0132413930 - ISBN13 : 9780132413930

Broché

Commandez sur www.amazon.fr :

0.00 € TTC (prix éditeur 0.00 € TTC)

Graphics and GUI Fundamentals
- Desktop Java Graphics APIs: Swing, AWT, and Java 2D
- Swing Rendering Fundamentals
- Graphics Fundamentals
- Images
- Performance
Advanced Graphics Rendering
- Composites
- Gradients
- Image Processing
- Glass Pane
- Layered Panes
- Repaint Manager
Animation
- Animation Fundamentals
- Smooth Moves
- Timing Framework: Fundamentals
- Timing Framework: Advanced Features
Effects
- Static Effects
- Dynamic Effects
- Animated Transitions
- Birth of a Filthy Rich Client

Critique du livre par la rédaction Fabrice Bouyé le 1^er 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

Détails du livre

Sommaire

Critiques (2)

Java Persistence et Hibernate

de Anthony Patricio

Public visé : Intermédiaire

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.

Édition : Eyrolles - 365 pages, 1^re édition, 18 décembre 2007

ISBN10 : 2212122594 - ISBN13 : 9782212122596

Commandez sur www.amazon.fr :

39.09 € TTC (prix éditeur 42.00 € TTC)

Préface
Remerciements
Table des matières
Avant-propos
Persistance et mapping objet-relationnel
Démarrer avec Java Persistence
Métdadonnées et mapping des entités
Héritage, polymorphisme et modèles complexes
Méthodes de récupération des entités
Création, modification et suppression d'entités
Obtenir et manipuler le gestionnaire d'entités
Fonctionnalités de mapping avancées
La suite Hibernate Tools
Projets annexes Java Persistence/Hibernate
Index

Critique du livre par la rédaction TheLeadingEdge le 1^er 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 1^er 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.

Détails du livre

Sommaire

Critiques (3)

Programmer en Java

de Claude DelannoY

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.

Édition : Eyrolles - 799 pages, 5^e édition, 11 octobre 2007

ISBN10 : 2212122322 - ISBN13 : 9782212122329

Commandez sur www.amazon.fr :

33.25 € TTC (prix éditeur 35.00 € TTC)

Présentation de Java
Généralités
Les types primitifs de Java
Les opérateurs et les expressions
Les instructions de contrôle de Java
Les classes et les objets
Les tableaux
L'héritage
Les chaînes de caractères et les types énumérés
La gestion des exceptions
Les threads
Les bases de la programmation graphique
Les contrôles usuels
Les boîtes de dialogue
Les menus, les actions et les barres d'outils
Les évènements de bas niveau
Les gestionnaires de mise en forme
Textes et graphiques
Les applets
Les flux et les fichiers
La programmation générique
Les collections et les algorithmes
Programmation Java côté serveur : servlets et JSP
L'introspection et les annotations

Critique du livre par la rédaction Julien Plu le 1^er 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 Faith's Fall le 1^er 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 1^er 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.

Détails du livre

Sommaire

Critiques (1)

Java Generics

and Collections

de Maurice Naftalin, Philip Wadler

Public visé : Intermédiaire

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.

Édition : O'Reilly - 273 pages, 1^re édition, 1^er novembre 2007

ISBN10 : 0596527756 - ISBN13 : 9780596527754

Broché

Commandez sur www.amazon.fr :

21.27 € TTC (prix éditeur 25.01 € TTC)

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 1^er février 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.

Détails du livre

Sommaire

Critiques (1)

Le guide de Survie

Java: L'essentiel du code et des commandes

de Timothy Fisher

Public visé : Intermédiaire

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.

Édition : Campus Press - 232 pages, 1^er mars 2007

ISBN10 : 2744021628 - ISBN13 : 9782744021626

Commandez sur www.amazon.fr :

15.02 € TTC (prix éditeur 16.00 € TTC)

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 vbrabant le 1^er 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.

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ébutant

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.

Édition : Dunod - 348 pages, 2^e édition, 1^er novembre 2005

ISBN10 : 2100492195 - ISBN13 : 9782100492190

Broché

Commandez sur www.amazon.fr :

35.15 € TTC (prix éditeur 37.00 € TTC)

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 1^er 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.

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édiaire

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)

Édition : McGraw-Hill/Osborne Media - 825 pages, 1^re édition, 1^er décembre 2005

ISBN10 : 0072253606 - ISBN13 : 9780072253603

Broché

Commandez sur www.amazon.fr :

38.02 € TTC (prix éditeur 38.02 € 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 Hikage le 1^er 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 Programmation Orienté Aspect pour Java / J2EE

Détails du livre

Sommaire

Critiques (2)

Programmation Orienté Aspect pour Java / J2EE

de R.Pawlak, J.Ph.Retaillé et L.Seinturier

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.

Édition : Eyrolles - 446 pages, 1^er avril 2004

ISBN10 : 2212114087 - ISBN13 : 9782212114089

Commandez sur www.amazon.fr :

42.75 € TTC (prix éditeur 45.00 € TTC)

Les concepts de la POA

1. Introduction : limites de la programmation objet et apports de la POA
2. Notions d'aspect, de coupe, de code advice, de point de jonction…

Principaux outils de POA du monde Java

1. AspectJ
2. JAC (Java Aspect Components)
3. JBoss AOP
4. AspectWerkz
5. Comparaison des outils de POA

Applications de la POA

1. Implémentation des design patterns
2. Qualité de service des applications : design par contrats, tests, supervision des applications
3. Serveurs d'applications et POA

Étude de cas détaillée

1. Utilisation de la POA dans une application J2EE : couches métier, client et présentation

Critique du livre par la rédaction Eric REBOISSON le 1^er 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 doe john le 1^er août 2006

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 Tête la première

Détails du livre

Sommaire

Critiques (1)

Java Tête la première

Couvre Java 5.0

de Kathy Sierra, Bert Bates

Traducteurs : Marie-Cécile Baland

Public visé : Débutant

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 !

Édition : O'Reilly - 687 pages, 2^e édition, 1^er novembre 2006

ISBN10 : 2841774112 - ISBN13 : 9782841774111

Commandez sur www.amazon.fr :

46.55 € TTC (prix éditeur 49.00 € TTC)

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

Critique du livre par la rédaction afrikha le 1^er 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

Détails du livre

Sommaire

Critiques (3)

Les Cahiers du programmeur Swing

de Emmanuel Puybaret

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, …

Édition : Eyrolles - 499 pages, 1^re édition, 7 décembre 2006

ISBN10 : 2212120192 - ISBN13 : 9782212120196

Broché

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC)

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 1^er 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 vbrabant le 1^er 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 1^er 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

Détails du livre

Sommaire

Critiques (2)

0 commentaire

Mieux programmer en Java

68 astuces pour optimiser son code

de Petter Haggar

Public visé : Débutant

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.

Édition : Eyrolles - 224 pages, 1^re édition, 1^er juillet 2000

ISBN10 : 2212091710 - ISBN13 : 9782212091717

Commandez sur www.amazon.fr :

28.05 € TTC (prix éditeur 30.00 € TTC)

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 1^er 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.

Critique du livre par la rédaction Lucas Girardin le 30 juin 2014

Je suis tombé sur ce livre un peu par hasard, mais cela a été une vraie bonne surprise. La plupart des choses abordées étaient connues. Mais cette fois-ci on revoit les bonnes pratiques avec une vraie explication sur le comportement du code.
Personnellement je n'ai pas pu m’empêcher de tester ce que j'apprenais dans ce livre sur ma machine. C'est aussi très enrichissant d'essayer ces astuces sur un vrai projet (personnel et déjà finalisé de préférence) afin d'encore mieux appréhender ce qui est dit dans ce livre.
Le livre est abordable pour un débutant, qui butera certainement sur quelques chapitres comme les threads ou les exceptions s'il n'a jamais dû s'en servir, mais rien d'insurmontable.
Le dernier chapitre sur les classes et interfaces est un peu à prendre avec des pincettes étant donné l'ancienneté du livre. Mais ça reste une bonne lecture.

Commenter Signaler un problème

MarieKisSlaJoue - Membre expert

l 01/07/2014 à 15:00

Vous avez vous aussi dans votre bureau une bibliothèque de livre datant de tellement longtemps que plus personne ne sais qui les a achetés ? Coincé entre deux livre sur java 2 j'ai trouvé dans ma bibliothèque le livre de Petter Haggar, "Mieux programmer en Java - 68 astuces pour optimiser son code" La dernière critique datant de 7 ans je me suis demandé si il était toujours au gout du jour.
Il à pris un coup de vieux mais mérite quand même de l’intérêt pour les débutants. Avec ces 200 pages il est assez rapide à lire.
http://java.developpez.com/livres/in...ts#L2212091710

Détails du livre

Sommaire

Critiques (1)

Exercices en Java

Couvre Java 5.0

de Claude Delannoy

Public visé : Débutant

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.

Édition : Eyrolles - 313 pages, 2^e édition, 1^er août 2006

ISBN10 : 2212119895 - ISBN13 : 9782212119893

Commandez sur www.amazon.fr :

18.91 € TTC (prix éditeur 19.09 € TTC)

Les opérateurs et les expressions
Les instructions de contrôle
Les classes et les objets
Les tableaux
L'héritage et le polymorphisme
La classe String et les chaînes de caractères
Les exceptions
Les bases de la programmation événementielle
Les principaux contrôles de Swing
Les boîtes de dialogue
Les menus
Les événements de bas niveau
Les applets
Les flux et les fichiers
La programmation générique

Critique du livre par la rédaction vbrabant le 1^er 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 Java 6 : Entraînez-vous et maîtrisez Java par la pratique, 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

Détails du livre

Sommaire

Critiques (1)

Les expressions régulières par l'exemple

de Vincent Fourmond

Public visé : Intermédiaire

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.

Édition : Technique & Pratiques - 126 pages, 1^re édition, 1^er juillet 2005

ISBN10 : 2914010656 - ISBN13 : 9782914010658

Commandez sur www.amazon.fr :

9.31 € TTC (prix éditeur 9.08 € TTC)

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 yga le 1^er juillet 2006

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 !

Détails du livre

Sommaire

Critiques (1)

Java en concentré

Manuel de référence pour Java

de David Flanagan

Public visé : Débutant

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.

Édition : O'Reilly - 1418 pages, 5^e édition, 1^er février 2006

ISBN10 : 284177371X - ISBN13 : 9782841773718

18 x 6 x 24 cm

Commandez sur www.amazon.fr :

51.03 € TTC (prix éditeur 54.00 € TTC)

Introduction
- Qu'est ce que Java ?
- Les avantages clés de Java ?
- Un exemple de programme
La syntaxe Java
- Programmes Java dans leur ensemble
- Types de données primitifs
- Expressions et opérateurs
- Instructions
- Méthodes
- Introduction aux classes et objets
- Tableaux
- Types références
- Paquetages et espace de désignation en Java
- Structure des fichiers Java
- Définir et exécuter des programmes Java
- Différences entre C et Java
La programmation orientée objet en Java
(list]
Syntaxe de la définition des classes
Champs et méthodes
Création et initialisation d'objets
Destruction et finalisation d'objets
Sous-classes et héritage
Masquage des données et encapsulation
Classes et méthodes abstraites
Méthodes importantes de java.lang.Object
Interfaces
Types emboîtés
Résumé des modificateurs
Caractéristiques de C++ absentes en Java

[*]Nouveautés du langage Java 5.0

Types génériques
Types énumérés
Annotations

[*]La plate-forme Java

Vue d'ensemble de la plate-forme Java
Texte
Nombre de Maths
Dates et heures
Tableaux
Collections
Threads et programmation concurrente
Fichiers et répertoires
Flux d'entrée et de sortie avec java.io
Interconnexion de réseaux avec java.net
Entrées/sorties et interconnexion de réseaux avec java.nio
XML
Types, réflexion et chargement dynamique
Persistence des objets
Sécurité
Cryptographie
Fonctionnalités diverses

[*]La sécurité en Java

Risques liés à la sécurité
Sécurité de la machine virtuelle Java et vérification des fichiers de classe
Authentification et cryptographie
Contrôle d'accès
Sécurité pour tout le monde
Classes de permissions

[*]Conventions de programmation et de documentation en Java

Conventions liées à l'attribution des noms et à la capitalisation
Conventions de portabilité
Commentaires de documentation en Java
Conventions propres aux JavaBeans

[*]Outils de développement Java[*]Guide de référence[/list]

Critique du livre par la rédaction Ricky81 le 1^er août 2006

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

Détails du livre

Sommaire

Critiques (1)

Les cahiers du programmeur

Java 1.4 et 5.0

de Emmanuel Puybaret

Public visé : Débutant

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…

Édition : Eyrolles - 367 pages, 3^e édition, 1^er mars 2006

ISBN10 : 221211916X - ISBN13 : 9782212119169

21 x 2 x 24 cm

Commandez sur www.amazon.fr :

27.55 € TTC (prix éditeur 29.00 € TTC)

Présentation des études de cas
Principes du langage et installation de l'environnement
Création de classes
Contrôle des traitements avec les opérateurs, boucles et branchements
Réutilisation des classes
Les classes de base de la bibliothèque Java
Abstraction et interface
Gestion des erreurs avec les exceptions
Lecture et écriture des fichiers
Interfaces utilisateur avec Swing
Connexion à la base de données avec JDBC
Programmation Web avec les servlets, JSP et JavaBeans
Interface utilisateur du forum
Echanger des informations avec XML
Messagerie instantanée avec la programmation multitâche

Critique du livre par la rédaction vbrabant le 1^er juin 2006

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

Détails du livre

Sommaire

Critiques (2)

Aide-Mémoire de Java

de Vincent Granet, Jean-Pierre Regourd

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 !

Édition : Dunod - 246 pages, 1^er septembre 2005

ISBN10 : 2100491458 - ISBN13 : 9782100491452

Commandez sur www.amazon.fr :

15.02 € TTC (prix éditeur 16.00 € TTC)

[ist][*]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[/list]

Critique du livre par la rédaction joseph_p le 1^er 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 vbrabant le 1^er mai 2006

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

Détails du livre

Sommaire

Critiques (4)

0 commentaire

Refactoring des applications Java/J2EE

de Jean-Philippe Retaillé

Public visé : Expert

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.

Édition : Eyrolles - 349 pages, 1^er septembre 2005

ISBN10 : 2212115776 - ISBN13 : 9782212115772

Commandez sur www.amazon.fr :

39.09 € TTC (prix éditeur 42.00 € TTC)

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 la rédaction Olivier le 1^er 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 le 1^er mars 2007

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 vbrabant le 1^er juin 2006

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 Delcroix le 1^er janvier 2006

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.

Commenter Signaler un problème

if_zen - Membre averti

l 26/02/2010 à 10:39

Titre de l'ouvrage
Refactoring des applications Java/J2EE

Note sur une échelle de 5
3/5

Votre critique

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-si 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 trouver 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.

La critique en ligne

Détails du livre

Sommaire

Critiques (1)

Hibernate 3.0

Gestion optimale de la persistance dans les applications Java/J2EE

de Anthony Patricio

Public visé : Intermédiaire

Résumé de l'éditeur

Gestion optimale de la persistance dans les applications Java/J2EE : Standard de fait, Hibernate s'est imposé comme la solution idéale pour gérer le délicat problème de la persistance des objets Java/J2EE par mapping vers les bases de données relationnelles. Dans sa version 3, Hibernate fournit déjà une implémentation très avancée du futur standard de la persistance Java/J2EE : EJB 3.0 Persistence API. Un livre pratique illustré d'une étude de cas détaillée : Résolument pratique, cet ouvrage illustre chacune des fonctionnalités d'Hibernate à travers une étude de cas déclinée au fil des chapitres. Il insiste tout particulièrement sur les aspects méthodologiques et sur les questions de performances : maîtrise des fichiers de mapping, gestion optimale des sessions Hibernate, interrogation performante de la base de données, outils de productivité apportés par Hibernate 3.0, configuration des pools de connexions et des caches de second niveau, etc.

Édition : Eyrolles - 317 pages, 1^re édition, 1^er juin 2005

ISBN10 : 2212116446 - ISBN13 : 9782212116441

19 x 2 x 23 cm

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC)

[list][*]Persistance et mapping objet-relationnel

Historique de la persistance en Java
Principes de la persistance
Les autres solutions de persistance
Conclusion

[*]Classes persistantes et session Hibernate

Installation d'Hibernate
Les classes métier persistantes
La session Hibernate
Conclusion

[*]Métadonnées et mapping des classes métier

Référentiel des métadonnées
Les fichiers de mapping
Conclusion

[*]Héritage, polymorphisme et associations ternaires

Stratégies de mapping d'héritage et polymorphisme
Mise en oeuvre d'une association bidirectionnelle
Les autres types d'associations
Conclusion

[*]Méthodes de récupération d'instances persistantes

Le lazy loading, ou chargement à la demande
Les techniques de récupération d'objets
Conclusion

[*]Création, modification et suppression d'instances persistantes

Persistance d'un réseau d'instances
Les transactions
Conclusion

[*]Gestion de la session Hibernate

La session Hibernate
Les transactions applicatives
Utilisation d'Hibernate avec Struts
Gestion de la session dans un batch
Interpréter les exceptions
Conclusion

[*]Fonctionnalités de mapping avancées

Fonctionnalités de mapping liées aux métadonnées
Fonctionnalités à l'exécution
Les nouveaux types de mapping d'Hibernate 3
Conclusion

[*]L'outillage d'Hibernate

L'outillage relatif aux métadonnées
L'outillage Hibernate Tools
Extensions et intégration
Conclusion

Critique du livre par la rédaction Ricky81 le 14 novembre 2005

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.

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

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é : Intermédiaire

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.

Édition : Campus Press - 858 pages, 1^er juin 2005

ISBN10 : 2744019623 - ISBN13 : 9782744019623

Commandez sur www.amazon.fr :

42.75 € TTC (prix éditeur 45.00 € TTC)

Multithreads
Collections
Programmation des bases de données
Objets distribués
Swing
JavaBeans
La sécurité
Internationalisation
Méthodes natives
XML
Annotations

Critique du livre par la rédaction vbrabant le 1^er novembre 2005

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

Détails du livre

Sommaire

Critiques (1)

1 commentaire

Cahiers du programmeur

Java/XML

de Renaud Fleury avec la contribution de Caroline de Vasson

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

Édition : Eyrolles - 217 pages, 1^re édition, 1^er décembre 2004

ISBN10 : 2212113161 - ISBN13 : 9782212113167

21 x 2 x 24 cm

Commandez sur www.amazon.fr :

27.55 € TTC (prix éditeur 29.00 € TTC)

Cahier des charges
Installation de l'environnement de développement
XML, pour configurer et transporter des données
Modélisation et visualisation des objets métier via XML
Struts, partie émergée de l'application ?
Les bases de données XML natives : grand déstockage d'Automne ?
Conception de services web

Critique du livre par la rédaction Ioan le 26 avril 2005

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.

Commenter Signaler un problème

freegreg - Expert éminent

l 13/12/2004 à 16:21

Nouveau livre dédié à la technologie XML : Les Cahiers du Programmeur : Java/XML de Renaud Fleury avec la contribution de Caroline de Vasson aux éditions Eyrolles

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

N'hésitez pas à nous faire de vos impressions dès que vous l'aurez lu

Ioan - Membre émérite

l 26/04/2005 à 10:18

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.

Détails du livre

Sommaire

Critiques (1)

Ant précis & concis

de Stefan Edlich

Public visé : Débutant

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.

Édition : O'Reilly - 110 pages, 30 juin 2002

ISBN10 : 2841771598 - ISBN13 : 9782841771592

Commandez sur www.amazon.fr :

0.00 € TTC (prix éditeur 0.00 € TTC)

Introduction
En trois étapes vers le fichier build
Éléments de base de Ant
Concepts fondamentaux
Paramètres de la ligne de commande
Propriétés prédéfinies
Tâches personnalisées
Perspectives : Ant 2
Tâches prédéfinies
Référence des tâches standard
Tâches optionnelles

Critique du livre par l'équipe Java le 30 novembre 2002

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 :
Une courte introduction à Ant par l'équipe Java
Forum d'entraide Ant
Autres outils pour le développeur Java

Texte de votre critique Image 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 : [url=http://java.developpez.com/tutoriels/introduction-ant-part1/]Une courte introduction à Ant[/url] par l'équipe Java [url=http://www.developpez.net/forums/f318/java/edi-outils-java/build/ant/]Forum d'entraide Ant[/url] [url=http://java.developpez.com/outils/]Autres outils pour le développeur Java[/url]
Date de la critique JJ/MM/AAAA
Qui a réalisé cette critique ?	Moi Un membre de Developpez Son pseudo : Quelqu'un d'autre Son nom :
Note

Détails du livre

Critiques (1)

0 commentaire

Java & XSLT

de Eric M.Burke

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.

Édition : O'Reilly - 498 pages, 1^re édition, 1^er mars 2002

ISBN10 : 2841772055 - ISBN13 : 9782841772056

Commandez sur www.amazon.fr :

40.85 € TTC (prix éditeur 43.00 € TTC)

Critique du livre par la rédaction LFE le 1^er mars 2002

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.

Commenter Signaler un problème

khayyam90 - Rédacteur

l 25/06/2014 à 20:52

Java & XSLT

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.

[Lire la suite]

Avez-vous lu ce livre ou pensez-vous le lire ?
Souhaitez-vous ajouter une critique de ce livre sur la page de la rubrique ?
Avez-vous un commentaire à faire ?

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

Détails du livre

Sommaire

Critiques (1)

Au Coeur de Java 2 JDK 5, Vol.1

Notions Fondamentales

de Cay S. Hortsmann, Gary Cornell

Traducteurs : Christiane Silhol, Nathalie Le Guillou de Penanros

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)

Édition : Campus Press - 855 pages, 7^e édition, 1^er décembre 2004

ISBN10 : 2744018333 - ISBN13 : 9782744018336

format : 19x23x5 cm, poids : 1575 gr.

Commandez sur www.amazon.fr :

38.00 € TTC (prix éditeur 40.00 € TTC)

Une introduction à Java
L'environnement de programmation de Java
Structures fondamentales de la programmation Java
Objets et classes
L'héritage
Interfaces et classes internes
Programmation graphique
Gestion des événements
Swing et les composants d'interface utilisateur
Déployer des applets et des applications
Exceptions et mise au point
Les flux et les fichiers
Programmation générique
Annexes A : Les mots clés de Java
Annexes B : Adaptation en amont du code du JDK 5.0

Critique du livre par la rédaction bigboomshakala le 1^er décembre 2005

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!

Détails du livre

Sommaire

Critiques (2)

Java Efficace

Guide de Programmation

de Joshua Bloch

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.

Édition : Vuibert - 272 pages, 1^er juin 2002

ISBN10 : 2711748057 - ISBN13 : 9782711748051

Commandez sur www.amazon.fr :

30.04 € TTC (prix éditeur 32.00 € TTC)

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 1^er 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 christopheJ le 1^er mars 2006

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.

couverture du livre JUnit - Mise en oeuvre pour automatiser les tests en Java

Détails du livre

Sommaire

Critiques (2)

1 commentaire

JUnit - Mise en oeuvre pour automatiser les tests en Java

de Benoit GANTAUME

Résumé de l'éditeur

Ce livre sur l'automatisation des tests avec JUnit s'adresse à toutes les personnes impliquées dans des projets de développement logiciel et désireuses de découvrir le potentiel de JUnit. Quelle que soit la façon dont l'équipe de développement travaille, que vous soyez débutant ou expert, manager, développeur, architecte ou chef de projet, ce livre vous permettra d'appréhender les tests automatiques, de les insérer dans une logique de fabrication de logiciels et de les mettre en uvre efficacement. Le premier chapitre est destiné à introduire rapidement JUnit de manière concrète. Cette partie intéressera surtout les développeurs utilisant JUnit pour la première fois. La seconde partie s'adressera autant aux personnes ayant des responsabilités techniques que managériales et permettra de mieux comprendre les enjeux de l'automatisation des tests ainsi que leur imbrication dans le processus de la création de logiciels. Enfin la troisième partie sera dédiée aux techniques avancées de test permettant d'utiliser les tests automatiques comme un élément de compétitivité économique. Pour tirer le meilleur profit de ce livre, il est intéressant que le lecteur dispose des connaissances de base de la programmation Objet avec le langage Java, la connaissance des Design Patterns étant un plus. à la fin de cet ouvrage, vous serez capable de concevoir et mettre en uvre une stratégie de tests automatiques et de tester votre code à différents niveaux. Les éléments disponibles en téléchargement sur le site www.editions-eni.com, contiennent les codes sources de la calculatrice et du serveur de calcul, les deux projets exemples menés tout au long du livre. Les chapitres du livre : Préambule - Kit de démarrage - Qu'est-ce que le test ? - Le test dans les méthodologies - Comment démarrer ? Mythes et réalités - L'utilisation de bouchons - Modelage de tests - Couverture de code - Développement piloté par les tests - Trousse à outils.

Édition : ENI - 288 pages, 5^e édition, 10 janvier 2011

ISBN10 : 2746060612 - ISBN13 : 9782746060616

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 37.05 € TTC) livraison gratuite !

Introduction
Préambule
Kit de démarrage rapide
aspects théoriques du test
Qu'est-ce que le test ?
Le test dans les méthodologies
Comment démarrer ? Mythes et réalités
techniques de tests
l'utilisation de bouchons
Modelage de tests
Couverture de code

Critique du livre par la rédaction X-plode le 4 août 2011

L'auteur a su concilier en 288 pages, sensibilisation aux tests, notions et méthodologie de travail avec brio.
Ainsi, les premiers chapitres nous offrent plusieurs définitions et plusieurs réflexions sur les tests logiciels et leurs places dans la vie du développement d'un logiciel.

Ensuite, l'auteur aborde le sujet des mocks et des stubs et nous comprenons la différence entre ces deux notions et leur utilité pour tester le code en définissant un cadre précis pour le test.
Et nous continuons sur le modelage des tests et les métriques qui peuvent être mis en place pour obtenir des données sur la couverture de notre code par nos tests.

Enfin nous terminons le livre avec l'explication de la méthode TDD et les outils du parfait testeur.
Grâce à ce livre, nous apprenons la nécessité des tests unitaires, comment les mettre en place et l'utilité de la méthode de développement dirigé par les tests (TDD) via le framework le plus populaire JUnit.

Tous les développeurs désireux de connaitre le pourquoi du comment des tests grâce au framework JUnit seront comblés grâce aux présentations claires et aux nombreux exemples qui y sont exposés.
Un très bon livre pour toute personne souhaitant s'initier aux tests avec JUnit.

Critique du livre par la rédaction Julien Plu le 19 juillet 2015

Je n’ai pour ma part aucune critique négative à faire sur ce livre. Il y a absolument tout ce dont on a besoin de savoir pour apprendre à tester son application Java avec JUnit. Cela va de la simple introduction sur ce que sont des tests jusqu’à l’explication de comment inclure
ces derniers dans des méthodes de développement comme SCRUM ou le cycle en V. Le plus gros avantage de ce livre est qu’il explique tout ceci en très peu de pages. Cela montre que l’auteur explique peu, mais très bien.

Il n’y a pas vraiment de partie que j’ai préférée à d’autres, le livre est captivant du début à la fin et on a même hâte de prendre un de ses programmes pour immédiatement mettre en pratique ce que l’on vient de lire.

Je recommande donc ce livre tout particulièrement aux personnes qui souhaitent apprendre comment tester leur programme et à ceux qui voudraient avoir une référence.

Commenter Signaler un problème

Djug - Expert éminent sénior

l 04/08/2011 à 14:00

Bonjour,

La rédaction de DVP a lu pour vous l'ouvrage suivant:

JUnit - Mise en œuvre pour automatiser les tests en Java, de Benoit Gantaume, paru aux Éditions Eni.

Ce livre sur l'automatisation des tests avec JUnit s'adresse à toutes les personnes impliquées dans des projets de développement logiciel et désireuses de découvrir le potentiel de JUnit. Quelle que soit la façon dont l'équipe de développement travaille, que vous soyez débutant ou expert, manager, développeur, architecte ou chef de projet, ce livre vous permettra d'appréhender les tests automatiques, de les insérer dans une logique de fabrication de logiciels et de les mettre en œuvre efficacement. Le premier chapitre est destiné à introduire rapidement JUnit de manière concrète. Cette partie intéressera surtout les développeurs utilisant JUnit pour la première fois. La seconde partie s'adressera autant aux personnes ayant des responsabilités techniques que managériales et permettra de mieux comprendre les enjeux de l'automatisation des tests ainsi que leur imbrication dans le processus de la création de logiciels. Enfin la troisième partie sera dédiée aux techniques avancées de test permettant d'utiliser les tests automatiques comme un élément de compétitivité économique. Pour tirer le meilleur profit de ce livre, il est intéressant que le lecteur dispose des connaissances de base de la programmation Objet avec le langage Java, la connaissance des Design Patterns étant un plus. à la fin de cet ouvrage, vous serez capable de concevoir et mettre en œuvre une stratégie de tests automatiques et de tester votre code à différents niveaux. Les éléments disponibles en téléchargement sur le site www.editions-eni.com, contiennent les codes sources de la calculatrice et du serveur de calcul, les deux projets exemples menés tout au long du livre. Les chapitres du livre : Préambule - Kit de démarrage - Qu'est-ce que le test ? - Le test dans les méthodologies - Comment démarrer ? Mythes et réalités - L'utilisation de bouchons - Modelage de tests - Couverture de code - Développement piloté par les tests - Trousse à outils.

L'avez-vous lu? Comptez-vous le lire bientôt?

Quel est votre avis?

Exprimez-vous!! Votre avis nous intéresse...

thierryler - Rédacteur

l 17/01/2012 à 11:47

J'aimerais bien le lire puis re-boucler sur mes articles concernant "3T", surtout à cause des chapitres sur les TDD.

Quelqu'un peut me le prêter ?

3T : les Tests en Trois Temps
http://thierry-leriche-dessirier.dev...va/methode-3t/

Les Tests en Trois Temps (3T) en pratique
http://thierry-leriche-dessirier.dev...t-en-pratique/

Mais aussi un article plus perso sur JUnit justement
http://thierry.leriche-dessirier.com...ntro-junit.htm