What are the requirements on a data class's primary constructor, and why won't `data class Empty()` compile?
answer
- At least one primary-constructor param
- Every param must be val or var
- data class Empty() does not compile
- Bare param (no val/var) is a compile error
- Body properties are excluded from generated members
basics
~20 sA data class must declare a primary constructor with at least one parameter, and every parameter must be marked val or var. An empty parameter list, or a plain parameter without val/var, is a compile error.
solid answer
~40 sThe Kotlin compiler enforces two rules on a data class primary constructor: (1) it must have at least one parameter, and (2) every primary-constructor parameter must be marked `val` or `var` so it becomes a property. `data class Empty()` fails because there are zero parameters, so the compiler cannot generate meaningful `equals`/`hashCode`/`toString`/`componentN`/`copy`. Likewise `data class P(x: Int)` fails because `x` is a constructor parameter, not a property — you must write `data class P(val x: Int)`. These rules exist because the generated members operate over the constructor properties; with no properties there is nothing to compare, hash, or destructure. Secondary constructors and an explicit body are still allowed, but they cannot satisfy the at-least-one-property requirement.
code
kotlin · 8 linesdata class Empty() // compile error: needs >= 1 param
data class Bad(x: Int) // compile error: x must be val/var
data class Good(val x: Int) // OK
val a = Good(1)
val b = Good(1)
println(a == b) // true (value equality)
println(a.copy(x = 2)) // Good(x=2)go deeper
Knows a data class needs at least one val/var parameter and can fix the compile error.
Explains why the rules exist (generated members need properties) and that body properties are excluded.
Connects the constraint to equals/hashCode/copy/componentN semantics and discusses the body-vs-constructor property distinction precisely.
Frames the constraints as compiler-enforced invariants protecting value-semantics contracts, and reasons about API design implications when modeling value objects.
## What a data class is A `data class` is a class whose primary purpose is to hold data. The `data` keyword tells the Kotlin compiler to auto-generate `equals()`, `hashCode()`, `toString()`, `componentN()` functions (for destructuring), and `copy()` based on the properties declared in the **primary constructor**. ## The primary constructor The primary constructor is the parameter list written right after the class name: `class Point(val x: Int, val y: Int)`. A parameter prefixed with `val` (read-only) or `var` (mutable) is not just a constructor argument — it is automatically declared as a **property** (a field with a getter, and for `var` also a setter). ## Constraint 1 — at least one parameter The primary constructor must declare **at least one** parameter: ```kotlin data class Empty() // ERROR: Data class must have at least one primary constructor parameter data class User(val id: Int) // OK ``` Without properties, the generated members are meaningless (every instance would be equal, hash identically, and have nothing to destructure), so the compiler rejects it. ## Constraint 2 — every primary-constructor parameter must be val or var Each parameter in the primary constructor must be marked `val` or `var`: ```kotlin data class P(x: Int) // ERROR: Data class primary constructor parameters must be 'val' or 'var' data class P(val x: Int) // OK ``` A bare parameter (`x: Int`) is only visible inside `init` blocks and property initializers, not a property — so it cannot participate in the generated members. ## What is still allowed - A class **body** with extra members, methods, secondary constructors. - Properties declared **in the body** (not the constructor) — but these are **excluded** from `equals`/`hashCode`/`toString`/`copy`/`componentN`. ```kotlin data class User(val id: Int) { var lastSeen: Long = 0 // NOT part of equals/hashCode/copy } ``` ## Mnemonic summary - Need ≥1 primary-constructor parameter. - Each such parameter must be `val`/`var`. - Body properties are legal but ignored by generated members.
- Can a data class have additional properties declared in its body?Yes, but they are excluded from the generated equals, hashCode, toString, copy, and componentN; only primary-constructor properties participate.
- Does a data class with one val parameter still get all generated members?Yes — one property is enough; you get equals, hashCode, toString, component1, and copy.
A data class is like a labeled box: it needs at least one labeled compartment (a val/var property), or there is nothing to compare or copy.
saying these in an interview costs you the question
- Claiming a data class can have zero parameters
- Thinking a bare parameter (no val/var) is fine in a data class
- Believing body-declared properties affect equals/hashCode
- Saying the rule is about secondary constructors, not the primary one
- Confusing 'parameter' with 'property' and assuming all params auto-become properties without val/var