Java Academy · Lesson

Choosing the Right Nesting Strategy

Decide between nested class variants based on coupling, access needs, and readability.

Choosing the Right Nesting Strategy is a free Java Academy lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Java Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Choosing the Right Nesting Strategy

Java offers four nesting options: top-level, static nested, inner (non-static), and local/anonymous. Choosing the right one depends on coupling, access needs, and reuse scope.

Decision Tree

Ask these questions to choose:

Is the class used only inside the outer class? → Consider nesting
Does it need the outer instance? → Inner class; else → Static nested
Is it used only in one method? → Local class or anonymous
Does it implement a single method? → Lambda

Top-Level Class

Use a top-level class when the type has broad use across the codebase, represents a key domain concept, or will be imported by many other classes.

// Top-level: used across many packages
public class Product {
    // ...
}

public interface Repository<T, ID> {
    Optional<T> findById(ID id);
    void save(T entity);
}

// These belong in separate .java files and are widely imported

Static Nested Class

Use static nested when: the class is only meaningful in the context of the outer class, it does not need the outer instance, and it should be accessible externally.

class Graph {
    // Edge only makes sense in the context of a Graph
    public static class Edge {
        public final int from, to, weight;
        public Edge(int from, int to, int weight) {
            this.from = from; this.to = to; this.weight = weight;
        }
    }

    private List<Edge> edges = new ArrayList<>();

    public void addEdge(int from, int to, int weight) {
        edges.add(new Edge(from, to, weight));
    }
}

Inner (Non-Static) Class

Use inner when: the class has a strong conceptual tie to the outer instance and must access its private members — like iterators or closely coupled helper objects.

class DataStore<T> {
    private final List<T> data;

    DataStore(List<T> data) { this.data = data; }

    // Must access data — inner class makes sense
    class Snapshot {
        private final List<T> copy;

        Snapshot() { this.copy = List.copyOf(data); } // accesses outer

        T get(int idx) { return copy.get(idx); }
        int size()     { return copy.size(); }
    }

    Snapshot snapshot() { return new Snapshot(); }
}

Local Class

Use local when: the class is only needed in a single method, it is complex enough to have multiple methods or state, and you want to keep the scope minimal.

static int countWords(String text, boolean caseSensitive) {
    class WordCounter {
        Map<String, Integer> counts = new HashMap<>();

        void count(String word) {
            String key = caseSensitive ? word : word.toLowerCase();
            counts.merge(key, 1, Integer::sum);
        }

        int uniqueCount() { return counts.size(); }
    }

    WordCounter wc = new WordCounter();
    for (String w : text.split("\\s+")) wc.count(w);
    return wc.uniqueCount();
}
System.out.println(countWords("the cat sat on the mat", false)); // 5

Anonymous Class vs Lambda

Use anonymous class when multi-method or abstract class extension is needed. Use lambda for SAM interfaces.

// Lambda: clean for SAM
list.sort((a, b) -> a.compareTo(b));

// Anonymous: multi-method, or extending abstract class
java.util.TimerTask task = new java.util.TimerTask() {
    @Override public void run() { System.out.println("Tick!"); }
};
// TimerTask is abstract class — can't use lambda directly

Summary Table

Quick reference:

Top-level: broad reuse, public API types
Static nested: logically grouped, no outer instance needed
Inner: strongly tied to outer instance, needs private access
Local: method-scoped, complex enough for a class
Anonymous: one-off implementation, short-lived
Lambda: SAM interface, no state, concise

Practical: HTTP Client Design

Applying nesting strategy to a realistic HTTP client design.

class HttpClient {
    // Static nested: request config has no outer reference
    public static class RequestConfig {
        public final int timeoutMs;
        public final String userAgent;
        RequestConfig(int timeout, String ua) { this.timeoutMs = timeout; this.userAgent = ua; }
    }

    // Static nested: response is standalone data carrier
    public static class Response {
        public final int statusCode;
        public final String body;
        Response(int code, String body) { this.statusCode = code; this.body = body; }
    }

    private final RequestConfig config;
    HttpClient(RequestConfig config) { this.config = config; }

    public Response get(String url) {
        // Implementation using this.config
        return new Response(200, "body");
    }
}

Avoid Over-Nesting

Avoid nesting more than one level deep. Deeply nested classes become hard to navigate and test. Extract to top-level or package-private classes if they grow complex.

Package-Private Alternative

Instead of nesting, consider making a class package-private (no access modifier). It is visible only within the package but is easier to test and maintain than a nested class.

// In package com.example.order:

// Package-private: visible in package, no nesting
class OrderLine {  // no 'public' modifier
    final String sku;
    final int qty;
    OrderLine(String sku, int qty) { this.sku = sku; this.qty = qty; }
}

// Public class in same package can use OrderLine freely
public class Order {
    private List<OrderLine> lines = new ArrayList<>();
    // ...
}

Records and Sealing as Alternatives

Modern Java features — records and sealed interfaces — often eliminate the need for complex nesting patterns.

// Instead of nested inner class hierarchy:
sealed interface Shape permits Circle, Rectangle, Triangle {}
record Circle(double r) implements Shape {}
record Rectangle(double w, double h) implements Shape {}
record Triangle(double b, double h) implements Shape {}

static double area(Shape s) {
    return switch (s) {
        case Circle c      -> Math.PI * c.r() * c.r();
        case Rectangle r   -> r.w() * r.h();
        case Triangle t    -> 0.5 * t.b() * t.h();
    };
}

Quick Check

When is an inner (non-static) class the best choice over a static nested class?

Recap: Choosing the Right Nesting Strategy

Key takeaways:

Top-level: public types used widely across the codebase
Static nested: logically grouped with outer, no outer instance needed
Inner class: strongly tied to outer instance, accesses private members
Local class: method-scoped, complex enough for multiple methods
Anonymous class: one-off, combines declaration and instantiation
Lambda: cleanest for SAM interfaces; consider when replacing anonymous classes

Frequently asked questions

Is the “Choosing the Right Nesting Strategy” lesson free?

Yes — the full text of “Choosing the Right Nesting Strategy” is free to read here on the web, and the Java Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Java Academy course, upgrade to CoddyKit PRO.

What will I learn in “Choosing the Right Nesting Strategy”?

Decide between nested class variants based on coupling, access needs, and readability. You practise Java Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Java Academy?

No prior experience is required. Java Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Choosing the Right Nesting Strategy” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Java Academy lesson?

Yes. Every Java Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Java Academy