Master Java Best Practices: 75 Essential Tips from Effective Java

Introduction

The article reviews core Java guidelines from the book Effective Java , illustrating each rule with code snippets and practical explanations.

1. Prefer static factory methods over constructors

Static factory methods can have meaningful names, control instance creation, and return cached objects.

public static People getInstance() {
    return new People();
}

2. Use the Builder pattern for many constructor parameters

When a class has numerous optional parameters, replace telescoping constructors with a nested static Builder class.

public static class Builder {
    private String name;
    private int age;
    public Builder(String name, int age) { this.name = name; this.age = age; }
    public Builder sex(String sex) { this.sex = sex; return this; }
    public Builder grade(String grade) { this.grade = grade; return this; }
    public Student build() { return new Student(this); }
}

3. Singleton implementations

Four approaches are compared: eager initialization, lazy initialization, enum singleton, and serialization‑safe singleton using readResolve.

public enum Instance { INSTANCE; }

4. Avoid mutable static fields and use final

Declare constants as static final and prefer immutable objects. Example:

private final int code;

5. Prefer interfaces over concrete classes

Program to interfaces such as List<String> list = new ArrayList<>(); to increase flexibility.

6. Favor generics over raw types

Using generic collections catches type errors at compile time.

List<String> list = new ArrayList<>();
list.add("hello");
// list.add(1); // compile‑time error

7. Use EnumSet and EnumMap instead of bit fields or ordinal indexing

EnumSet provides a type‑safe, efficient set for enum constants.

EnumSet<Operation> ops = EnumSet.noneOf(Operation.class);
ops.add(Operation.DIVIDE);

EnumMap maps enum keys to values without the pitfalls of using raw Map<Class<?>, Object>.

EnumMap<AlarmPoints, Command> map = new EnumMap<>(AlarmPoints.class);
map.put(AlarmPoints.KITCHEN, () -> System.out.println("Kitchen fire"));

8. Prefer for‑each loops over indexed for loops

They are less error‑prone and clearer.

for (String s : list) {
    System.out.println(s);
}

9. Use Override annotation

Ensures methods truly override a superclass method.

10. Avoid overloading when it creates ambiguity

Example: list.remove(i) can remove by index or by object; use list.remove((Integer)i) to clarify.

11. Defensive copying for mutable fields

When exposing mutable objects, return copies to preserve immutability.

public Date start() {
    return new Date(start.getTime());
}

12. Document thrown exceptions with @throws

Every public API should list checked and unchecked exceptions it may throw.

13. Use enums instead of int constants

Enums provide type safety and can carry data and behavior.

public enum ErrorCode {
    FAILURE(0, "Operation failed"),
    SUCCESS(1, "Operation succeeded");
    private final int code;
    private final String msg;
    ErrorCode(int code, String msg) { this.code = code; this.msg = msg; }
}

14. Prefer BigDecimal for precise numeric calculations

Floating‑point types ( float, double) can introduce rounding errors.

15. Concurrency best practices

Synchronize access to shared mutable data.

Prefer Executor and Future over raw Thread.

Use concurrent collections (e.g., ConcurrentHashMap) instead of wait/notify.

16. Serialization considerations

Implement Serializable only when necessary; define readObject / writeObject for custom forms and maintain version compatibility.

private void writeObject(ObjectOutputStream out) throws IOException {
    out.defaultWriteObject();
    // custom handling
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
    in.defaultReadObject();
    // validation
}

Conclusion

The collection of 75 rules provides a roadmap for writing robust, maintainable Java code, emphasizing immutability, clear APIs, proper use of language features, and disciplined concurrency and serialization practices.