Effective Java Second Edition

Consider a builder when faced with many constructor parameters.

Consider static factory methods instead of constructors.

Obey the general contract when overriding equals.

Enforce non-instantiability with a private constructor.

Enforce the singleton property with a private constructor or an enum type

Avoid creating unnecessary objects

Eliminate obsolete object references

Avoid finalizers

Always override hashCode when you override equals

Always override toString

Override clone judiciously

Consider implementing Comparable

Minimize the accessibility of classes and members

In public classes, use accessor methods, not public fields

Minimize mutability

Favor composition over inheritance

Design and document for inheritance or else prohibit it

Prefer interfaces to abstract classes

Use interfaces only to define types

Prefer class hierarchies to tagged classes

Use function objects to represent strategies

Favor static member classes over non-static

Don't use raw types in new code

Eliminate unchecked warnings

Prefer lists to arrays

Favor generic types

Favor generic methods

Use bounded wildcards to increase API flexibility

Consider typesafe heterogeneous containers

Use enums instead of int constants

Use instance fields instead of ordinals

Use EnumSet instead of bit fields

Use EnumMap instead of ordinal indexing

Emulate extensible enums with interfaces

Prefer annotations to naming patterns

Consistently use the Override annotation

Use marker interfaces to define types

Check parameters for validity

Make defensive copies when needed

Design method signatures carefully

Use overloading judiciously

Use varargs judiciously

Return empty arrays or collections, not nulls

Write doc comments for all exposed API elements

Minimize the scope of local variables

Prefer for-each loops to traditional for loops

Know and use the libraries

Avoid float and double if exact answers are required

Prefer primitive types to boxed primitives

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 and 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

Prefer executors and tasks to threads

Prefer concurrency utilities to wait and notify

Document thread safety

Use lazy initialization judiciously

Don't depend on the thread scheduler

Avoid thread groups

Implement Serializable judiciously

Consider using a custom serialized form

Write readObject methods defensively

For instance control, prefer enum types to readResolve

Consider serialization proxies instead of serialized instances