Effective Java Programming Language Guide

Effective Java Programming Language Guide

$39.99 $28.79

  • Release Date: 05 June, 2001
  • Collectible Price: $48.65
  • Used Price: $22.17
  • Availability: Usually ships within 24 hours
  • Third Party Used Price: $27.93

Author: Joshua Bloch

Written for the working Java developer, Joshua Bloch's Effective Java Programming Language Guide provides a truly useful set of over 50 best practices and tips for writing better Java code. With plenty of advice from an indisputable expert in the field, this title is sure to be an indispensable resource for anyone who wants to get more out of their code.

As a veteran developer at Sun, the author shares his considerable insight into the design choices made over the years in Sun's own Java libraries (which the author acknowledges haven't always been perfect). Based on his experience working with Sun's best minds, the author provides a compilation of 57 tips for better Java code organized by category. Many of these ideas will let you write more robust classes that better cooperate with built-in Java APIs. Many of the tips make use of software patterns and demonstrate an up-to-the-minute sense of what works best in today's design. Each tip is clearly introduced and explained with code snippets used to demonstrate each programming principle.

Early sections on creating and destroying objects show you ways to make better use of resources, including how to avoid duplicate objects. Next comes an absolutely indispensable guide to implementing "required" methods for custom classes. This material will help you write new classes that cooperate with old ones (with advice on implementing essential requirements like the equals() and hashCode() methods).

The author has a lot to say about class design, whether using inheritance or composition. Tips on designing methods show you how to create understandable, maintainable, and robust classes that can be easily reused by others on your team. Sections on mapping C code (like structures, unions, and enumerated types) onto Java will help C programmers bring their existing skills to Sun's new language. Later sections delve into some general programming tips, like using exceptions effectively. The book closes with advice on using threads and synchronization techniques, plus some worthwhile advice on object serialization.

Whatever your level of Java knowledge, this title can make you a more effective programmer. Wisely written, yet never pompous or doctrinaire, the author has succeeded in packaging some really valuable nuggets of advice into a concise and very accessible guidebook that arguably deserves a place on most any developer's bookshelf. --Richard Dragan

Topics covered:

  • Best practices and tips for Java
  • Creating and destroying objects (static factory methods, singletons, avoiding duplicate objects and finalizers)
  • Required methods for custom classes (overriding equals(), hashCode(), toString(), clone(), and compareTo() properly)
  • Hints for class and interface design (minimizing class and member accessibility, immutability, composition versus inheritance, interfaces versus abstract classes, preventing subclassing, static versus nonstatic classes)
  • C constructs in Java (structures, unions, enumerated types, and function pointers in Java)
  • Tips for designing methods (parameter validation, defensive copies, method signatures, method overloading, zero-length arrays, hints for Javadoc comments)
  • General programming advice (local variable scope, using Java API libraries, avoiding float and double for exact comparisons, when to avoid strings, string concatenation, interfaces and reflection, avoid native methods, optimizing hints, naming conventions)
  • Programming with exceptions (checked versus run-time exceptions, standard exceptions, documenting exceptions, failure-capture information, failure atomicity)
  • Threading and multitasking (synchronization and scheduling hints, thread safety, avoiding thread groups)
  • Serialization (when to implement Serializable, the readObject(), and readResolve() methods)

Similar Products

Core J2EE Patterns: Best Practices and Design Strategies, Second Edition

From $34.99:

Core J2EE Patterns: Best Practices and Design Strategies, Second Edition

The Java(TM) Programming Language (3rd Edition)

From $39.99:

The Java(TM) Programming Language (3rd Edition)

Design Patterns

From $43.99:

Design Patterns

Expert One-on-One J2EE Design and Development (Programmer to Programmer)

From $40.79:

Expert One-on-One J2EE Design and Development (Programmer to Programmer)

Refactoring: Improving the Design of Existing Code

From $42.34:

Refactoring: Improving the Design of Existing Code

Customer Rating: 4.83 of 5 (84 total reviews)

  • 5 starsUseful tips, tricks and

    A very readable book that an aspiring developer should read after mastering the basics of Java. The contents is well-thought out, Java specific, and thus very good. No fluff here, and it does live up to the expectations set by C. Meyers! It won't turn you into a Java guru (for that, you need to know the core libraries very well - collections, networking, threads), but will move you in that direction quite a bit.
    I loved the sections on Methods Common to All Objects (an equivalent of the 'canonical form ' in C++), immutable objects (author presents coherent reasoning behind them, it got me thinking and I saw the light!) exceptions (this is a very pedestrian topic, the advice is excellent and time-saving). Also, the typesafe enum pattern was very good.
    The book is very well written and a real treat. Definitely buy it as your second or third book on Java :-)

  • 5 starsExcellent and thought provoking.

    The first time I noticed Josh Bloch was when I was reading an article on artima.com. His incisive comments on software design and coding style led me to read this book. It is undoubtedly the best Java book I've read since "Thinking In Java".

    I highly recommend this book to anyone who's written enough Java to have asked themselves, "is this the right way to do what I'm doing," or "there must be a better way."

    Anyone who is designing libraries should study Josh's Items, challenge them. There is much to appreciate in the volume of experience that writing a book like this takes.

    The one weakness in this book: it does not address the kind of software development consulting teams need to adopt in order to deliver "Extreme Programming" style. I wish it addressed programming for customization; the book squarely focusses on programming reusable libraries.

    I hope every reader derives as much wisdom from this book as I was able to. Thank you Josh Bloch.

  • 5 starsSimply Amazing

    I read the reviews on this book, but I did not think that it would be as good as everyone says. I was wrong. I develop java applications commercially and I thought that I could read up a bit to make sure that I was still using good habits and making the best code. I could not believe the insight that the author has. The books does not just tell you what to do, it explains when some things should be used and when to choose another route. In many cases he gives many possible ways to solve a problem and gives the pros and cons of each. His writing style is fun to read (for someone who loves programming) and very professional. When reading you can feel his experience and authority on java along with his in depth knowledge of this internal JDK structure and paradigms. I will never sell this book, it is too valuable. Take his advice and save the world from the code you may have written without his guidance.