Unlock Java Mastery: 90 Essential Tips from Effective Java

Effective Java – Core Summary

Effective Java, authored by Joshua Bloch, presents 90 essential programming rules and practical solutions for everyday Java development, serving as a reference for engineers at leading companies.

Fundamental Items

Object Creation and Destruction

Static factory methods instead of constructors

Static factories have names that clearly describe the object being returned.

They can reuse existing instances instead of creating a new one each call.

They may return any subtype of the declared return type.

They simplify creation of parameterized types, e.g. Map<String, List<String>> m = HashMap.newInstance() versus new HashMap<String, List<String>>().

Builder pattern for many parameters

Multiple constructor parameters are better handled with a builder that enforces required arguments and allows optional ones to be set fluently.

The builder separates object construction from representation, enabling immutable objects.

Avoid creating unnecessary objects

Prefer string literals ( String s = "") over new String("") to reuse interned strings.

Prefer primitive types over boxed types to avoid autoboxing overhead.

Eliminate obsolete object references

Use WeakHashMap or LinkedHashMap for caches and clear unused entries promptly.

Explicitly remove listeners and callbacks when they are no longer needed.

General Object Methods

Override equals

Check reference equality with ==, then instanceof, cast, and compare each significant field.

Never overload equals(Object) with a different parameter type.

Always override hashCode when equals is overridden

Equal objects must have equal hash codes to work correctly with hash‑based collections.

Override toString

Provide a descriptive representation of the object's state.

Avoid fragile formatting that external code must parse.

Consider implementing Comparable

Enables natural ordering and use with generic sorting algorithms.

Class and Interface Design

Minimize accessibility

Prefer private, then package‑private, protected, and finally public for members.

Expose only what is necessary to reduce coupling.

Composition over inheritance

Favor using a private field of another class (composition) instead of extending it, unless the superclass is explicitly designed for inheritance.

Interfaces over abstract classes

Interfaces allow flexible type hierarchies without the single‑inheritance limitation of abstract classes.

Use interfaces to define types only

Do not use interfaces as constant holders; prefer enum or static final fields.

Prefer static nested classes

If a nested class does not need access to the outer instance, declare it static to avoid hidden references.

Enum and Annotation Guidelines

Prefer enum over int constants

Enums provide type safety, clear semantics, and can hold fields and methods.

Never rely on ordinal()

Store explicit data in instance fields instead of using the enum’s ordinal value.

Use EnumSet instead of bit‑mask fields

EnumSet

offers type‑safe, efficient set operations for enums.

Use EnumMap instead of ordinal‑based arrays

EnumMap

provides a clear, type‑safe mapping from enum keys to values.

Concurrency Essentials

Synchronized access to mutable shared data

Guard mutable state with synchronized blocks or explicit locks to prevent visibility and atomicity problems.

Avoid excessive synchronization; keep synchronized sections small.

Prefer high‑level constructs such as ExecutorService, ConcurrentHashMap, and CopyOnWriteArrayList where appropriate.

Avoid over‑synchronization

Too much locking reduces parallelism and can cause deadlocks.

Do not call external methods while holding a lock.

Prefer thread pools to raw threads

Use Executors.newFixedThreadPool for high‑load servers and Executors.newCachedThreadPool for lightweight tasks.

Replace Timer with ScheduledThreadPoolExecutor for accurate, recoverable scheduling.

Document thread‑safety

Classify objects as immutable, unconditionally thread‑safe, conditionally thread‑safe, or not thread‑safe, and document the required locking discipline.

General Development Tips

Prefer static factory methods over constructors for readability and flexibility.

Use builders for objects with many optional parameters.

Implement singletons with private constructors or enum singletons to prevent reflection and serialization attacks.

Make utility classes non‑instantiable with a private constructor that throws an exception.

Avoid unnecessary object creation; reuse objects or use object pools only for expensive resources.

Clear obsolete references (e.g., set array slots to null) to aid garbage collection.

Never invoke the garbage collector explicitly; let the JVM manage memory.

Follow the standard contracts when overriding equals, hashCode, toString, and clone.

Prefer generic types over raw types; specify concrete type parameters.

Return empty collections or arrays instead of null to avoid NPEs.

Use StringBuilder for intensive string concatenation.

Avoid reflection for ordinary code paths; it bypasses compile‑time checks and hurts performance.

Reserve exceptions for truly exceptional conditions; do not use them for regular control flow.

Distinguish checked exceptions (recoverable) from unchecked runtime exceptions (programming errors).

Write clear Javadoc for all public APIs, describing behavior, side effects, and thread‑safety guarantees.

Keep variable scope as narrow as possible and prefer enhanced for loops over indexed loops when feasible.

Use BigDecimal for precise monetary calculations instead of float / double.

Follow naming conventions and avoid using strings as substitutes for stronger types.

Conclusion

Effective Java is a classic guide for Java developers and object‑oriented programmers; studying its 90 rules, especially the sections on concurrency and enums, can dramatically improve coding quality and architectural design.