[akavi]

You can get strongly typed "shaped" data without objects[0], even in Java: Records[1].

~Unfortunately, I believe they're mutable (and cannot be made immutable).~ Edit: I was wrong, they're immutable.

[0]: I'm using "object" to mean "data bound to methods", since the concept of aggregate data in general long pre-date OOP (eg, C's structs)

[1]: https://docs.oracle.com/en/java/javase/17/language/records.h...

[taftster]

Java Records are immutable (by the most common definition). They don't have any means to update the record (via setters, etc.) after construction. That doesn't mean, for example, you can't store a reference to a mutable type (for example, a List or Map) in your record.

The frustration I have with Records is there is no good way to prevent direct construction of them. That is, the constructor is public, which prevents an easy way of enforcing an invariant during construction.

For example, let's say that you have a record with a Date type. There's no good way to prevent a user from creating the record with an invalid date, one that is out of a needed date range. Or maybe enforcing a field cannot be null or some combination of fields must meet requirements as a group.

The benefit I get from the classic Builder pattern is defeated with Records. I can't enforce checking of my fields before the construction of the record object itself. Presumably I would need to verify the object after construction, which is unfortunate.

[vips7L]

You can enforce some invariants during construction:

    record Point(int x, int y) {
        Point {
            if (x < 0) throw new IllegalArgumentException()
        }
    }

or if you want to assert something is not null:

    record Person(String name) {
        Person {
            requireNonNull(name);
        }
    }

[nogridbag]

I think records will be much more useful if https://openjdk.org/jeps/468 gets out of preview.

[elric]

> There's no good way to prevent a user from creating the record with an invalid date

That is factually incorrect.

You can do all of that validation in a record constructor, much like in a normal Java class constructor. There's a difference in syntax: you don't need to repeat the constructor arguments in parantheses, and don't have to perform the assignments yourself. These are tailored specifically for easy validation.

[tpmoney]

As mentioned by the other commenters, you should be able to run any validations or transformations on the data that you want in the canonical constructor, including re-assigning values (for example we've done defaults with `foo != null ? foo : new DefaultFoo()`). The only thing I think you can't do with a record is make the canonical constructor private and force users of your type to call factory methods that can return null instead of throwing an exception. You can provide those factory methods, but anyone can still call the constructor, so you have to do your hard checks in the constructor. On the other hand, no matter how many alternate constructors or factory methods you make, you're also guaranteed that every one of them eventually has to call the canonical constructor, so you don't need to spread your validation around either.

[akavi]

Can you make the Record class private to a module, and only export a static function that constructs them?

(I know very little about Java)

[kaba0]

To a degree, yes, that’s possible. But leaking a private type over module boundaries is bad form, so a better (though possibly over engineered solution) would be to have a separate public interface, implemented by the private record type, and the static function would have that interface as return type.

[enugu]

Why is it bad form to expose a record type only via custom functions and not its field accessors? Isn't this just like exposing a more usual object with its public functions and private functions remain inaccessible?

[snmx999]

You can create dedicated, already verified objects to pass on to your record. E.g. AllowedDate (extends Date).

[bedatadriven]

A record's fields are final, so records are immutable (though they can include immutable pointers to mutable objects)