Java修炼终极指南:92. 引入instanceof的记录模式

为了引入记录模式，我们需要一个记录，所以这里是一个：

public record Doctor(String name, String specialty)
  implements Staff {}

这个记录实现了Staff接口，就像我们医院的其他员工一样。现在，我们可以通过以下方式通过instanceof以老式风格识别某位医生：

public static String cabinet(Staff staff) {
  if (staff instanceof Doctor) {
    Doctor dr = (Doctor) staff;
    return "Cabinet of " + dr.specialty()
      + ". Doctor: " + dr.name();
  }
  ...
}

但是，正如我们在第2章，问题x-y中所知，JDK引入了可用于instanceof和switch的类型模式。因此，在这种特定情况下，我们可以通过类型模式重写前面的代码，如下所示：

public static String cabinet(Staff staff) {
       
  if (staff instanceof Doctor dr) { // 类型模式匹配
    return "Cabinet of " + dr.specialty()
       + ". Doctor: " + dr.name();
  }
  ...
}

到目前为止没有什么新东西！绑定变量dr可以用来调用记录访问器specialty()和name()，添加检查，计算等。但是，编译器非常清楚地知道Doctor记录是基于两个组件（name和specialty）构建的，所以编译器应该能够解构这个对象，并直接给我们这些组件作为绑定变量，而不是通过dr访问它们。这正是记录模式匹配的全部内容。记录模式匹配作为预览特性在JDK 19（JEP 405）中引入，并在JDK 20（JEP 432）中作为第二个预览特性引入。

记录模式匹配正是按照记录本身的相同声明语法（或像在规范构造函数中一样）将name和specialty声明为绑定变量的语法。这是通过记录模式重写的先前代码：

public static String cabinet(Staff staff) {          
  // 记录模式匹配
  if (staff instanceof Doctor(String name, String specialty)){     
      return "Cabinet of " + name + ". Doctor: " + specialty;
  }
  ...
}

非常简单，不是吗？现在，name和specialty是可以直接使用的绑定变量。我们简单地将这个语法放在类型模式的位置。换句话说，我们将类型模式替换为记录模式。

编译器通过相应的绑定变量公开记录的组件。这是通过在模式匹配中解构记录来实现的，这被称为记录模式。换句话说，解构模式允许我们以非常方便、直观和易于阅读的方式访问对象的组件。

当然，如果你需要dr绑定变量（即记录本身的引用）在name和specialty绑定变量旁边，那么可以像下面这样简单地添加：

public static String cabinet(Staff staff) {          
  if (staff instanceof
    Doctor(String name, String specialty) dr) {
      return "Cabinet of " + specialty + ". Doctor ID: "
        + dr.hashCode() + " (" + name + ")";
  }
  ...
}

这真的很酷！

在记录模式中，编译器有责任初始化name和specialty等绑定变量。为了完成这项工作，编译器调用相应组件的访问器。这意味着，如果你在这些访问器中有一些额外的代码（例如，返回防御性副本，执行验证或应用约束等），那么这个代码将被正确执行。

让我们进一步处理一些嵌套记录。

嵌套记录和记录模式

假设除了Doctor记录外，我们还有以下记录：

public record Resident(String name, Doctor doctor)
  implements Staff {}

每个住院医师都有一个协调员，即医生，所以Resident嵌套了一个Doctor。这次，我们必须相应地嵌套记录模式，如下所示：

public static String cabinet(Staff staff) {   
      
  if (staff instanceof Resident(String rsname,
      Doctor(String drname, String specialty))) {            
    return "Cabinet of " + specialty + ". Doctor: "
                         + drname + ", Resident: " + rsname;
  } 
...
}

住院医师和医生都有name组件。但是，我们不能在这个上下文中两次使用绑定变量name，因为这会导致冲突。这就是为什么我们有rsname和drname。请注意，绑定变量的名称不需要反映组件的名称。这是可能的，因为编译器通过位置而不是通过它们的名称来识别组件。但是，当然，如果可能的话，反映名称可以减少混乱并保持代码的高可读性。如果不需要解构Doctor记录，我们可以这样写：

if (staff instanceof Resident(String name, Doctor dr)) {
  return "Cabinet of " + dr.specialty() + ". Doctor: "
                       + dr.name() + ", Resident: " + name;
}

或者，如果你需要完全解构组件并引用记录，那么可以这样写：

if (staff instanceof Resident(String rsname,
  Doctor(String drname, String specialty) dr) rs) {
    return "Cabinet of " + dr.specialty() + ". Doctor: "
            + dr.name() + ", Resident: " + rs.name();
}

添加更多嵌套记录遵循相同的原则。例如，让我们也添加Patient和Appointment记录：

public record Appointment(LocalDate date, Doctor doctor) {}
public record Patient(
  String name, int npi, Appointment appointment) {}

现在，我们可以写出以下美妙的代码：

public static String reception(Object o) {
  if (o instanceof Patient(var ptname, var npi,
                  Appointment(var date,
                  Doctor (var drname, var specialty)))) {
       
   return "Patient " + ptname + " (NPI: " + npi
          + ") has an appointment at "
          + date + " to the doctor " + drname
          + " (" + specialty + ").";
  }
…
}

这次我们使用了var而不是显式类型。在这种情况下，你可以自由地这样做，因为var非常适合。如果你不熟悉类型推断，那么考虑《Java编码问题》，第一版，第4章类型推断，其中包含详细的解释和最佳实践。当然，也支持使用显式类型。在这里，我们还为引用记录添加了绑定变量：

if (o instanceof Patient(String ptname, int npi,
        Appointment(LocalDate date,
        Doctor (String drname, String specialty) dr) ap) pt) {
       
  return "Patient " + pt.name() + " (NPI: " + pt.npi()
     + ") has an appointment at "
     + ap.date() + " to the doctor " + dr.name() + " ("
     + dr.specialty() + ").";
}

我认为你已经明白了！