instanceof 模式匹配（JDK 14 预览 / JDK 16 正式）

孔蓝正在重构飞翔科技的订单处理模块。他在一个方法里写了三次 instanceof——每次都是同样的模式：判断类型、强制转换、使用转换后的变量。

"看看这代码——"他指着屏幕给白歌看：

if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

"三部曲：instanceof → 强转 → 使用。三个步骤每个模块都在重复，写得我都怀疑自己在做复制粘贴工程师。"

白歌笑了笑，把光标移到 instanceof 后面："JDK 16 的语法，一步完成。以后判断和转换不用分家了——"

定义表

概念描述
instanceof 模式匹配（Pattern Matching for instanceof）JDK 16 正式特性，在 instanceof 判断成功后直接将对象绑定到指定类型的变量，消除显式强制转换
绑定变量（Binding Variable）obj instanceof String s 中的 s——当判断为 true 时，s 已经被转换为 String 类型，可直接使用
作用域（Scope）绑定变量 s 在 if 语句为 true 的分支内可见；在 else 分支中不可见
流式作用域（Flow Scoping）绑定变量在条件表达式中的可见性遵循数据流分析规则，编译器精确追踪变量"确定被赋值"的位置

传统写法的痛点：三部曲

基础用法：一步完成判断 + 绑定

public class PatternInstanceofBasic {
    public static void main(String[] args) {
        Object[] data = { "飞翔科技", 2020, "技术部", 42 };

        for (Object obj : data) {
            // === JDK 16：instanceof 一步完成判断 + 变量绑定 ===
            if (obj instanceof String s) {
                // s 已经是 String 类型，可以直接使用 String 的方法
                System.out.println("字符串内容: " + s);
                System.out.println("  长度: " + s.length());
                System.out.println("  大写: " + s.toUpperCase());
            } else if (obj instanceof Integer i) {
                // i 已经是 Integer 类型
                System.out.println("整数: " + i);
                System.out.println("  平方: " + (i * i));
            }
        }
    }
}

输出：

字符串内容: 飞翔科技
  长度: 4
  大写: 飞翔科技
整数: 2020
  平方: 4080400
字符串内容: 技术部
  长度: 3
  大写: 技术部
整数: 42
  平方: 1764

进阶用法：复杂条件组合

绑定变量可以在 && 右侧使用——编译器精确分析数据流，确保变量在该位置已被赋值。

public class PatternInstanceofComplex {
    public static void main(String[] args) {
        // === 飞翔科技员工信息处理 ===
        Object[] employees = {
                "大翔:CTO:35000",
                "白歌:架构师:30000",
                12345,  // 非字符串数据
                "小崔:后端开发:12000"
        };

        for (Object obj : employees) {
            // === 绑定变量 + 复杂条件 ===
            if (obj instanceof String s && s.contains("CTO")) {
                System.out.println("【高管】" + s);
            } else if (obj instanceof String s && s.length() > 10) {
                // 注意：第二个 s 是新的绑定变量（不同作用域）
                System.out.println("【长记录】" + s);
            } else if (obj instanceof String s) {
                System.out.println("【普通记录】" + s);
            } else {
                System.out.println("【非法数据】" + obj);
            }
        }
    }
}

输出：

【高管】大翔:CTO:35000
【长记录】白歌:架构师:30000
【非法数据】12345
【长记录】小崔:后端开发:12000

equals() 实现的最佳实践

instanceof 模式匹配让 equals() 方法的实现变得简洁而安全。

import java.util.Objects;

public class PatternInstanceofEquals {
    // === JDK 16 风格的 equals 实现 ===
    static class Employee {
        private final String name;
        private final int id;

        Employee(String name, int id) {
            this.name = name;
            this.id = id;
        }

        @Override
        public boolean equals(Object obj) {
            // 一步完成：类型检查 + 变量绑定 + 字段比较
            return obj instanceof Employee other
                    && this.id == other.id
                    && Objects.equals(this.name, other.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, id);
        }
    }

    public static void main(String[] args) {
        Employee e1 = new Employee("大翔", 1001);
        Employee e2 = new Employee("大翔", 1001);
        Employee e3 = new Employee("白歌", 1002);

        System.out.println("e1.equals(e2) = " + e1.equals(e2));  // true
        System.out.println("e1.equals(e3) = " + e1.equals(e3));  // false
        System.out.println("e1.equals(null) = " + e1.equals(null));  // false
        System.out.println("e1.equals(\"大翔\") = " + e1.equals("大翔"));  // false
    }
}

输出：

e1.equals(e2) = true
e1.equals(e3) = false
e1.equals(null) = false
e1.equals("大翔") = false

绑定变量的作用域规则

public class PatternInstanceofScope {
    static void demo(Object obj) {
        if (obj instanceof String s) {
            // ✅ s 在这里是 String 类型
            System.out.println("if 块内: " + s.toUpperCase());
        } else {
            // ❌ s 在 else 块中不可用
            // System.out.println(s);  // 编译错误：找不到符号 s
            System.out.println("else 块: 不是 String 类型");
        }

        // ❌ s 在 if 块外也不可用
        // System.out.println(s);  // 编译错误
    }

    public static void main(String[] args) {
        demo("hello");
        demo(42);
    }
}

输出：

if 块内: HELLO
else 块: 不是 String 类型

易错场景

绑定变量名与已有变量冲突

public class PatternInstanceofShadowPitfall {
    public static void main(String[] args) {
        String s = "外部变量";

        Object obj = "内部数据";

        // ❌ 编译错误：绑定变量名不能遮盖已有局部变量
        // if (obj instanceof String s) {  // 错误！s 已经存在
        //     System.out.println(s);
        // }

        // ✅ 使用不同的变量名
        if (obj instanceof String inner) {
            System.out.println("内部: " + inner);
        }
        System.out.println("外部: " + s);
    }
}

输出：

内部: 内部数据
外部: 外部变量

不能用 instanceof 替代 null 检查

public class PatternInstanceofNullPitfall {
    public static void main(String[] args) {
        Object obj = null;

        // instanceof 对 null 返回 false，不会进入分支
        if (obj instanceof String s) {
            System.out.println("不会执行到这里");
        } else {
            System.out.println("obj 为 null，instanceof 返回 false");
        }

        // ✅ 如果需要处理 null 情况，先判空
        String result;
        if (obj == null) {
            result = "默认值";
        } else if (obj instanceof String s) {
            result = s;
        } else {
            result = obj.toString();
        }
        System.out.println("最终结果: " + result);
    }
}

输出：

obj 为 null，instanceof 返回 false
最终结果: 默认值

过早优化：对 final 类使用 instanceof

public class PatternInstanceofFinalPitfall {
    public static void main(String[] args) {
        String name = "飞翔科技";

        // ⚠️ String 是 final 类，不会有子类
        // 对 final 类使用 instanceof 模式匹配虽然合法，但无意义
        if (name instanceof String s) {
            // s 和 name 是完全相同的引用
            System.out.println("多余的模式匹配: " + s);
        }

        // ✅ 对于 final 类型，直接使用即可
        System.out.println("直接使用: " + name.toUpperCase());
    }
}

输出：

多余的模式匹配: 飞翔科技
直接使用: 飞翔科技

面试考点

面试官常问的三个问题：

问题一："instanceof 模式匹配和传统强制转换有什么本质区别？"

答案：传统方式需要两步——先 instanceof 判断，再手动 (Type) obj 强制转换。这有两个问题：第一，同一个类型名写两次，代码繁琐；第二，强制转换在语法上没有和 instanceof 检查绑定，理论上可能出现检查后仍转换失败的情况（虽然不常见）。模式匹配将判断和绑定合二为一——编译器保证绑定变量的类型安全，杜绝了 ClassCastException 的可能性。

问题二："if (obj instanceof String s && s.length() > 5) 中 s 为什么在 && 右侧可用？"

答案：这是 JDK 编译器数据流分析的结果。当 obj instanceof String s 返回 true 时，绑定变量 s 从该点开始就"确定被赋值"。在 && 短路求值中，右侧表达式只在左侧为 true 时才求值，所以编译器可以安全地认为 s 在 && 右侧一定是有效的 String 引用。类似地，|| 运算符的右侧则不能使用绑定变量（因为左侧为 false 时不会进入右侧）。

问题三："绑定变量在 else 块中为什么不可用？"

答案：当 obj instanceof String s 为 false 时，obj 不是 String 类型，s 从未被赋值。因此在 else 块中 s 处于"确定未被赋值"状态，编译器禁止使用。这种"流式作用域"机制确保了你不会在变量未初始化的情况下使用它。

孔蓝的重构总结："我把订单处理模块里 47 处 instanceof + 强转 全部改成了模式匹配语法。删除的不是代码，是重复劳动带来的精神内耗。白歌说这叫'让工具做工具该做的事'——以后写 equals() 方法，一行就够了。"