Java 21 OCP · Objective: Records and Sealed classes · Attempt 2

Records & Sealed Classes: second go

I retook the 8-question Enthuware test on 2 Nov 2026. Three of my attempt 1 misses are now fixed and three new rules caught me out. This page drills only those three rules, with new original questions. Every code sample was compiled and run on JDK 21.

Attempt 2 scorecard
The three rules
What I got wrong
My progress
1 · Both sides of permits
2 · What sealed really means
3 · Implicit record properties
4 · True or false
Timed mock

Attempt 2 scorecard

#	Rule tested	Result	vs attempt 1
1	A permitted subtype must itself extend or implement the sealed type	✗	New miss → block 1
2	Generic record patterns, no diamond, flow scope after `\|\|`	✓	Fixed
3	Members a record gets automatically	✓	New, right first time
4	"Sealed" doesn't mean "can't be extended"; what can be sealed	✗	Repeat weak spot → block 2
5	Records are final, nested records are static, and immutability is shallow	✗	New miss → block 3
6	Compact plus normal canonical constructor is a duplicate	✓	Fixed
7	not recorded yet	–
8	A record can have any number of overloaded constructors	✓	Fixed

Recorded so far: 4 / 7. All three misses are about what the modifiers sealed, non-sealed and final actually mean, and records are part of that.

The three rules

1 · A sealed relationship is declared on both sides

The parent says permits X, and X must say extends/implements the parent. permits is a whitelist. It doesn't create the subtype relationship.
If a type in permits doesn't extend or implement the parent, the error invalid permits clause is reported on the parent.
A permitted class must be final, sealed or non-sealed. A permitted interface must be sealed or non-sealed, because an interface can't be final. A record is already final.
non-sealed is only allowed on a type whose direct supertype is sealed. sealed can go anywhere, including on a root class that extends only Object.
A type that isn't in permits can't name the sealed type in its own extends/implements, even if it already inherits it through a non-sealed class.
permits without sealed is an error.

2 · Sealed means "restricted", not "closed"

final: no subclasses. sealed: only the permitted ones, and there must be at least one. non-sealed: anyone can extend it again.
A sealed class can be concrete and instantiated. It isn't implicitly abstract, and it isn't final.
Only classes and interfaces can be marked sealed. That excludes records, enums and annotation interfaces. Records and enums can still implement a sealed interface.
An enum is implicitly sealed if any constant has a body, and implicitly final otherwise.
Local and anonymous classes can't extend a sealed type.
With no permits clause, the permitted subtypes are the ones declared in the same file.

3 · What a record is implicitly

final, so it's never sealed, non-sealed or abstract. Writing final record is redundant but legal.
static when nested (member and local). It can't touch the outer class's instance fields or the enclosing method's local variables. static is allowed on a member record but not on a local one.
Shallowly immutable. The component fields are final, but a List, array or StringBuilder component can still be changed. For a deep copy, use items = List.copyOf(items); in a compact constructor.
There's no limit on the number of instances. Equal values give separate objects: == is false and equals is true. Limiting instances is what enums do.

What I got wrong this time

Attempt 2 · Q1 · Permits clause

A permitted class that never said `implements`

I thought being listed in permits made the class a subtype. It doesn't, so non-sealed class Result { } failed twice: the parent's permits clause was invalid, and non-sealed had no sealed parent to reopen.

Hook: the parent permits it, and the child must still implements/extends the parent.

Attempt 2 · Q4 · What sealed means

"A sealed class cannot be extended" sounded true

It's false. A sealed class must be extended, but only by the types it permits. The answer was "none of the above", because the other options were also false: interfaces can be sealed, and records and enums can't be.

Hook: final = nobody · sealed = only the listed types · non-sealed = anyone again.

Attempt 2 · Q5 · Record properties

Which three things are records implicitly?

Final, static when nested, and immutable (shallowly). They're not sealed, because a final type has no subtypes. They're also not about limiting the number of instances.

Hook: records are Final, Static when nested, and Shallow: "FSS", never sealed.

Fixed since attempt 1

Generic record patterns · duplicate canonical constructors · any number of overloads

All three were right this time. They're still covered by blocks 2 and 5 on the attempt 1 page.

My drill progress on this page

Work through blocks 1–4, then sit the timed mock. Reload the page to reshuffle. Aim for full marks on each block before you try the mock.

Drill block	Qs	Last	Best	Runs	Last done
Loading…

1 · Both sides of permits Q1

2 · What sealed really means Q4

3 · Implicit record properties Q5

4 · True or false (quick-fire)

Each statement on its own. This is the "give each option a yes or no" habit, which would have saved Q4 and Q5.

Timed mock

20 questions drawn at random from all the blocks above, with fresh question and option order every time. There's no feedback until you submit. You get 40 minutes, and the pass mark is 68%.

← All topics · Attempt 1 page