本地记录类的使用

public class OrderService {
    public void processOrders(List<Order> orders) {
        // 在方法内部定义本地记录类
        record OrderSummary(String productName, int quantity, double totalPrice) {}
        
        List<OrderSummary> summaries = [orders.stream](<http://orders.stream>)()
            .map(order -> new OrderSummary(
                order.getProductName(),
                order.getQuantity(),
                order.getPrice() * order.getQuantity()
            ))
            .toList();
        
        summaries.forEach(System.out::println);
    }
}

类似的用法

1. 本地类（Local Classes）

从 Java 早期版本就支持，可以在方法内部定义普通类：

public void calculateStatistics(List<Integer> numbers) {
    // 本地类
    class Statistics {
        private int sum;
        private int count;
        
        void add(int value) {
            sum += value;
            count++;
        }
        
        double average() {
            return count > 0 ? (double) sum / count : 0;
        }
    }
    
    Statistics stats = new Statistics();
    numbers.forEach(stats::add);
    System.out.println("平均值: " + stats.average());
}

2. 本地枚举类（Local Enum Classes）

Java 16 也支持在方法内部定义枚举：

public void processPayment(String paymentType) {
    // 本地枚举
    enum PaymentMethod {
        CREDIT_CARD, DEBIT_CARD, ALIPAY, WECHAT_PAY
    }
    
    PaymentMethod method = PaymentMethod.valueOf(paymentType.toUpperCase());
    System.out.println("处理支付方式: " + method);
}

3. 本地接口（Local Interfaces）

Java 16 引入，可以在方法内部定义接口：

public void validateData(List<String> data) {
    // 本地接口
    interface Validator {
        boolean isValid(String value);
    }
    
    Validator emailValidator = value -> value.contains("@");
    Validator lengthValidator = value -> value.length() > 5;
    
    [data.stream](<http://data.stream>)()
        .filter(emailValidator::isValid)
        .filter(lengthValidator::isValid)
        .forEach(System.out::println);
}

使用场景和优势

1. 限制作用域：这些类型只在方法内部可见，避免污染外部命名空间
2. 提高可读性：将临时数据结构定义在使用的地方，代码更清晰
3. 简化代码：特别是记录类，可以快速创建不可变数据载体
4. 更好的封装：实现细节完全隐藏在方法内部

这些特性让 Java 的表达能力更强，特别适合处理复杂的数据转换和临时数据结构。