方法链与绑定

这一课你将能做到

1. 手写一个返回 this 的链式 Builder，并说出链式调用不改变绑定规则的原因
2. 区分静态绑定与动态绑定，指出 static 方法「看起来被覆盖了」其实是隐藏
3. 在 Stream 链中标出中间操作与终结操作，解释惰性求值何时触发

为什么要学

builder.name("x").amount(3).build()、list.stream().filter(...).map(...).toList()——企业代码里两处最常见的链式写法，都依赖同一个机制：方法返回自身引用或同类新对象。看不懂绑定规则，就会在「父类引用调静态方法」这类问题上踩坑还找不出原因。

面试角度：「static 方法能被重写吗」「动态绑定的实现原理」「Builder 模式解决什么问题」是 OOP 追问链的标配第三问，答到 vtable 一层就是加分项。

先建立图像

链式调用的本质：
  obj.a()          → 返回 this（还是 obj）
  .b()             → 继续在 obj 上调用
  .build()         → 返回最终产品

绑定规则速查：
  ┌────────────────────┬──────────┬────────────────────────┐
  │ 调用类型            │ 绑定时机 │ 看谁                   │
  ├────────────────────┼──────────┼────────────────────────┤
  │ static 方法        │ 编译期   │ 声明（引用）类型        │
  │ private/final 方法 │ 编译期   │ 声明类型（不可覆盖）    │
  │ 重载的取舍          │ 编译期   │ 参数的编译期类型        │
  │ 普通实例方法        │ 运行期   │ 实际对象类型（多态）    │
  └────────────────────┴──────────┴────────────────────────┘

跟着做

步骤 1：静态绑定 vs 动态绑定——静态方法是「隐藏」不是覆盖

新建 BindingDemo.java，完整可运行：

public class BindingDemo {

    static class Animal {
        static String kind() { return "animal"; }   // 静态方法
        String speak() { return "..."; }            // 实例方法
    }

    static class Dog extends Animal {
        static String kind() { return "dog"; }      // 这是「隐藏」，不是覆盖
        @Override
        String speak() { return "汪"; }             // 覆盖，动态绑定
    }

    public static void main(String[] args) {
        Animal a = new Dog();
        System.out.println(a.speak()); // 汪：运行期看实际对象 Dog
        System.out.println(a.kind());  // animal：编译期看声明类型 Animal

        Dog d = new Dog();
        System.out.println(d.kind());  // dog：声明类型是 Dog 才走 Dog.kind()
    }
}

运行：java BindingDemo.java。第三行输出是 animal——a.kind() 等价于 Animal.kind()，编译器按声明类型解析静态调用。IDE 会对此给出黄色警告，别忽略它。

步骤 2：手写链式 Builder

继续在 BindingDemo.java 里追加内部类与 main 片段：

    static class OrderBuilder {
        private String sku;
        private int amount;
        private boolean urgent;

        OrderBuilder sku(String v)     { this.sku = v; return this; }
        OrderBuilder amount(int v)     { this.amount = v; return this; }
        OrderBuilder urgent(boolean v) { this.urgent = v; return this; }

        String build() {
            if (sku == null || amount <= 0) throw new IllegalStateException("参数未就绪");
            return "Order[" + sku + ", " + amount + ", urgent=" + urgent + "]";
        }
    }

    String order = new OrderBuilder()
            .sku("SKU-1")
            .amount(3)
            .urgent(true)
            .build();
    System.out.println(order);

每个 setter 返回 this，链就成立；build() 做最终校验，保证产出的对象是「合法的」。Lombok 的 @Builder 生成的是同一套结构，Spring Boot 项目里到处都是。

步骤 3：Stream 也是链——中间操作惰性、终结操作触发

新建 StreamChainDemo.java：

import java.util.List;

public class StreamChainDemo {

    record Lesson(String slug, int order) {}

    public static void main(String[] args) {
        List<Lesson> lessons = List.of(
                new Lesson("jva-methods", 5),
                new Lesson("jva-oop", 4),
                new Lesson("jva-records", 6));

        List<String> slugs = lessons.stream()
                .peek(l -> System.out.println("经过: " + l.slug())) // 观察惰性
                .filter(l -> l.order() > 4)   // 中间操作，不立即执行
                .map(Lesson::slug)            // 方法引用也是链的一环
                .sorted()                     // 中间操作
                .toList();                    // 终结操作，此刻才逐元素走管道
        System.out.println(slugs);
    }
}

运行后观察 peek 的输出顺序：元素是「一个一个流过整条管道」的，而不是 filter 全做完再 map——这就是惰性求值。

讲清楚要点

1. 链式 API 靠返回 this：setter 风格 Builder 返回自身；Stream 返回新 Stream 对象（不可变风格，链上每步不污染上游）。
2. 链式调用不改变绑定规则：链上每一段仍是普通实例方法调用，运行期依然按实际对象类型分派。
3. static 方法不能被覆盖，只能被隐藏：静态方法属于类不属于实例，子类同名静态方法只是遮住父类版本；用 Animal a = new Dog() 调 a.kind() 走的是 Animal 的版本。
4. private 与 final 方法不参与动态绑定：JVM 可直接静态绑定它们，因此构造器里调用它们是安全的（呼应第 4 课）。
5. Builder 的适用边界：参数多（≥4）、有可选参数、需要不可变产物时用 Builder；两三个必选参数直接构造器最简。链过长难调试，关键步骤可拆行。
6. Stream 中间操作不执行任何计算：filter/map/sorted 只记录管道结构，toList/forEach/count 等终结操作才触发遍历；理解这点才能解释「为什么改集合要在终结前」与短路行为。

你可能会懵的地方

• 方法链和连续调用是一回事吗？ 形式上一样，但链式 API 的前提是方法返回有意义的对象（this 或新对象）。返回 void 的方法无法成链。
• 为什么说 Stream 链比 Builder 链「更纯」？ Builder 的 setter 修改自身状态后返回 this，链上共享一个可变对象；Stream 每个中间操作生成新 Stream，上游不受影响。不可变风格在并发与调试上都更安全。
• 重载的取舍在编译期，那泛型擦除会影响重载吗？ 会。f(List<String>) 与 f(List<Integer>) 擦除后签名相同，编译直接报错——这就是「重载看编译期签名」的代价之一。
• 动态绑定底层怎么实现的？ 每个类在方法区有一张虚方法表（vtable），实例头指向它；调用实例方法时按实际类型的 vtable 偏移量查找，因此「父类引用调子类方法」只需要一次表内跳转，开销极小。
• Lombok @Builder 和手写 Builder 选哪个？ 团队已用 Lombok 就用注解，减少样板；但要理解生成结构（本课手写版），排查序列化、继承 Builder 等问题时不会懵。

错法对照

错法	问题	正解
以为 a.kind()（a 是 Dog 实例）会走 Dog 版本	静态方法按声明类型绑定	静态方法用类名调用：Animal.kind()
setter 返回 void 还想链式	编译不过	返回 this
Builder 链中途复用半成品对象	状态被上一次 build 污染	每次从 new Builder 开始，build 后即弃
无限拉长 Stream 链不出错也不可读	排障困难	超过 5 步拆成局部变量命名清晰
在中间操作里修改外部集合	惰性执行时机不可控，易并发修改	副作用收敛到终结操作 forEach/toList

卡点急救

1. 链式调用编译报「cannot be applied」：上一环返回的不是你以为的类型；检查每个方法的返回类型，链式 API 的类型必须环环相扣。
2. 静态方法多态「没生效」：这不是 bug，是隐藏语义；把调用改成 类名.方法 消除歧义，需要多态就改成实例方法。
3. Stream 管道执行了但结果为空：上游 filter 条件过严或数据源为空；用 peek 逐级观察（仅调试用），确认数据在哪一步消失。

面试常问

• static 方法能被重写吗？ 可背版：不能。静态方法属于类，编译期按引用类型静态绑定；子类定义同名静态方法只是「隐藏」父类版本，父类引用仍调用父类方法。同理 private、final 方法也不参与动态绑定。
• 动态绑定的原理？ JVM 为每个类建立虚方法表，对象头持有指向本类方法表的指针；调用实例方法时，按实际类型的 vtable 条目分派，因此「编译看左边、运行看右边」，且单次查找开销很小。
• Builder 模式解决什么问题？什么时候不用？ 解决多参数构造的可读性与可选参数组合爆炸，且天然配合不可变对象（字段 final、build 时统一校验）。参数少于等于 3 个、无可选参数时直接构造器，不必为模式而模式。

自测三问

1. Animal a = new Dog(); a.kind() 与 a.speak() 分别走谁的版本？为什么？
2. Stream 的中间操作为什么是惰性的？终结操作有哪些？
3. Builder 的 build() 里做校验，比在 setter 里逐个校验好在哪里？

小结一句话

链式 API 靠返回 this，多态靠运行期绑定；static 方法只有隐藏没有覆盖，Stream 链的执行终点在终结操作。

延伸

• Java 官方教程：覆盖与隐藏
• 下一课：Record 与不可变