Effective Java Programming Language Guide

# Publisher: Prentice Hall PTR; 1st edition (June 5, 2001)
# Language: English
# ISBN-10: 0201310058
# ISBN-13: 978-0201310054

Book Description

Effective Java Programming Language Guide distills the hard-won wisdom of today's best Java programmers into 50 techniques for designing and constructing more robust, high-performance software. Josh Bloch, one of Sun's most widely respected Java developers, focuses on the practical problems virtually every Java developer encounters, offering specific solutions and top-notch code examples. Josh Bloch identifies 50 practices that lead directly to better code -- including better alternatives for common practices that have proven undesirable in real-world development. The techniques are specific, thoroughly explained, and supported by top-notch code examples. Among the highlights: why developers should avoid finalizers; when to use delegation instead of inheritance; and how to make the most of Java's powerful typesafe enum pattern. Nearly all 50 practices relate to the "core" of the Java platform -- the language itself -- making the book relevant to every Java developer.

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)

Download Link