7 Java Mistakes Every Beginner Makes (and How to Fix Them)

Java is strict and powerful — and it has traps. Here are seven common mistakes beginners make, each with a clear example and fix you can apply today.

By Udbhav R · Sep 4, 2025

Quick navigation

1. 1. Forgetting to close resources
2. 2. Confusing == with .equals()
3. 3. Missing break in switch
4. 4. NullPointerException
5. 5. Static vs instance confusion
6. 6. Ignoring exceptions
7. 7. Overusing public (lack of encapsulation)

1) Forgetting to Close Resources

The mistake:

Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
// Forgot scanner.close()

Leaving resources open (files, sockets, scanners) can leak system resources and cause unpredictable behavior.

// ✅ Fix: try-with-resources
try (Scanner scanner = new Scanner(System.in)) {
    String name = scanner.nextLine();
}

Tip: Use try-with-resources for AutoCloseable objects (Streams, Readers, Sockets, DB connections).

2) Confusing == with .equals()

The mistake:

String a = new String("Hello");
String b = new String("Hello");

if (a == b) {
    System.out.println("Equal");
}

Why it fails: == compares references (identity). For value equality use .equals().

// ✅ Fix:
if (a.equals(b)) {
    System.out.println("Equal");
}

Note: For primitives (int, boolean) == compares values. For objects, prefer .equals() or Objects.equals(a, b) to avoid NPEs.

3) Forgetting break in switch

The mistake:

int day = 1;

switch (day) {
    case 1:
        System.out.println("Monday");
    case 2:
        System.out.println("Tuesday");
}

Output will be both "Monday" and "Tuesday" because execution falls through without break.

// ✅ Fix:
switch (day) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
}

Pro tip: In modern Java you can use the enhanced switch expression (Java 14+) to avoid fall-through.

4) NullPointerException (NPE)

The mistake:

String name = null;
System.out.println(name.length()); // Crash!

NPEs are one of the most common runtime errors for beginners.

// ✅ Fix 1: check for null
if (name != null) {
    System.out.println(name.length());
}

// ✅ Fix 2: Use Optional (safer)
Optional maybeName = Optional.ofNullable(name);
maybeName.ifPresent(n -> System.out.println(n.length()));

Tip: Use static analysis tools and IDE inspections to spot possible null dereferences early.

5) Mixing Up Static and Instance

The mistake:

class Counter {
    int count = 0;
}

Counter c1 = new Counter();
Counter c2 = new Counter();
c1.count++;
System.out.println(c2.count); // 0

Beginners often expect instance fields to be shared across objects.

// ✅ Fix: use static for shared fields
class Counter {
    static int count = 0;
}

Use static when a value should belong to the class as a whole; otherwise, use instance fields.

6) Ignoring Exceptions

The mistake:

Thread.sleep(1000); // Unhandled exception

The compiler forces you to handle checked exceptions — don’t ignore them by throwing broadly.

// ✅ Fix: handle specifically
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt(); // good practice
    e.printStackTrace();
}

Tip: Prefer handling exceptions at the right level and avoid decluttering with generic throws Exception on many methods.

7) Overusing public — Poor Encapsulation

The mistake:

public class BankAccount {
    public double balance; // anyone can change this
}

Making fields public breaks encapsulation and allows uncontrolled access.

// ✅ Fix: encapsulate with private fields and methods
public class BankAccount {
    private double balance;

    public void deposit(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("Amount must be positive");
        balance += amount;
    }

    public double getBalance() {
        return balance;
    }
}

Why it matters: Encapsulation preserves invariants and makes your code maintainable and safe.

---

Quick Checklist (Pin this)

• Use try-with-resources to auto-close resources.
• Use .equals() for object equality; use == for primitives.
• Remember break in switch or prefer switch expressions.
• Guard against null and prefer Optional when suitable.
• Know when to use static vs instance fields.
• Handle checked exceptions intentionally — don’t hide them.
• Encapsulate fields; expose behaviour via methods.

FAQ

How can I avoid NullPointerExceptions proactively?

Use static analysis tools (IDE warnings, SpotBugs) and code contracts. Consider using Optional to represent potentially missing values.

When should I use static?

Use static when a field or method belongs to the class as a whole (shared across instances) — for example, a global counter or a utility method.

Is try-with-resources supported in all Java versions?

Yes — try-with-resources has been supported since Java 7. It’s the preferred pattern to automatically close AutoCloseable resources.

Final Thoughts

Java’s strictness helps you catch errors early — but beginners can get tripped up by small details. Avoid the seven mistakes above and you’ll write cleaner, safer Java code. Which one of these tripped you up when you started? Share your story in the comments — I love hearing debugging tales.

Follow me on Medium

Suggested tags: Java, Programming, Java Tips, Beginner Java, Software Development