Développement Desktop Java

14 livres et 21 critiques, dernière mise à jour le 8 février 2017 , note moyenne : 4.5

  1. Java 6 : Entraînez-vous et maîtrisez Java par la pratique - Collections : Les TP Informatiques
  2. Java - La maîtrise - Java 5 et 6
  3. Filthy Rich Clients
  4. Java Persistence et Hibernate
  5. Programmer en Java
  6. Rich Client Programming - Plugging into the Netbeans Platform
  7. Swing la synthèse - Développement des interfaces graphiques en Java
  8. Les Cahiers du programmeur Swing
  9. Les cahiers du programmeur - Java 1.4 et 5.0
  10. Aide-Mémoire de Java
  11. Hibernate 3.0 - Gestion optimale de la persistance dans les applications Java/J2EE
  12. Au coeur de Java 2, Volume 2, Fonctions avancées JDK 5.0
  13. Au Coeur de Java 2 JDK 5, Vol.1 - Notions Fondamentales
  14. Programmation Orienté Aspect pour Java / J2EE
couverture du livre Java 6 : Entraînez-vous et maîtrisez Java par la pratique

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

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

Collections : Les TP Informatiques

de

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

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

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


couverture du livre Java - La maîtrise

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

Java - La maîtrise

Java 5 et 6

de

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 , 2eé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 Filthy Rich Clients

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

Filthy Rich Clients

de

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 , 1re é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 1er mai 2008
Il s'agit là d'un livre que j'ai longtemps attendu ; en fait, je l'attendais même sans le savoir depuis que j'ai commencé à programmer des applications clientes utilisant Swing.
En effet, l'intégration de Java2D lors de la sortie de Java 2 (1.2) dès 1998 a permis d'étendre considérablement les capacités de la plateforme Java en ce qui concerne les effets et traitements d'images et ce de manière totalement portable d'un système à l'autre. De même, Swing, sorti à la même époque, permettait enfin de faire des interfaces graphiques en s'affranchissant des limites de l'AWT, mieux Swing reposait sur Java2D. Cependant, s'il peut-être aisé de trouver des informations, cours ou livres sur Java2D et plus encore sur Swing, il est resté assez difficile de trouver des exemples d'intégration avancée entre ces deux bibliothèques hormis les démos fournies par Sun avec le JDK. Et même celles-ci ne montrent pas comment Java2D peut, littéralement, transformer et transcender Swing.

Tous les programmeurs qui ont eut à créer leur propre composant Swing ou à modifier l'affichage d'un composant existant ont du à un moment ou à un autre écrire un peu de Java2D dans leur code d'affichage ; cependant nous sommes tous généralement restés confinés à des appels des primitives pour tracer des lignes ou encore remplir de simples polygones avec des couleurs unies, personne ne sachant vraiment trop comment combiner les deux bouts ensemble. Ainsi, tandis que les nouvelles versions de Windows et MacOS se succédaient les unes aux autres apportant à chaque fois leur lot de nouveaux effets graphiques cools, les interfaces graphiques Java restaient portables, certes, mais étaient également globalement toujours aussi grises et ennuyantes.
Ne craignez rien ! Romain Guy (Gfx) et Chet Haase, les deux superstars des très populaires présentations orientées Desktop des conférences JavaOne de ces dernières années viennent ENFIN à notre rescousse ! Si vous avez déjà été explorer les tonnes d'exemples et d'astuces que Gfx a proposés sur ce site et notre forum Java ou sur son blog ou ceux que Chet a postés sur le sien, une bonne partie est condensée dans ce livre (en anglais). Avec un langage simple, clair et non dénué d'humour, les deux auteurs nous présentent tour à tour tout ce qui est nécessaire pour faire que votre application Swing sorte du lot et accroche votre utilisateur ; qu'elle puisse s'intégrer aux designs plus riches en couleurs et autres effets graphiques ainsi qu'aux nouveaux standards en matière d'ergonomie ou de présentation des OS d'aujourd'hui.

Dans la première partie de l'ouvrage, nous retrouveront, outre les conseils habituels de "bonne conduite" en ce qui concerne la programmation Swing, des astuces pour bénéficier d'optimisations des performances du rendu. La seconde partie aborde des concepts plus avancés tels que les Composites (ce qui se passe lors de la superposition de 2 rendus), les gradients de couleur, les filtres permettant de faire des traitements sur des images mais également certains concepts Swing nécessaires à l'intégration de ces effets dans une IHM tels que le Glass Pane ou encore le Repaint Manager. La troisième partie touchera quant à elle à l'animation en présentant les concepts de base de ce qui fait une animation puis en abordant le Timing Framework auquel participe Chet Haase. La dernière partie du livre aborde enfin les effets qu'il est possible de créer en combinant tout ce qui a été vu au cours des chapitres précédents ainsi que les différentes étapes de la conception et de la création d'un client "obscènement" riche (traduction libre de Filthy Rich Client).
Attention toutefois, ce livre est uniquement disponible en anglais. Il supposera que vous connaissez déjà les fondamentaux de Swing et que vous avez également quelques connaissances de la manière de dessiner, ce serait-ce qu'une ligne droite ; ce n'est en aucun cas un ouvrage d'introduction à Java2D. De plus, on pourra parfois regretter que certaines images illustrant les chapitres soient un peu petites et que l'impression en niveaux de gris ne permette pas toujours de se rendre compte du résultat final de certains des effets, notamment ceux de surbrillance.

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


couverture du livre Java Persistence et Hibernate

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

Java Persistence et Hibernate

de
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 , 1re é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 1er octobre 2008
Cet ouvrage est certainement le meilleur de ceux qu'il m'ait été donné de lire sur le sujet.
Agréable à lire, illustré de nombreuses captures d'écran qui renforcent les explications données, c'est un livre trés détaillé qui couvre l'ensemble des possibilités d'Hibernate.
Pour autant, même si le public visé est clairement celui des développeurs, il couvre bien plus que le simple aspect programmation.
Tout au long du livre l'auteur s'attache à nous proposer une mise en oeuvre qui va bien au delà du simple mapping mécanique entre une base de données et le modèle métier.
Pour certains cas notamemnt, il étudie plusieurs possibilités de mapping, ou de modélisation, et montre les conséquences sur les autres couches. Les stratégies de chargement les plus adaptées en fonction des différents contextes qu'il est possible de rencontrer sont également abordées dans le détail. Les concepteurs et les architectes devraient apprécier et en tirer sans aucun doute des renseignements utiles.
Mon seul regret concerne la partie technique : l'auteur a choisi de n'utiliser que les annotations. Personnellement je trouve que c'est dommage. J'aurai bien aimé trouver les exemples en XML.
Critique du livre par la rédaction Baptiste Wicht le 1er mars 2008
Comme son titre l'indique, cet ouvrage présente Java Persistence API (JPA) avec Hibernate comme fournisseur de persistance. Ce livre ne va pas se contenter de couvrir la partie JPA, il va également explorer des fonctionnalités spécifiques à Hibernate qui permettront d'aller plus loin que les spécifications JPA.
L'auteur commence par nous présenter la problématique de la persistance et l'évolution des librairies facilitant cette tâche au fil des ans jusqu'à l'avènement de JPA. Il nous montre également les avantages d'un outil de mapping objet-relationnel. Il présente ensuite ce qu'est JPA et c'est qu'est Hibernate.

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

Les deux chapitres suivants traitent quand à eux des méthodes de récupération des entités ainsi que de la façon de les gérer, c'est-à-dire les modifier, les supprimer et les créer. Ces 2 chapitres sont très complets et plus simples à suivre que les précédents. La partie récupération traite bien de toutes les manières de récupérer des objets (EJB-QL, SQL natif, Criteria). On y parle également des transactions et de la gestion des accès concourants.
Vient ensuite un chapitre sur la gestion de l'EntityManager. C'est-à-dire comment le créer ou récupérer et comment gérer son cycle de vie tout au long de l'exécution de l'application. Il traite des différentes stratégies de gestion de l'EM ainsi que du traitement par lot ou de l'utilisation dans un batch. On y traite également de l'utilisation des EJB3 pour gérer l'EntityManager. Comme je n'ai pas pu installer JBoss intégré, je n'ai pu tester cette partie. Avec le chapitre 8, on entre dans le cour d'Hibernate qui permet de faire plus de choses que la spécification JPA. On verra donc les formules, les procédures stockées, les types personnalisés, les clés composées et encore d'autres notions avancées de mapping avancés. Ces 2 chapitres traitent de notions assez complexes, mais ils les traitent bien, et on s'y retrouve facilement.

L'avant dernier chapitre parle de la suite Hibernate Tools. Il traite surtout du plugin pour Eclipse permettant de faciliter le développement JPA/Hibernate et de SchemaExport, l'utilitaire permettant de générer le schéma de la base de données. Le dernier chapitre, quant à lui, traite des autres projets autour d'Hibernate. On va notamment s'intéresser aux pools de connexion et au gestionnaire de cache de second niveau ainsi qu'à la validation des entités.
En conclusion, j'ai trouvé certaines notions de ce livre complexes à mettre en oeuvre et le plan du livre laisse parfois à désirer. L'auteur va parfois un peu trop vite et le lecteur se retrouve emmêlé entre plusieurs notions parfois très différentes. Néanmoins, ce livre présente très bien les différentes notions de JPA ainsi que les aspects avancés qui nécessitent Hibernate. Mais je ne le conseillerais pas aux débutants.


couverture du livre Programmer en Java

Note 4 drapeau CD-Rom
Détails du livre
Sommaire
Critiques (3)
 
 

Programmer en Java

de

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 , 5eé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 1er août 2008
Ce livre est vraiment instructif car il explique vraiment bien ce que peut être le langage Java. Le débutant y trouvera un très bon cours pour le Java, la POO, les graphiques avec SWING, et même pour le développement web avec JSP et d'autres outils / techniques / … .
Ce livre sera aussi une très bonne référence pour les initiés à Java car il contient une annexe très bien fournie et des exemples de code tout faits qui peuvent beaucoup servir.
Une chose très constructive aussi : beaucoup de remarques sur certains points communs avec le langage C++, pour que l'on puisse bien voir les différences ou similitudes avec ce langage. J'ai également beaucoup apprécié le chapitre sur la programmation générique qui est vraiment bien construit. Sinon, mon seul regret est qu'il manque un chapitre sur JDBC qui est très utile et aurait pu introduire une partie BDD.
Conclusion : Ce livre est pour moi LA référence en français du langage Java pour ceux qui voudraient l'apprendre.
C'est également un très bon aide mémoire pour les initiés car il donne tout ce qu'il faut pour être totalement autonome afin de développer ses propres applications et appréhender en toute sérénité la volumineuse documentation Java.
Critique du livre par la rédaction Faith's Fall le 1er juillet 2008
Étant développeur C / C++ de base et désirant migrer vers le langage Java, je me suis intéressé à l'ouvrage « Programmer en Java » de Jean-Claude Delannoy dans sa 5e Édition. La première approche de ce livre est plutôt bonne, il regroupe la plupart des bases du langage comme les class, les threads, les boucles et même l'interface graphique de type Swing sur plusieurs chapitres. On peut noter également la présence d'un chapitre dédié à Java EE qui donne des idées sur la programmation orientée Web avec les pages dynamiques JSP ou les servlets.
Avec plus de détail, ce livre montre une approche très pratique et scolaire sur les divers points du langage Java avec des exemples de code expliqués. J'ai également apprécié les diverses comparaisons entre le Java et le langage C++ qui permette de voir comment le Java est assez proche du C++ et permet également aux développeurs C++ de ne pas être dépaysé par le Java.
Mon avis sur cet ouvrage est très positif, cependant, il est vraiment réservé pour apprendre les bases et ce limite uniquement aux aspects les plus importants du langage Java, ce qui signifie que si vous cherchez des informations sur des techniques de programmation avancés, ce livre ne sera pas fait pour vous. Par contre pour apprendre ou migrer sur le Java, ce livre est un réel plus à avoir à côté de soi.
Critique du livre par la rédaction Eric REBOISSON le 1er février 2008
Un ouvrage très instructif pour tous ceux qui voudraient se lancer dans Java. Ce livre traite de tous les points essentiels du langage : les origines de Java, les types, mots clés, POO, threads, IHM, programmation Web, etc. Claude Delannoy, l'auteur de "Programmer en Java" publie là une 5ème édition de ce qu'on peut appeler maintenant un best-seller. Je vous livre maintenant mes impressions :

Les plus :
  • Un sommaire très détaillé qui pour moi est un bon indicateur sur le contenu
  • La rédaction et le style simple facilitant la bonne compréhension
  • Un contenu de qualité et fiable et les parallèles avec C/C++
  • Plus de 250 000 ouvrages vendus, ce n'est pas un hasard


Les moins :
  • La mise en page trop sobre (mais les goûts et les couleurs, vous connaissez la suite…)
  • Certains chapitres ne sont vraiment que des petites introductions (mais on comprendra que l'ouvrage n'a pas non plus vocation à l'exhaustivité)


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

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


couverture du livre Rich Client Programming

Note 5 drapeau CD-Rom
Détails du livre
Sommaire
Critiques (1)
 
 

Rich Client Programming

Plugging into the Netbeans Platform

de

Résumé de l'éditeur

The NetBeans platform, is the core of the NetBeans integrated development environment (IDE) and an application framework for developing rich desktop applications (ie client applications). Using a NetBeans IDE simplifies the creation and maintenance of software features. NetBeans is free and its code is freely available and what makes NetBeans-based applications special is that they are truly cross-platform which enables developers to focus on the essentials that are specific to their apps and build them more rapidly. This book focuses on using the NetBeans Platform as a framework for creating rich client applications that can be written once and then run on ANY operating system. Much information about the NetBeans Platform is already available, but there is no single up-to-date source that demonstrates how to make use of the whole platform. This book, which is the most frequent request from NetBeans users, pulls together years worth of accumulated wisdom, best practices, and practical information…all in one place.

The open-source NetBeans Platform is an extraordinarily powerful framework for building "write once, run anywhere" rich client applications. Now, for the first time since the release of NetBeans IDE 5.0, there's a comprehensive guide to rich client development on the NetBeans Platform. Written for Java developers and architects who have discovered that basic Swing components are not enough for them, this book will help you get started with NetBeans module development, master NetBeans' key APIs, and learn proven techniques for building reliable desktop software. Each chapter is filled with practical, step-by-step instructions for creating complete rich client applications on top of the NetBeans Platform and plugins for NetBeans IDE.

Rich Client Programming's wide-ranging content covers
  • Why modular development makes sense for small, medium, and large applications
  • Using NetBeans to accelerate development and improve efficiency
  • Leveraging NetBeans productivity features, from the Component Palette to Code Completion
  • Leveraging NetBeans' modular architecture in your own applications
  • Implementing loosely coupled communication to improve code maintainability and robustness
  • Managing user- and system-configuration data
  • Building reloadable components with solid threading models
  • Constructing sophisticated multiwindow applications and presenting rich data structures to users
  • Adding user-configurable options
  • Integrating Web services with NetBeans desktop applications
  • Automating module updates and providing user help

Édition : Prentice Hall PTR - 640 pages , 1re édition, 1er mai 2007

ISBN10 : 0132354802 - ISBN13 : 9780132354806

18 x 3 x 23 cm, broché

Commandez sur www.amazon.fr :

37.42 € TTC (prix éditeur 49.99 € TTC)
  • Foreword by Jonathan Schwartz
  • Foreword by Jan Chalupa
  • Preface
  • About the Authors and Contributors
  • Acknowledgments
  • Chapter 1: Getting Started with the NetBeans Platform
  • Chapter 2: The Benefits of Modular Programming
  • Chapter 3: Modular Architecture
  • Chapter 4: Loosely Coupled Communication
  • Chapter 5: Lookup
  • Chapter 6: Filesystems
  • Chapter 7: Threading, Listener Patterns, and MIME Lookup
  • Chapter 8: The Window System
  • Chapter 9: Nodes, Explorer Views, Actions, and Presenters
  • Chapter 10: DataObjects and DataLoaders
  • Chapter 11: Graphical User Interfaces
  • Chapter 12: Multiview Editors
  • Chapter 13: Syntax Highlighting
  • Chapter 14: Code Completion
  • Chapter 15: Component Palettes
  • Chapter 16: Hyperlinks
  • Chapter 17: Annotations
  • Chapter 18: Options Windows
  • Chapter 19: Web Frameworks
  • Chapter 20: Web Services
  • Chapter 21: JavaHelp Documentation
  • Chapter 22 Update Centers
  • Chapter 23: Use Case 1: NetBeans Module Development
  • Chapter 24: Use Case 2: Rich Unger on Application Development
  • Chapter A: Advanced Module System Techniques
  • Chapter B: Common Idioms and Code Patterns in NetBeans
  • Chapter C: Performance
  • Index
Critique du livre par la rédaction n!co le 1er octobre 2007
Introduction
Poussé par la notoriété grandissante des dernières versions 5.x et de la très attendue version 6, Rich Client Platform : Plugging into the Netbeans Platform est le deuxième livre présentant Netbeans comme plateforme de client riche. Apportant une nouvelle expérience du développement d'application RCP, le site Netbeans.org restait jusqu'à aujourd'hui la principale source d'information pour apprendre à profiter de la plateforme : API très riche, documents techniques, nombreux tutoriaux offerts par la communauté, sans oublier la mailing-list très active. Cependant, il manquait une introduction aux concepts de base de l'architecture et c'est le défi que les auteurs ont su relever avec qualité au travers des 22 chapitres de ce livre.

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

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

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

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

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

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


couverture du livre Swing la synthèse

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

Swing la synthèse

Développement des interfaces graphiques en Java

de
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 , 2eédition, 1er 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 1er août 2007
Ce livre est destiné à toutes les personnes utilisant Swing. Il va vous expliquer les principaux concepts de Swing. Vous allez les apprendre via une série d'exemples ludiques. A la fin de chaque chapitre, vous allez pouvoir appliquer les différentes notions à une petite application.

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

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

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


couverture du livre Les Cahiers du programmeur Swing

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

Les Cahiers du programmeur Swing

de

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 , 1re é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 1er mai 2008
Je viens de terminer la lecture du livre SWING dans la collection "Les cahiers du programmeur", un ouvrage sur l' APISwing qui permet de concevoir des interfaces graphiques avec le langage de programmation Java. Place maintenant à une petite présentation du contenu et à mes impressions sur cette publication dont le fil rouge est une application pour la modélisation 3D d'un logement.
Un bon point pour commencer, le sommaire complet et les titres de chapitres détaillés permettent d' accéder rapidement à l'information. Ensuite pour chaque chapitre, les grands thèmes couverts sont annoncés, on sait donc d'avance ce que l'on va découvrir, c'est structuré et ça suscite l'envie de lire. Pour la matière, toutes les phases de création du projet Sweet Home 3D sont présentées : on débute par l'idée et les phases inhérentes au démarrage d'un projet (cahier des charges, conception…), puis l'installation des outils de développement, la programmation proprement dite et les cycles de tests associés pour finir avec le déploiement de l'applicatif. Le comparatif avec d'autres API graphiques (AWT, SWT, JFace) est le bienvenu pour expliquer les choix qui peuvent conduire à l'utilisation ou non d'un des outils. On pourra lire également sur chaque page des petits encarts pour agrémenter les explications du livre (B.A.-BA, A retenir, Astuces, Pour aller plus loin, Attention…)
Ce livre ne traite donc pas uniquement de Swing et on puisera énormément d'informations sur (entre autres) :
  • Les fondations d'un projet informatique (cahier des charges, référentiel des sources)
  • Les nouveautés de Java 5 (annotations, généricité,)
  • Les designs patterns (MVC, Singleton, Décorateur, Proxy…)
  • Le déploiement avec Java Veb Start
  • ANT


Le livre expose des extraits de code commentés sur l'implémentation de l'application, des scénarios fonctionnels, des diagrammes de classes UML et des copies d'écrans pour illustrer les différentes étapes. J'ai cherché ce qui pouvait manquer dans le contenu mais tout est là.
C'était une découverte de la collection "Les cahiers du programmeur", et je dois dire que j'ai été enchanté tant par la qualité du contenu technique que par la pédagogie adoptée pour tenir le lecteur en haleine, mais aussi par la mise en page très riche et lisible à la fois. Je donne donc la note maximale et je ferai simple pour la conclusion : tous les livres devraient être comme ça, vous pouvez donc l'acheter les yeux fermés !
Critique du livre par la rédaction vbrabant le 1er avril 2007
Tout d'abord, je dois vous signaler, avant que vous n'alliez plus loin dans la critique, que j'ai été relecteur technique de ce livre.
Mon avis aurait donc pu être faussé.
C'est la raison pour laquelle j'ai attendu que quelqu'un d'autre fasse une critique de ce livre, avant de publier la mienne :-).
Ce livre est le seul que j'ai lu jusqu'à ce jour qui explique aussi clairement comment développer une application Swing en utilisant le modèle MVC tout en faisant bien la distinction entre le modèle MVC de votre application et le modèle MVC (ou plutôt M-VC) des composants Swing.
Attention que ce livre n'est pas là pour vous faire découvrir tous les composants Swing qui sont à votre disposition, mais plutôt pour vous faire découvrir comment bien découper/structurer votre application Swing.

Malgré cela, on y apprend l'utilisation des JTable, JTree, …, à afficher le même modèle sous des vues différentes (on visualise la même pièce en 3D, en 2D et sous forme de table), implémenter l'Undo/Redo, le Drag and Drop, l'internationalisation d'une application, …
On y apprend de plus comment découper un projet, comment les personnes ont raisonné pour finalement arriver au design de cette application.
Tout au long de l'ouvrage, l'auteur compare également Swing et AWT avec SWT et JFace, nous fait découvrir des modules Eclipse intéressants.
L'étude de cas que l'auteur a choisi pour ce livre est certainement pour beaucoup dans la qualité de l'ouvrage.
Dès le premier chapitre, on a envie d'en savoir plus, de connaitre comment l'auteur s'y est pris pour réaliser son étude de cas.
Sachez également que l'auteur a aussi mis son étude de cas à la disposition de tous, sous licence open source, et qu'elle est totalement opérationelle.
En conclusion, je ne peux que conseiller ce livre à tous ceux qui programment ou désirent programmer en Swing.
Ce livre me semble assez unique dans sa façon d'aborder Swing.
Pourquoi je ne donne que 4.5/5 à ce livre ? C'est la question que l'auteur m'a posée.
Je lui ai répondu que je mettrais 5/5 au livre qui m'expliquerait Swing à la façon "Head First/Tête première". Et le système des étoiles ne me permet pas de lui donner 4.9/5.
Critique du livre par la rédaction Baptiste Wicht le 1er février 2007
Ce livre est tout simplement génial. C'est la première fois que je lis un livre d'informatique aussi prenant, on a à chaque fois envie d'aller plus loin et d'avancer dans les chapitres.
Ceci est surtout du à la structure qu'a utilisée l'auteur pour écrire ce livre. Il n'en a pas fait un simple catalogue Swing montrant toutes les méthodes et classes de Swing et leur utilisation; il crée plutôt un projet qu'on va faire avancer tout au long du livre en lui ajoutant de nouvelles fonctionnalités. En plus de toutes les informations techniques que l'on obtient durant la lecture des différents chapitres, l'auteur nous fait aussi part de son expérience dans le travail en groupe et le développement de projet. En effet, on va voir comment découper le projet en plusieurs scénarios bien distincts, comment appliquer la méthode XP, comme utiliser CVS pour archiver et partager les fichiers du projet, etc. L'auteur va aussi traiter de la différence SWT/SWING/AWT.

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

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


couverture du livre Les cahiers du programmeur

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

Les cahiers du programmeur

Java 1.4 et 5.0

de
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 , 3eédition, 1er 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 1er 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

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

Aide-Mémoire de Java

de

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 , 1er 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 1er mai 2007
Un livre indispensable pour tout débutant en Java et souvent nécessaire pour développeur confirmé devant aborder des sujets dont il n'a pas l'habitude.
Ce petit livre couvre succinctement l'essentiel de la programmation Java, avec à la fois les explications sur le fonctionnement fondamental de chaque fonctionnalité et des exemples pertinents.
Bien sûr, si vous voulez aborder un aspect bien spécifique, ce livre ne vous sera pas suffisant, mais il offrira sans doute déjà assez d'informations pour bien débuter. De toutes façons, jamais un livre généraliste sur Java ne donnera jamais assez d'éléments sur un point précis des très vastes bibliothèques disponibles.
Au final : un must have.
Critique du livre par la rédaction vbrabant le 1er 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 Hibernate 3.0

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

Hibernate 3.0

Gestion optimale de la persistance dans les applications Java/J2EE

de
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 , 1re édition, 1er 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

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

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

de
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 , 1er 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 1er 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 Au Coeur de Java 2 JDK 5, Vol.1

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

Au Coeur de Java 2 JDK 5, Vol.1

Notions Fondamentales

de
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 , 7eédition, 1er 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 1er 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!


couverture du livre Programmation Orienté Aspect pour Java / J2EE

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

Programmation Orienté Aspect pour Java / J2EE

de

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

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

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


Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -