在标准的 Java 语法中，你不能直接写 类名.方法名().方法名() 这样的代码。

类名.方法名 这种形式，通常指的是 静态方法调用，而一个静态方法的调用，其返回值是一个对象（Object），如果这个返回的对象，恰好又拥有自己的一个方法，那么你就可以在这个返回的对象上继续调用它的方法，这看起来就像一个“链式”调用。

你看到的 类名.方法名.方法名，实际上是下面这种写法的简化和省略：

类名.静态方法名().返回对象的方法名()

下面我们通过一个完整的例子来理解这个过程。

核心概念分解

1. 静态方法 (Static Method)

   • 使用 static 关键字修饰。
   • 它属于类,而不是类的某个实例。
   • 可以直接通过 类名.方法名() 来调用，无需创建对象。
   • 静态方法通常用于与类相关的工具性操作,或者作为工厂方法来创建并返回类的实例。

2. 方法链 (Method Chaining)

   • 一种编程风格,允许在一个对象上连续调用多个方法。
   • 实现方法链的关键是：每个被调用的方法都返回调用它的那个对象本身（this）。
   • myObject.method1().method2().method3();

3. 静态工厂方法 (Static Factory Method)

   • 这是一个静态方法,它的主要职责是创建并返回一个该类的（或另一个类的）实例。
   • 这正是连接“静态方法调用”和“方法链”的桥梁。

完整示例代码

假设我们要创建一个 StringBuilder 的“仿制品”来演示这个过程。StringBuilder 本身就是一个非常经典的方法链和静态方法结合的例子。

创建我们的工具类 StringUtils

这个类将包含一个静态方法 of，它接收一个字符串并返回一个 MyStringBuilder 对象。

// StringUtils.java
public class StringUtils {
    /**
     * 这是一个静态工厂方法。
     * 它接收一个字符串，并创建并返回一个 MyStringBuilder 对象。
     * @param initialString 初始字符串
     * @return 一个新的 MyStringBuilder 实例
     */
    public static MyStringBuilder of(String initialString) {
        System.out.println("StringUtils.of() 被调用了，正在创建 MyStringBuilder 对象...");
        return new MyStringBuilder(initialString);
    }
}

创建我们的链式调用类 MyStringBuilder

这个类将实现方法链,它的每个修改方法（如 append, toUpperCase）都会返回 this。

// MyStringBuilder.java
public class MyStringBuilder {
    private StringBuilder sb;
    public MyStringBuilder(String initialString) {
        this.sb = new StringBuilder(initialString);
        System.out.println("MyStringBuilder 对象已创建，初始内容为: \"" + initialString + "\"");
    }
    /**
     * 追加字符串，并返回自身以支持链式调用
     */
    public MyStringBuilder append(String str) {
        this.sb.append(str);
        System.out.println("    -> 调用了 append(\"" + str + "\")");
        return this; // 关键：返回当前对象
    }
    /**
     * 转换为大写，并返回自身以支持链式调用
     */
    public MyStringBuilder toUpperCase() {
        this.sb = new StringBuilder(this.sb.toString().toUpperCase());
        System.out.println("    -> 调用了 toUpperCase()");
        return this; // 关键：返回当前对象
    }
    /**
     * 完成构建，返回最终的字符串
     */
    public String build() {
        System.out.println("    -> 调用了 build()");
        return this.sb.toString();
    }
}

在 Main 类中演示调用

我们来看一下如何将它们组合起来,实现你提问中的那种形式。

// Main.java
public class Main {
    public static void main(String[] args) {
        System.out.println("--- 开始演示 ---");
        // 这是完整的、清晰的写法
        System.out.println("\n[方式一：完整写法]");
        MyStringBuilder builder1 = StringUtils.of("hello");
        builder1.append(" world");
        builder1.toUpperCase();
        String result1 = builder1.build();
        System.out.println("最终结果: " + result1);
        // 这就是你提问的“链式”写法
        // 它实际上是上面写法的精简版
        System.out.println("\n[方式二：链式写法 - 回答你的问题]");
        String result2 = StringUtils.of("java")
                                    .append(" is awesome")
                                    .toUpperCase()
                                    .build();
        System.out.println("最终结果: " + result2);
        System.out.println("\n--- 演示结束 ---");
    }
}

运行结果分析

运行 Main.java，你会得到如下输出：

--- 开始演示 ---
[方式一：完整写法]
StringUtils.of() 被调用了，正在创建 MyStringBuilder 对象...
MyStringBuilder 对象已创建，初始内容为: "hello"
    -> 调用了 append(" world")
    -> 调用了 toUpperCase()
最终结果: HELLO WORLD
[方式二：链式写法 - 回答你的问题]
StringUtils.of() 被调用了，正在创建 MyStringBuilder 对象...
MyStringBuilder 对象已创建，初始内容为: "java"
    -> 调用了 append(" is awesome")
    -> 调用了 toUpperCase()
    -> 调用了 build()
最终结果: JAVA IS AWESOME
--- 演示结束 ---

流程解读：

1. StringUtils.of("java")

   • 首先执行 StringUtils 类的静态方法 of("java")。
   • 这个方法创建并返回了一个 MyStringBuilder 对象。
   • 表达式的值就是这个新创建的 MyStringBuilder 对象。

2. .append(" is awesome")

   • 由于上一步返回了一个 MyStringBuilder 对象，所以可以直接在这个对象上调用它的方法 append(" is awesome")。
   • append 方法执行完后，返回了 this（也就是它自己）。
   • 表达式的值依然是这个 MyStringBuilder 对象。

3. .toUpperCase()

   • 同理,在上一步返回的 MyStringBuilder 对象上调用 toUpperCase() 方法。
   • toUpperCase 方法也返回了 this。
   • 表达式的值仍然是这个 MyStringBuilder 对象。

4. .build()

   • 调用 build() 方法。
   • build() 方法的返回类型是 String，所以链式调用在此结束，result2 变量接收这个最终的字符串值。

现实世界中的例子

这种模式在 Java 标准库中非常常见：

1. StringBuilder / StringBuffer

   // 静态方法调用 + 方法链
   String s = new StringBuilder("hello")
                  .append(" world")
                  .reverse()
                  .toString();
   System.out.println(s); // 输出: dlrow olleh

   • new StringBuilder("hello") 创建对象，后续都是方法链。

2. java.util.stream.Collectors

   import java.util.stream.Collectors;
   import java.util.List;
   import java.util.Arrays;
   List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
   // 静态方法调用 + 方法链
   String nameList = names.stream()
                          .collect(Collectors.joining(", ")); // Collectors.joining 是静态方法
   System.out.println(nameList); // 输出: Alice, Bob, Charlie

3. Jackson / Gson 等 JSON 库

   // 静态方法调用 + 方法链
   String json = new ObjectMapper()
                     .createObjectNode()
                     .put("name", "John")
                     .put("age", 30)
                     .toString();
   System.out.println(json); // 输出: {"name":"John","age":30}

当你看到 类名.方法名.方法名 这样的代码时，可以立刻理解它的内部逻辑：先通过静态方法获取一个对象，然后立即在这个对象上连续调用其自身的方法。