Java Academy · 课时

选择合适的嵌套策略

Q: 「选择合适的嵌套策略」这节课中我会学到什么？

根据耦合程度、访问需求和可读性，在不同嵌套类变体之间做出选择 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

根据耦合程度、访问需求和可读性，在不同嵌套类变体之间做出选择

选择合适的嵌套策略 是 CoddyKit 上的免费 Java Academy 课时。这是第 4 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 4 节课。

选择正确的嵌套策略

Java 提供四种嵌套选项：顶层类、静态嵌套类、内部类（非静态）以及局部类/匿名类。正确的选择取决于耦合程度、访问需求和复用作用域。

决策树

请通过以下问题进行选择：

该类是否只在外部类内部使用？→ 考虑嵌套
它是否需要外部实例？→ 内部类；否则 → 静态嵌套类
它是否只在一个方法中使用？→ 局部类或匿名类
它是否只实现一个方法？→ lambda 表达式

顶层类

当某个类型在整个代码库中都有广泛用途、代表关键领域概念，或会被许多其他类导入时，请使用顶层类。

// 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

静态嵌套类

在以下情况下请使用静态嵌套类：该类只有在外部类的上下文中才有意义；不需要外部实例；并且应当能够从外部访问。

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));
    }
}

内部类（非静态）

在以下情况下请使用内部类：该类与外部实例存在紧密的概念联系，并且必须访问外部类的私有成员——例如迭代器或高度耦合的辅助对象。

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(); }
}

局部类

在以下情况下请使用局部类：该类只在单个方法中需要，复杂到需要多个方法或状态，并且您希望将作用域保持在最小范围内。

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

匿名类与 Lambda

需要多个方法或继承抽象类时，请使用匿名类。对于 SAM 接口，请使用 lambda 表达式。

// 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

总结表

快速参考：

顶层类：广泛复用，公共应用程序接口类型
静态嵌套类：逻辑上归为一组，不需要外部实例
内部类：与外部实例紧密关联，需要访问私有成员
局部类：作用域限定在方法内，复杂到足以使用一个类
匿名类：一次性实现，生命周期较短
lambda 表达式：SAM 接口，无状态，简洁

实践：HTTP 客户端设计

将嵌套策略应用于一个真实的 HTTP 客户端设计。

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");
    }
}

避免过度嵌套

避免嵌套超过一层。深层嵌套的类很难浏览和测试。如果类变得复杂，请将其提取为顶层类或包级私有类。

包级私有替代方案

与其进行嵌套，不如考虑将类设为包级私有（不添加访问修饰符）。它只在包内可见，但相比嵌套类更易于测试和维护。

// 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<>();
    // ...
}

记录类与密封类型作为替代方案

现代 Java 特性——记录类和密封接口——通常可以消除复杂嵌套模式的需求。

// 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();
    };
}

快速检查

什么时候使用内部类比使用静态嵌套类更合适？

回顾：选择正确的嵌套策略

要点：

顶层类：在整个代码库中广泛使用的公共类型
静态嵌套类：与外部类进行逻辑分组，不需要外部实例
内部类：与外部实例紧密关联，可以访问私有成员
局部类：作用域限定在方法内，复杂到需要多个方法
匿名类：一次性使用，将声明和实例化合并在一起
lambda 表达式：SAM 接口最简洁的选择；替代匿名类时可以考虑使用

常见问题解答

「选择合适的嵌套策略」课时是免费的吗？

是的 — 「选择合适的嵌套策略」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 4 节课。

「选择合适的嵌套策略」这节课中我会学到什么？

根据耦合程度、访问需求和可读性，在不同嵌套类变体之间做出选择你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 4 节课，共 4 节。

「选择合适的嵌套策略」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Java Academy 课中编写并运行代码吗？

能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Java Academy