Java修炼终极指南:84. 引入记录的规范和紧凑构造函数

在上一个问题中，我们创建了MelonRecord Java记录，并通过以下代码实例化它：

MelonRecord melonr = new MelonRecord("Cantaloupe", 2600);

这怎么可能（因为我们在MelonRecord中没有写任何参数化构造函数）？编译器只是按照其内部协议为Java记录创建了一个基于我们在记录声明中提供的组件的默认构造函数（在这种情况下，有两个组件，type和weight）。这个构造函数被称为规范构造函数，它总是与给定的组件对齐。每个记录都有一个规范构造函数，这是创建该记录实例的唯一方式。但是，我们可以重新定义规范构造函数。下面是一个类似于默认构造函数的显式规范构造函数 - 如你所看到的，规范构造函数只是接受所有给定的组件并将相应的实例字段设置为（也由编译器生成为私有final字段）：

public MelonRecord(String type, float weight) {
            
  this.type = type;
  this.weight = weight;
}

一旦实例被创建，它就不能被改变（它是不可变的）。它将唯一的目的在你的程序中携带这些数据。这个显式的规范构造函数有一个快捷方式，称为紧凑构造函数 - 这是Java记录特有的。由于编译器知道给定组件的列表，它可以从这个紧凑构造函数完成其工作，这个构造函数等同于前一个构造函数：

public MelonRecord {}

请注意，不要将这个紧凑构造函数与不带参数的构造函数混淆。以下代码片段是不等价的：

public MelonRecord {}   // 紧凑构造函数
public MelonRecord() {} // 无参数构造函数

当然，没有意义去写一个显式的规范构造函数，只是为了模仿默认构造函数的作用。因此，让我们检查几个重新定义规范构造函数有意义的场景。

处理验证

在这个时候，当我们创建一个MelonRecord时，我们可以将类型传递为null，或者将甜瓜的重量作为负数。这导致了包含非有效数据的损坏记录。可以在显式的规范构造函数中处理记录组件的验证，如下所示：

public record MelonRecord(String type, float weight) {
  // 用于验证的显式规范构造函数
  public MelonRecord(String type, int weight) {
    if (type == null) {
      throw new IllegalArgumentException(
        "The melon's type cannot be null");
    }
    if (weight < 1000 || weight > 10000) {
      throw new IllegalArgumentException("The melon's weight
         must be between 1000 and 10000 grams");
    }
               
    this.type = type;
    this.weight = weight;
  }
}

或者，通过紧凑构造函数，如下所示：

public record MelonRecord(String type, float weight) {
  // 用于验证的显式紧凑构造函数
  public MelonRecord {
       
    if (type == null) {
      throw new IllegalArgumentException(
        "The melon's type cannot be null");
    }
    if (weight < 1000 || weight > 10000) {
      throw new IllegalArgumentException("The melon's weight
        must be between 1000 and 10000 grams");
    } 
  }
}

验证处理是显式规范/紧凑构造函数的最常见用例。接下来，让我们看看两个较少为人所知的用例。

重新分配组件

通过显式的规范/紧凑构造函数，我们可以重新分配组件。例如，当我们创建一个MelonRecord时，我们提供了它的类型（例如，Cantaloupe）和它的重量（例如，2600克）。但是，如果我们想使用重量单位为千克（2600克=2.6千克），那么我们可以在一个显式的规范构造函数中提供这种转换，如下所示：

// 用于重新分配组件的显式规范构造函数
public MelonRecord(String type, float weight) {
  weight = weight/1_000; // 覆盖组件 'weight'
       
  this.type = type;
  this.weight = weight;                                         
}

如你所看到的，weight组件是可用的，并在weight字段初始化为新分配的值之前重新分配。最后，weight组件和weight字段具有相同的值（2.6千克）。那么这段代码呢？

public MelonRecord(String type, float weight) {
  this.type = type;
  this.weight = weight/1_000;      
}

嗯，在这种情况下，最后weight字段和weight组件将有不同的值。weight字段是2.6千克，而weight组件是2600克。请注意，这很可能不是你想要做的。让我们检查另一段代码：

public MelonRecord(String type, float weight) {
       
  this.type = type;
  this.weight = weight;          
       
  weight = weight/1_000;
}

再次，最后weight字段和weight组件将有不同的值。weight字段是2600克，而weight组件是2.6千克。再次提醒，这很可能不是你想要做的。当然，更干净和最简单的方法是依赖紧凑构造函数。这一次，我们不能偷偷进行意外的重新分配：

public record MelonRecord(String type, float weight) {
  // 用于重新分配组件的显式紧凑构造函数
  public MelonRecord {
       
  weight = weight/1_000; // 覆盖组件 'weight'
  }
}

最后，让我们处理第三种情况。

给定组件的防御性副本

我们知道Java记录是不可变的。但这并不意味着它的组件也是不可变的。想想数组、列表、映射、日期等组件。所有这些组件都是可变的。为了恢复完全的不可变性，你将更喜欢在这些组件的副本上工作，而不是修改给定的组件。正如你已经直觉到的，这可以通过显式的规范构造函数完成。例如，让我们考虑以下记录，它获取一个表示一组项目的零售价格的单个组件作为Map：

public record MarketRecord(Map<String, Integer> retails) {}

这个记录不应该修改这个Map，所以它依赖于一个显式的规范构造函数来创建一个防御性副本，该副本将在后续任务中使用，没有任何修改的风险（Map.copyOf()返回给定Map的不可修改副本）：

public record MarketRecord(Map<String, Integer> retails) {
  public MarketRecord {
    retails = Map.copyOf(retails); 
  }
}

基本上，这只是组件重新分配的一种风味。此外，我们可以通过访问器方法返回防御性副本：

public Map<String, Integer> retails() {
  return Map.copyOf(retails);
}

// 或者，Java Bean风格的getter

public Map<String, Integer> getRetails() {
  return Map.copyOf(retails);
}