Developpez.com - Java
X

Choisissez d'abord la catégorieensuite la rubrique :

logo

Critiques de livre par Baptiste Wicht - Les livres Java

Dernière mise à jour : 01/12/2009


precedent    sommaire    suivant



couverture du livre 'Modular Java'

Note 4.0

Modular Java

Creating Flexible Applications With OSGi and Spring

de Craig Walls
Public visé : Intermédiaires,Avancés

Résumé de l'éditeur

Modular Java is a pragmatic guide to developing modular applications using OSGi, the framework for dynamic modularity in Java, and Spring Dynamic Modules, an OSGi extension to the Spring Framework. You'll start with the basics but quickly ramp up, creating loosely coupled modules that publish and consume services, and you'll see how to compose them into larger applications. Along the way, you'll apply what you learn as you build a complete web application that is made up of several OSGi modules, using Spring-DM to wire those modules together.

Modular Java is filled with tips and tricks that will make you a more proficient OSGi and Spring-DM developer. Equipped with the know-how gained from this book, you'll be able to develop applications that are more robust and agile.


Critique du livre par la rédaction (Baptiste Wicht) (Octobre 2009)
Ce livre est une très bonne introduction à la création d'applications modulaires en Java. Ce livre présente tous les principaux concepts de la technologie OSGi, de Spring Dynamic Modules ainsi que des outils permettant de faciliter le développement d'applications OSGi.

Le premier chapitre présente la problématique de modularité et présente comment OSGi tente de résoudre ce problème. Les concepts principaux de la technologie y sont également décrits.

Le second chapitre présente différents conteneurs OSGi. Dans ce chapitre, on crée un premier programme Hello World en utilisant OSGi. On améliore ensuite ce programme en utilisant la publication et la consommation de services OSGI.

Le troisième chapitre introduit l'application "Dude, Where's my Jar ?" qui nous suivra tout au long du livre. Cette application est une application web permettant d'effectuer des recherches de fichier Jar dans des repository Maven. En plus de cela, le chapitre présente la série d'outils Pax qui permettent de faciliter le développement d'applications OSGi.

Le chapitre suivant voit la création du premier bundle de notre application grâce auquel on adresse les premières problématiques du développement OSGi, à savoir l'utilisation de dépendances non-OSGi.

Le chapitre cinq développe le bundle suivant. Ce chapitre se focalise sur la publication et la consommation de services OSGi. En plus de cela, on apprend également à tester une application et des services OSGi.

Il est maintenant temps de passer à Spring Dynamic Modules avec le chapitre suivant. On y voit comment faciliter la consommation et la déclaration de services sous forme de beans Spring.

Avec le chapitre 7, on commence à développer le bundle web. Pour cela, on va inclure Tomcat ou Jetty sous forme de bundles OSGi. On va ensuite voir les différences qu'il y a entre déclarer un bundle simple (JAR) et un bundle web (WAR).

Le chapitre suivant traite de l'extension de bundle OSGI au moyen de fragment. On va notamment voir comment découpler la partie JSP et design de la partie applicative.

L'avant dernier chapitre permet de voir comment déployer une application OSGi en production. Il présente l'ajout d'une console web à l'application pour administer directement les modules.

Le dernier chapitre présente les services de journalisation et d'administration qui font partie de la norme OSGi.

En conclusion, ce livre vous permettra de commencer à développer des applications utilisant OSGi.
C'est très agréable de suivre le développement d'une application tout au long du livre, tout en découvrant au fur et à mesure ce qu'OSGi permet de faire pour faciliter le développement d'une application.
Néanmoins, je trouve qu'on aurait pu éviter de se baser tant que ça sur les outils Pax. On perd presque de vue OSGi à partir de l'utilisation de Pax. Il se peut qu'on ne puisse utiliser Pax dans une application et dans ce cas, on pourrait ne pas savoir tout faire.
Certes, il est utile de voir le déroulement Maven les premières fois, mais ce n'est pas utile de les afficher systématiquement. Certaines pages ne contiennent presque que des traces Maven qui ne correspondent ni à des erreurs, ni à des informations intéressantes. Mais malgré cela, la lecture du livre reste très fluide et intéressante.

Sommaire

  • Introduction
  • Getting Started
  • Dude, Where's My Jar ?
  • Working with Bundles
  • OSGi Services
  • Spring and OSGi
  • Creating Web Bundles
  • Extending Bundles
  • OSGi in Production
  • Configuring the Application
  • Manifest Headers
  • Spring-DM Configuration
  • The OSGi Blueprint Service
  • Resources
  • Bibliography
  • Index

260 pages, 1ère édition, juin 2009 Editions O'Reilly, ISBN10 : 1934356409, ISBN13 : 978-1934356401, Broché
Commandez sur http://oreilly.com : 34.95  $ - Livraison Gratuite !

Commandez sur www.amazon.fr :
23.59 EUR TTC seulement (au lieu de 24.84 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Spring par l'exemple'

Note 4.5

Spring par l'exemple

de Gary Mak
Public visé : Débutants,Intermédiaires

Résumé de l'éditeur

Spring représente le framework applicatif Java EE le plus simple et le plus puissant que j'aie jamais utilisé. Depuis l'inversion de contrôle et la programmation orientée aspect à la persistance, les transactions, le design pattern MVC, les tests et autres, ce livre explique comment tirer profit de Spring au travers d'exemples de code détaillés. Ces exemples vont du scan de composants dans le chemin d'accès aux classes au test unitaire des contrôleurs Spring MVC. Spring propose des solutions simples à des problèmes difficiles. Cette simplicité a été également mon premier objectif dans la conception de cet ouvrage. J'ai souhaité trouver un équilibre entre l'étendue des sujets traités, le niveau de détail, la rapidité d'apprentissage et les connaissances requises. Chaque chapitre explore un sujet important au travers d'un exemple réel complet. Lors de la première lecture d'un chapitre, je vous recommande de suivre l'exemple de manière séquentielle. Ensuite, vous pouvez vous en servir comme référence en examinant la liste des problèmes-solutions. Si vous cherchez à résoudre un problème précis, vous pouvez aller directement aux solutions dont vous avez besoin en consultant la table des matières ou l'index.


Critique du livre par la rédaction (Baptiste Wicht) (Juillet 2009)
Ce livre est une excellente introduction à Spring. En effet, il va explorer les différents concepts de Spring en allant chaque fois un peu plus loin. Après avoir lu ce livre, on maitrise les principales fonctionalités du framewok Spring. Chaque chapitre du livre traite d'un concept spécifique de Spring. Chacun des chapitres est découpé en sous-chapitres se basant sur une série de problèmes/solutions, ce qui se révèle très pratique pour retrouver des informations par la suite.

Le premier chapitre traite de l'inversion de contrôle en général. Les différents types d'IoC y sont décrits et mis en oeuvre à l'aide de la création d'un petit exemple de container IoC développé au long du chapitre.

Le deuxième chapitre présente le framework Spring et son impressionnant portfolio. Vous y apprendrez à installer le framework et ses dépendances ainsi que Spring IDE.

Avec les deux chapitres suivants, on explore les fonctionnalités d'inversion de contrôle de Spring. Après ce chapitre, vous saurez tout ce qu'il faut savoir sur l'utilisation de Spring pour injecter vos dépendances dans vos objets. L'injection de beans, de collections ou de constantes n'auront plus de secret pour vous. Des fonctionnalités plus élaborées, telles que les beans et méthodes de fabrique, les postprocesseurs, l'internationalisation ou les éditeurs de propriété, sont également explorées.

Avec les deux prochains chapitres, vous apprendrez à modulariser les préoccupations transversales en utilisation la programmation orientée aspect. Ces chapitres commencent en utilisant les proxies dynamiques de Java pour coder ces préoccupations transversales, ensuite de quoi, il nous apprend à utiliser Spring AOP classique (Spring 1.x) et enfin, on apprend à utiliser Spring AOP (Spring 2.x). Le support d'AspectJ est également traité en profondeur, du tissage au chargement en passant par la configuration d'aspects AspectJ en tant que beans Spring.

Le chapitre 7 explore la prise en charge de JDBC (appelée Spring JDBC). On y apprendra à utiliser des templates JDBC pour faciliter le développement d'applications basées sur JDBC. On y verra également comment profiter des generics et des varargs de Java 5.0 pour JDBC.

On passe ensuite à la gestion des transactions avec Spring. Les différentes méthodes pour implémenter les transactions avec Spring, API du gestionnaire de transactions, template de transaction, Spring AOP, greffons transactionnels ou encore annotation @Transactional, y sont traités en détail. On verra également comment configurer finement les différentes transactions, via leurs attributs de propagation, isolation, temporisation ou encore annulation.

Le chapitre suivant traite de la prise en charge de l'ORM dans Spring. On y voit comment configurer un framework ORM dans Spring et on développe également un exemple complet avec JPA et Hibernate.

L'antépénultième chapitre traite du framework Spring MVC qui permet de développer facilement des applications web sur la base du design pattern MVC. Les différents concepts de Spring MVC y sont traitées et bien que ce ne soit pas exhaustif, après la lecture de ce chapitre, vous serez capable de développer une première application web basique avec Spring MVC. On enchaîne directement avec le chapitre suivant qui traite de l'intégration avec d'autres frameworks Web tels que Struts, JSF ou DWR.

Le dernier chapitre traite de l'intégration des tests unitaires. Ce chapitre explique comment simplifier le test d'une application basé sur le Spring Framework avec JUnit ou TestNG. On y apprendra à créer des tests unitaires ainsi que des tests d'intégration.

En conclusion, ce livre vous permettra de commencer à développer des applications basées sur Spring et de découvrir la puissance de ce framework. La seule critique que je peux faire par rapport à ce livre est la longueur des chapitres Spring MVC et frameworks web. Pour moi qui suis plutôt orientés applications Desktop, j'aurais préféré aller plus loin dans certains chapitres ou explorer d'autres fonctionnalités de Spring telles que la validation, le scheduling/pooling de threads ou le support de langages dynamiques dans la configuration des beans.

Sommaire

  • A propos de l'auteur
  • Introduction
  • Inversion de contrôle et conteneur
  • Introduction au framework Spring
  • Configuration des beans
  • Fonction élaborées du conteneur Spring IoC
  • Proxy dynamique et Spring AOP classique
  • Spring 2.x AOP et prise en charge d'AspectJ
  • Prise en charge de JDBC
  • Gestion des transactions
  • Prise en charge de l'ORM
  • Framework Spring MVC
  • Intégration avec d'autres frameworks web
  • Prise en charge des tests unitaires
  • Index

510 pages, 1ère édition, mai 2009 Editions Pearson Education, ISBN10 : 2744023396, ISBN13 : 978-2744023392, Broché
Commandez sur www.amazon.fr :
39.90 EUR TTC seulement (au lieu de 42 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Hardcore Java'

Note 4.0

Hardcore Java

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

Résumé de l'éditeur

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

  • Use of the final keyword to optimize and protect your Java classes.
  • Complete and thorough coverage of all types of nested classes, including how to optimize anonymous and inner classes.
  • Detailed discussion of immutable objects, including unique tips on when to use them (and when not to).
  • Elimination of bugs through exception-handling management.
  • In-depth studies of constants, including their impact on the Java memory model.
  • The most thorough discussion of reflection in print, moving far beyond other books' "Hello World" coverage.
  • Construction and use of dynamic proxies, in both Java Standard and Enterprise editions.
  • Expansive coverage of weak references, including usage patterns and their role in garbage collection and memory management.
Hardcore Java is an invaluable addition to every programmer's library, and even the most advanced developers will find themselves moving beyond their own conceptions into truly advanced applications of the language. Thousands of lines of code, heavily commented and easily runnable, illustrate each concept in the book.

Critique du livre par la rédaction (Baptiste Wicht) (12/2008)
Ce livre présente plusieurs particularités du langage Java ainsi que beaucoup de trucs et astuces permettant d'utiliser au mieux ce language.

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

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

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

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

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

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

Sommaire

  • 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

400 pages, 1ère édition, janvier 2004 Editions O'Reilly, ISBN10 : 0596005687, ISBN13 : 978-0596005689
Commandez sur www.amazon.fr :
39.95 EUR TTC (prix éditeur 39.95 EUR TTC) - Livraison Gratuite !
couverture du livre 'Java Persistence et Hibernate'

Note 3.5

Java Persistence et Hibernate

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

Résumé de l'éditeur

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

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

Critique du livre par la rédaction (Baptiste Wicht) (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 cœur 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.

Sommaire

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

365 pages, 1ère édition, 18 décembre 2007 Editions Eyrolles, ISBN10 : 2212122594, ISBN13 : 9782212122596
Commandez sur eyrolles.com : 39,90  EUR TTC seulement (au lieu de 42,00  EUR TTC : prix public)

Commandez sur www.amazon.fr :
39.90 EUR TTC seulement (au lieu de 42.00 EUR TTC : prix éditeur) - Livraison Gratuite !
couverture du livre 'Java Generics'

Note 3.5

Java Generics

and Collections

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

Résumé de l'éditeur

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Sommaire

  • 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

273 pages, 1ère édition, Novembre 2007 Editions O'Reilly, ISBN10 : 0-59652775-6, ISBN13 : 978-0-596-52775-4, Broché
Commandez sur www.amazon.fr :
21,27 EUR TTC (prix éditeur 25,01 EUR TTC) - Livraison Gratuite !
couverture du livre 'Checking Java Programs'

Note 4.0

Checking Java Programs

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

Résumé de l'éditeur

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

  • Using javac options, JUnit and assertions
  • Making your IDE work harder
  • Checking your source code with PMD
  • Checking your compiled code (.class files) with FindBugs
  • Checking your program's run-time behavior with Java PathFinder
Critique du livre par la rédaction (Baptiste Wicht) (décembre 2007)
Tout d'abord, ce livre ne se veut pas un livre complet sur les programmes cités ici. C'est une introduction à l'analyse de programmes. Ce livre est donc destiné aux programmeurs qui n'ont pas encore testés leurs propres outils d'analyse et qui aimeraient en savoir plus sur les possibilités existantes dans ce domaine.

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

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

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

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

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

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

Sommaire

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

54 pages, 1ere édition, Mars 2007 Editions O'Reilly, ISBN10 : 0596510233, Format PDF
Commandez sur www.amazon.fr :
couverture du livre 'Swing la synthèse'

Note 4.5

Swing la synthèse

Développement des interfaces graphiques en Java

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

Résumé de l'éditeur

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

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

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

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

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

Critique du livre par la rédaction (Baptiste Wicht) (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.

Sommaire

  • 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

348 pages, 2ème édition, 1 novembre 2005 Editions Dunod, ISBN10 : 2100492195, Broché
Commandez sur www.amazon.fr :
35,15 EUR TTC (prix éditeur 37,00 EUR TTC) - Livraison Gratuite !
couverture du livre 'Programmer en Java'

Note 4.5

Programmer en Java

de Claude Delannoy
Public visé : Tous niveaux
Introduction : 4ème édition Java 5.0

Résumé de l'éditeur

Dans cet ouvrage, Claude Delannoy applique ou langage Java la 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 nu développement Web avec les servlets Java et les JSP.

Chaque notion nouvelle et chaque fonction du langage est illustrée de programmes complets dont le code source est fourni sur le CD-Rom d'accompagnement. L'environnement de développement Eclipse 3.1, é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 4e édition sur les nouveautés de la version 5 de Java 2 Standard Edition : programmation générique (chapitre nouveau), types énumérés, types enveloppes, possibilités de " boxing/unboxing " automatique, arguments variables en nombre, boucle for... each, etc. Lorsque nécessaire, les exemples de code ont été fournis en deux versions : une version exploitant les possibilités nouvelles de J2SE 5.0 et une version compatible avec les versions antérieures.

Critique du livre par la rédaction (Baptiste Wicht)
Ce livre passe en revue et explique tout ce qu'il faut savoir sur Java. Les différents chapitres sont tous très complets et permettent de bien saisir les divers concepts de Java. De plus l'auteur a choisi d'ajouter de nombreux exemples en C++ pour montrer les similarités des deux langages, ce qui fera peut-être choisir ce livre à un programmeur C++ désirant passer à Java. Il ne faut pas oublier de dire que ce livre traite aussi de toutes les nouveautés qu'offre Java 5, c'est-à-dire la généricité, la boucle foreach, l'autoboxing.

Les premiers chapitres du livre sont consacrés aux généralités du langage Java : un historique du langage, les règles générales d'écriture, une explication très complète des types primitifs en Java, les opérateurs et les expressions et les instructions de contrôles. Cette partie va permettre de se familiariser avec Java et permettre de nous lancer dans l'étude des chapitres suivants.

Ensuite, le livre va consacrer plus de 170 de ses pages aux notions de programmation orienté objet. Toutes les notions y sont clairement expliquées et illustrées par des exemples. On passe des classes, des objets et des tableaux à l'héritage, à la redéfinition et à la sur définition et au polymorphisme puis on finit avec les types énumérés et les chaînes de caractères. Ces chapitres seront sans doute les plus compliqués pour le débutant en POO, mais certainement aussi les plus indispensables.

L'auteur passe ensuite à un chapitre sur les exceptions, traitant des exceptions en général et aussi de la création de nos propres exceptions. S'ensuit un chapitre, malheureusement trop court sur les threads.

Ensuite, l'auteur nous fera entrer dans le monde de la programmation graphique et événementielle avec Swing. Cette partie est très complète et comprend la gestion des événements, les contrôles usuels, les boîtes de dialogue, les menus, les gestionnaires de positionnement (layouts) et le dessin. On pourra néanmoins critiquer l'absence d'AWT et surtout que l'auteur ne traite pas des composants complexes tels que JTable ou JTree.

Une partie sur les applets vient ensuite, suivie d'une partie sur les flux d'entrée/sortie. Cette partie traite de la lecture et de l'écriture dans un fichier binaire, de la gestion de fichiers et des flux en général. Néanmoins, cette partie aurait mérité plus de matière tant il y a dire, car elle ne parle aucunement de communications réseau ni d'ailleurs des nouveaux fluxs réseaux de Java (nio).

Le dernier chapitre du livre est consacré à la programmation Java coté serveur. C'est-à-dire les servlets et les JSP. Ce chapitre est une bonne introduction à la compréhension et au développement de servlets et de JSP. Mais il ne va pas non plus assez loin pour permettre de créer des applications compliquées, ceci sortirait du contexte du livre.

Pour conclure, ce livre permet de bien saisir tous les concepts de Java et, malgré quelques lacunes, fournit à toute personne l'ensemble des bases nécessaires pour aller plus loin dans le développement d'applications Java. Le programmeur devra quand même passer par d'autres ouvrages plus ciblés pour aller plus loin dans certains concepts tels que la programmation côté serveur.

Sommaire

  • 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
  • Texte et graphiques
  • Les applets
  • Les flux et les fichiers
  • La programmation générique
  • Les collections et les algorithmes
  • Programmation Java coté serveur : servlets et JSP
  • Annexe A : Les droits d'accès aux membres, classes et interfaces
  • Annexe B : La classe Clavier
  • Annexe C : Les constantes et fonctions mathématiques
  • Annexe D : Les exceptions standard
  • Annexe E : Les exceptions graphiques et leurs méthodes
  • Annexe F : Les événements et les écouteurs
  • Annexe G : Les collections
  • Annexe H : Contenu et utilisation du CD-Rom

750 pages, 4ème édition, Mars 2006 Editions Eyrolles - Collection Blanche, ISBN10 : 2212117485, Broché, 21 x 5 x 23cm
Commandez sur www.amazon.fr :
33.25 EUR TTC (prix éditeur 35,00 EUR TTC) - Livraison Gratuite !
couverture du livre 'Mieux programmer en Java'

Note 4.0

Mieux programmer en Java

68 astuces pour optimiser son code

de Petter Haggar
Public visé : Connaissances de base en Java

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 atelierws 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.
Critique du livre par la rédaction (Baptiste Wicht)
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.

Sommaire

  • Techniques générales
  • Objets et tests d'égalité
  • Gestion des exceptions
  • Performances
  • Programmation multithread
  • Classes et interfaces
  • Annexes

224 pages, 1ère édition, Juillet 2000 Editions Eyrolles, ISBN10 : 2212091710, Broché
Commandez sur www.amazon.fr :
28.50 EUR TTC (prix éditeur 30,00 EUR TTC) - Livraison Gratuite !
couverture du livre 'Java Efficace'

Note 5.0

Java Efficace

Guide de Programmation

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

Résumé de l'éditeur

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

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

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

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

Critique du livre par la rédaction (Baptiste Wicht)
Ce livre est fait non seulement pour toutes les personnes qui doivent écrire des libraires 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 effet 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 à 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érale, 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.

Sommaire

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

272 pages, juin 2002 Editions Vuibert, ISBN10 : 2-7117-4805-7
Commandez sur www.amazon.fr :
30,40 EUR TTC (prix éditeur 32 EUR TTC) - Livraison Gratuite !
couverture du livre 'Les Cahiers du programmeur Swing'

Note 5.0

Les Cahiers du programmeur Swing

de Emmanuel Puybaret
Public visé : Connaissances de base en Java

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

Critique du livre par la rédaction (Baptiste Wicht)
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 à 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.

Sommaire

  • 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

499 pages, 1ère édition, 7 Décembre 2006 Editions Eyrolles, ISBN10 : 2212120192, Broché
Commandez sur www.amazon.fr :
37.05 EUR TTC (prix éditeur 39,00 EUR TTC) - Livraison Gratuite !
couverture du livre 'Les Design Patterns en Java : Les 23 modèles de conception fondamentaux'

Note 3.5

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

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

Résumé de l'éditeur

Par son approche pratique fondée sur de nombreux exemples d'application, Design Patterns en Java™ vous amène à une compréhension approfondie des patterns de conception, condition sine qua non pour tirer le meilleur parti de leur puissance dans le développement d'applications en Java. Ce document révolutionnaire introduit les fonctionnalités les plus récentes de Java et les meilleures pratiques aux 23 patterns.

Forts de leur grande 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 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.

Si vous êtes un programmeur Java désireux de gagner du temps grâce à l'écriture d'un code plus efficace, les explications lumineuses de cet ouvrage, étayées de nombreux exemples, conseils et techniques vous aideront à y parvenir. Vous maîtriserez la puissance des patterns et améliorerez vos programmes, tant en matière de conception que d'écriture et de maintenance du code.

Critique du livre par la rédaction (Baptiste Wicht)
Il est presque indispensable de connaître les design patterns pour bien concevoir et développer une application. En effet, il participent grandement à l'évolutivité et à la maintenabilité du code.

Ce livre présente les 23 design patterns principaux et il le fait très bien. Tous les patterns sont présentées de la même manière, on commence par voir quelle problèmatique peut régler le pattern en question et et quel est son objectif. Ensuite, on part sur un cas pratique (toujours basé sur la même application), dans lequel on montre la problèmatique et on la résoud grâce au pattern. Si c'est possible, on nous montre aussi d'autres exemples ou l'utilisation du pattern dans la librairie standard de Java, ce qui aide parfois a mieux comprendre quand utiliser le pattern.

Les patterns sont triés en plusieurs catégories différentes : les patterns d'interface, les patterns de responsabilité, les patterns de construction, les patterns de construction et les patterns d'extension. Comme tout les patterns et les catégories sont bien divisés, on peut facilement le lire comme un catalogue et rechercher un pattern spécifique, mais ce livre n'est pas seulement un catalogue de pattern, en effet, il vous propose des exercices pour vérifier vos connaissances et utilise une application concrète tout au long du livre, application dont on peut d'ailleurs télécharger les sources.

On peut néanmoins reprocher plusieurs choses à ce livre. Tout d'abord, l'application choisie n'est peut-être pas la meilleure... On se retrouve souvent avec des termes techniques relatifs aux feux d'artifices ce qui nous embrouille souvent... De plus, on a parfois de la peine à bien comprendre ce que fait vraiment la partie de l'application. Ensuite, le style n'est pas toujours des plus agréables et je n'ai jamais réussi à passer longtemps sur ce livre, alors qu'il m'est arrivé de ne pas décrocher d'autres livres pendant plusieurs heures. Et enfin, du fait parfois du style et parfois des exemples, j'ai eu de la peine à bien comprendre le pattern, notamment VISITOR (mais ce n'est pas le plus simple).

En conclusion, ce livre est une très bonne introduction aux designs patterns et vous permettra de produire un code plus maintenable et évolutif. Mais ne vous attendez pas non plus à un livre que vous lirez des heures durant.

Sommaire

  • 1.Introduction
  • 2.Introduction aux interfaces
  • 3.ADAPTER
  • 4.FACADE
  • 5.COMPOSITE
  • 6.BRIDGE
  • 7.Introduction à la responsabilité
  • 8.SINGLETON
  • 9.OBSERVER
  • 10.MEDIATOR
  • 11.PROXY
  • 12.CHAIN OF RESPONSABILITY
  • 13.FLYWEIGHT
  • 14.Introduction à la construction
  • 15.BUILDER
  • 16.FACTORY METHOD
  • 17.ABSTRACT FACTORY
  • 18.PROTOTYPE
  • 19.MEMENTO
  • 20.Introduction aux opérations
  • 21.TEMPLATE METHOD
  • 22.STATE
  • 23.STRATEGY
  • 24.COMMAND
  • 25.INTERPRETER
  • 26.Introduction aux extensions
  • 27.DECORATOR
  • 28.ITERATOR
  • 29.VISITOR

435 pages, 1ère édition, 25 août 2006 Editions CampusPress, ISBN10 : 2744020990
Commandez sur www.amazon.fr :
39,90 EUR TTC (prix éditeur 42 EUR TTC) - Livraison Gratuite !

precedent    sommaire    suivant

Valid XHTML 1.0 TransitionalValid CSS!