Reassigning components
Via an explicit canonical/compact constructor we can reassign components. For instance, when we create a MelonRecord we provide its type (for instance, Cantaloupe) and its weight in grams (for instance, 2600 grams). But, if we want to use weight in kilograms (2600 g = 2.6 kg) then we can provide this conversion in an explicit canonical constructor as follows:
// explicit canonical constructor for reassigning components
public MelonRecord(String type, float weight) {
weight = weight/1_000; // overwriting the component ‘weight’
this.type = type;
this.weight = weight;
}
As you can see, the weight component is available and reassigned before the weight field is initialized with the new reassigned value. In the end, the weight component and the weight field have the same value (2.6 kg). How about this snippet of code?
public MelonRecord(String type, float weight) {
this.type = type;
this.weight = weight/1_000;
}
Well, in this case, in the end, the weight field and the weight component will have different values. The weight field is 2.6 kg, while the weight component is 2600 g. Pay attention that most probably this is not what you want. Let’s check another snippet:
public MelonRecord(String type, float weight) {
this.type = type;
this.weight = weight;
weight = weight/1_000;
}
Again, in the end, the weight field and the weight component will have different values. The weight field is 2600 g, while the weight component is 2.6 kg. And again, pay attention, most probably this is not what you want.Of course, the cleaner and most simple approach relies on the compact constructor. This time, we cannot sneak accidental reassignments:
public record MelonRecord(String type, float weight) {
// explicit compact constructor for reassigning components
public MelonRecord {
weight = weight/1_000; // overwriting the component ‘weight’
}
}
Finally, let’s tackle the third scenario.
Defensive copies of the given components
We know that a Java record is immutable. But this doesn’t mean that its components are immutable as well. Think of components such as arrays, lists, maps, dates, and so on. All these components are mutable. In order to restore total immutability, you’ll prefer to work on copies of these components rather than modify the given components. And, as you already have intuited, this can be done via the explicit canonical constructor.For instance, let’s consider the following record that gets a single component representing the retail prices for a set of items as a Map:
public record MarketRecord(Map<String, Integer> retails) {}
This record shouldn’t modify this Map, so it relies on an explicit canonical constructor for creating a defensive copy that will be used in subsequent tasks without any risks of modification (Map.copyOf() returns an unmodifiable copy of the given Map):
public record MarketRecord(Map<String, Integer> retails) {
public MarketRecord {
retails = Map.copyOf(retails);
}
}
Basically, this is just a flavor of components reassignment.Moreover, we can return defensive copies via the accessor methods:
public Map<String, Integer> retails() {
return Map.copyOf(retails);
}
// or, getter in Java Bean style
public Map<String, Integer> getRetails() {
return Map.copyOf(retails);
}
You can practice all these examples in the bundled code.