2. Creating and Destroying Objects.
Consider Providing Static Factory Methods Instead of Constructors.Enforce the Singleton Property with a Private Constructor.Enforce Noninstantiability with a Private Constructor.Avoid Creating Duplicate Objects.Eliminate Obsolete Object References.Avoid Finalizers.
3. Methods Common to All Objects.
Obey the General Contract when Overriding Equals.Always Override HashCode When You Override Equals.Always Override to String.Override Clone Judiciously.Consider Implementing Comparable.
4. Classes and Interfaces.
Minimize the Accessibility of Classes and Members.Favor Immutability.Favor Composition Over Inheritance.Design and Document for Inheritance or Else Prohibit It.Prefer Interfaces to Abstract Classes.Use Interfaces Only to Define Types.Favor Static Member Classes Over Non-Static.
5. Substitutes for C Constructs.
Replace Structures with Classes.Replace Unions with Class Hierarchies.Replace Enums with Classes.Replace Function Pointers with Classes and Interfaces.
Check Parameters for Validity.Make Defensive Copies when Needed.Design Method Signatures Carefully.Use Overloading Judiciously.Return Zero-Length Arrays, Not Nulls.Write Doc Comments for All Exposed API Elements.
7. General Programming.
Minimize the Scope of Local Variables.Know and Use the Libraries.Avoid Float and Double if Exact Answers are Required.Avoid Strings where Other Types are More Appropriate.Beware the Performance of String Concatenation.Refer to Objects by their Interfaces.Prefer Interfaces to Reflection.Use Native Methods Judiciously.Optimize Judiciously.Adhere to Generally Accepted Naming Conventions.
Use Exceptions Only for Exceptional Conditions.Use Checked Exceptions for Recoverable Conditions, Runtime Exceptions for Programming Errors.Avoid Unnecessary Use of Checked Exceptions.Favor the Use of Standard Exceptions.Throw Exceptions Appropriate to the Abstraction.Document All Exceptions Thrown by Each Method.Include Failure-Capture Information in Detail Messages.Strive for Failure Atomicity.Don't Ignore Exceptions.
Synchronize Access to Shared Mutable Data.Avoid Excessive Synchronization.Never Invoke Wait Outside a Loop.Don't Depend on the Thread Scheduler.Document Thread-Safety.Avoid Thread Groups.
Implement Serializable Judiciously.Consider Using a Custom Serialized Form.Write ReadObject Methods Defensively.Provide a ReadResolve Method when Necessary.
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.
Joshua Bloch is a principal engineer at Google and a Jolt
Award-winner. He was previously a distinguished engineer at Sun
Microsystems and a senior systems designer at Transarc. Josh led
the design and implementation of numerous Java platform features,
including JDK 5.0 language enhancements and the award-winning Java
Collections Framework. He holds a Ph.D. in computer science from
Carnegie Mellon University.