Effective JAVA Second Edition

This book gives you a lot of advices how to make your code more correct and perfect.

Item 1: Consider static factory methods instead of constructors

Item 2: Consider a builder when faced with many constructor parameters
Item 3: Enforce the singleton property with a private constructor or an enum type
Item 4: Enforce non instantiability with a private constructor
Item 5: Avoid creating unnecessary objects
Prefer primitives to boxed primitives, and watch out for unintentional autoboxing.
Item 6: Eliminate obsolete object references
Item 7: Avoid finalizers
Item 8: Obey the general contract when overriding equals()
Item 9: Always override hashCode() when you override equals()
Item 10: Always override toString()
Item 11: Override clone() judiciously
Item 12: Consider implementing Comparable
Item 13: Minimize the accessibility of classes and members
Item 14: In public classes, use accessor methods, not public fields
Item 15: Minimize mutability
Item 16: Favor composition over inheritance
Item 17: Design and document for inheritance or else prohibit it
Item 18: Prefer interfaces to abstract classes
Item 19: Use interfaces only to define types
Item 20: Prefer class hierarchies to tagged classes
Item 21: Use function objects to represent strategies
Item 22: Favor static member classes over nonstatic
Item 23: Don't use raw types in new code
Item 24: Eliminate unchecked warnings
Item 25: Prefer lists to arrays
Item 26: Favor generic types
Item 27: Favor generic methods
Item 28: Use bounded wildcards to increase API flexibility
Item 29: Consider type safe heterogeneous containers
Item 30: Use enums instead of int constants
Item 31: Use instance fields instead of ordinals
Item 32: Use EnumSet instead of bit fields
Item 33: Use EnumMap instead of ordinal indexing
Item 34: Emulate extensible enums with interfaces
Item 35: Prefer annotations to naming patterns
Item 36: Consistently use the @Override annotation
Item 37: Use marker interfaces to define types
Item 38: Check parameters for validity
Item 39: Make defensive copies when needed
Item 40: Design method signatures carefully
Item 41: Use overloading judiciously
Item 42: Use varargs judiciously
Item 43: Return empty arrays or collections, not nulls
Item 44: Write doc comments for all exposed API elements
Item 45: Minimize the scope of local variables
Item 46: Prefer for-each loops to traditional for loops
Item 47: Know and use the libraries
Item 48: Avoid float and double if exact answers are required
Item 49: Prefer primitive types to boxed primitives
Item 50: Avoid strings where other types are more appropriate
Item 51: Beware the performance of string concatenation
Item 52: Refer to objects by their interfaces
Item 53: Prefer interfaces to reflection
Item 54: Use native methods judiciously
Item 55: Optimize judiciously
Item 56: Adhere to generally accepted naming conventions
Item 57: Use exceptions only for exceptional conditions
Item 58: Use checked exceptions for recoverable conditions and runtime exceptions for
programming errors
Item 59: Avoid unnecessary use of checked exceptions
Item 60: Favor the use of standard exceptions
Item 61: Throw exceptions appropriate to the abstraction
Item 62: Document all exceptions thrown by each method
Item 63: Include failure-capture information in detail messages
Item 64: Strive for failure atomicity
Item 65: Don't ignore exceptions
Item 66: Synchronize access to shared mutable data
Item 67: Avoid excessive synchronization
Item 68: Prefer executors and tasks to threads
Item 69: Prefer concurrency utilities to wait() and notify()
Item 70: Document thread safety
Item 71: Use lazy initialization judiciously
Item 72: Don't depend on the thread scheduler
Item 73: Avoid thread groups
Item 74: Implement Serializable judiciously
Item 75: Consider using a custom serialized form
Item 76: Write readObject() methods defensively
Item 77: For instance control, prefer enum types to readResolve()
Item 78: Consider serialization proxies instead of serialized instances
 I chosed a few tips that we can easily apply in our applications. Using these tips we can improve
code quality and we can have a better performance of the application.

Item 1: Consider static factory methods instead of constructors

 One advantage of static factory methods is that, unlike constructors, they have names.
 A second advantage of static factory methods is that, unlike constructors, they are not required to
create a new object each time they are invoked.
 A fourth advantage of static factory methods is that they reduce the verbosity of
creating parametrized type instances.
 The main disadvantage of providing only static factory methods is that classes without public or
protected constructors cannot be sub-classed.
 A second disadvantage of static factory methods is that they are not readily distinguishable from
other static methods.

Item 3: Enforce the singleton property with a private constructor or an enum type
A single-element enum type is the best way to implement a singleton.
//Enum singleton - the preferred approach
public enum Elvis {
INSTANCE;
public void leaveTheBuilding() { . . . }
}

Item 15: Minimize mutability

1. Don't provide any methods that modify the objects state.
2. Ensure that the class cant be extended.
3. Make all fields final.
4. Make all fields private.
5. Ensure exclusive access to any mutable components.
Immutable objects are inherently thread-safe; they require no synchronization.
The only real disadvantage of immutable classes is that they require a separate object for each
distinct value.
 Classes should be immutable unless there is a very good reason to make them mutable.
Immutable classes provide many advantages, and their only disadvantage is the potential for
performance problems under certain circumstances.
If a class cannot be made immutable, limit its mutability as much as possible.
Make every field final unless there is a compelling reason to make it nonfinal.

Item 16: Favor composition over inheritance

The disadvantages of wrapper classes are few. One caveat is that wrapper classes are not suited
for use in callback frameworks, where in objects pass self references to other objects for subsequent
invocations (callbacks). Because a wrapped object doesn't know of its wrapper, it passes a reference to
itself (this) and callbacks elude the wrapper.
Inheritance is appropriate only in circumstances where the subclass really is a subtype of the
superclass.

Item 17: Design and document for inheritance or else prohibit it

The only way to test a class designed for inheritance is to write subclasses.
You must test your class by writing subclasses before you release it.
Constructors must not invoke overridable methods, directly or indirectly.
Neither clone() nor readObject() may invoke an overridable method, directly or indirectly.
Designing a class for inheritance places substantial limitations on the class.
The best solution to this problem is to prohibit subclassing in classes that are not designed and
documented to be safely subclassed.

Item 23: Don't use raw types in new code

If you use raw types, you lose all the safety and expressiveness benefits of generics.
You lose type safety if you use a raw type like List, but not if you use a parameterized type
like List<Object>.
You must use raw types in class literals.
This is the preferred way to use the instanceof operator with generic types.
Item 24: Eliminate unchecked warnings
If you can't eliminate a warning, and you can prove that the code that provoked the warning is
type safe, then (and only then) suppress the warning with
an @SuppressWarnings("unchecked") annotation.
Always use the @SuppressWarnings annotation on the smallest scope possible.
Every time you use an @SuppressWarnings("unchecked") - annotation, add a comment saying why its
safe to do so.

Item 28: Use bounded wildcards to increase API flexibility

For maximum flexibility, use wildcard types on input parameters that represent producers or
consumers.
Do not use wildcard types as return types.
If the user of a class has to think about wild card types, there is probably something wrong with
the class’s API.
Always use Comparable<? super T> in preference to Comparable<T>.
Always use Comparator<? super T> in preference to Comparator<T>.
If a type parameter appears only once in a method declaration, replace it with a wild card.

Item 40: Design method signatures carefully

Choose method names carefully.
Don't go overboard in providing convenience methods.
Avoid long parameter lists.
For parameter types, favor interfaces over classes.

Item 41: Use overloading judiciously

Selection among overloaded methods is static, while selection among overridden methods is
dynamic.
A safe, conservative policy is never to export two overloadings withthe same number of parameters.
Item 44: Write doc comments for all exposed API elements
To document your API properly, you must precede every exported class, interface, constructor,
method, and field declaration with a doc comment.
The doc comment for a method should describe succinctly the contract between the method and
its client.
It is no longer necessary to use the HTML <code> or <tt> tags in doc comments: the
Javadoc {@code} tag is preferable because it eliminates the need to escape HTML meta characters.
When documenting a generic type or method, be sure to document all type parameters.
When documenting an enum type, be sure to document the constants.
When documenting an annotation type, be sure to document any members.

Item 45: Minimize the scope of local variables

Declare it where it is first used.
Nearly every local variable declaration should contain an initializer.
Prefer for loops to while loops.
Keep methods small and focused.

Item 66: Synchronize access to shared mutable data

Reading and writing a boolean field is atomic.
Synchronization has no effect unless both read and writeoperations are synchronized.
Increment operator (++) is not atomic.
When multiple threads share mutable data, each thread that reads or writes the data must perform
synchronization.

Item 69: Prefer concurrency utilities to wait() and notify()

Given the difficulty of using wait() and notify() correctly, you should use the higher-level
concurrency utilities instead.
For intervaltiming, always use System.nanoTime() in preference to System.currentTimeMillis().
Always use the wait loop idiom to invoke the wait() method; never invoke it outside of a loop.
//The standard idiom for using the wait method
synchronized (obj) {
 while (<condition does not hold>)
obj.wait(); // (Releases lock, and reacquires on wakeup)

// Perform action appropriate to condition

}

Item 72: Don't depend on the thread scheduler

The best way to write a robust, responsive, portable program is to ensure that the average number
of runnable threads is not significantly greater than the number of processors.
Threads should not run if they aren't doing useful work.
Resist the temptation to fix the program by putting in calls to Thread.yield().
Thread.yield() has no testable semantics.

Item 74: Implement Serializable judiciously

A second cost of implementing Serializable is that it increases the likelihood of bugs and security
holes.
A major cost of implementing Serializable is that it decreases the flexibility to change a class
implementation once it has been released.
A third cost of implementing Serializable is that it increases the testing burden associated with
releasing a new version of a class.
Implementing the Serializable interface is not a decision to be undertaken lightly.
Classes designed for inheritance (Item 17) should rarely implement Serializable, and interfaces
should rarely extend it.
You should consider providing a parameterless constructor on nonserializable classes designed
for inheritance.
Inner classes (Item 22) should not implement Serializable.

Item 75: Consider using a custom serialized form

Do not accept the default serialized form without first considering whether it is appropriate.
The default serialized form is likely to be appropriate if an objects physical representation is
identical to its logical content.
 Even if you decide that the default serialized form is appropriate, you often must provide
a readObject() method to ensure invariants and security.
Before deciding to make a field nontransient, convince yourself that its value is part of the
logical state of the object.
You must impose any synchronization on object serialization that you would impose on any other
method that reads the entire state of the object.
Regardless of what serialized form you choose, declare an explicit serial version UID in every
serializable class you write.