notes from effective java

effectiveJava.txt

Effective Java
==============

[Creating and Destroying Objects]

/ Consider static factory methods instead of constructors
+ they have names
+ they are not required to create a new object each time they’re invoked
+ they can return an object of any subtype of their return type
- classes without public or protected constructors cannot be subclassed
- they are not readily distinguishable from other static methods

/ Consider a builder when faced with many constructor parameters
+ the Builder pattern is a good choice when designing classes whose constructors or static factories would have more than a handful of parameters
- it could be a problem in some performance-critical situations

/ 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
+ flexibility to change
- a privileged client can invoke the private constructor reflectively (AccessibleObject.setAccessible)

/ Enforce noninstantiability with a private constructor
+ guarantees that the class will never be instantiated under any circumstances
+ prevents the class from being subclassed
- Attempting to enforce noninstantiability by making a class abstract does not work.

/ Avoid creating unnecessary objects
+ prefer primitives to boxed primitives, and watch out for unintentional autoboxing.
- increases memory footprint, and harms performance
- creating objects unnecessarily merely affects style and performance.

/ Eliminate obsolete object references
+ nulling out object references should be the exception rather than the norm.
- whenever a class manages its own memory, the pro- grammer should be alert for memory leaks

/ Avoid finalizers

- finalizers are unpredictable, often dangerous, and generally unnecessary.
- can cause erratic behavior, poor performance, and portability problems.