feat: new page for data classes by danil-pavlov · Pull Request #5885 · JetBrains/kotlin-web-site

Danil Pavlov (danil-pavlov) · 2026-10-23T18:02:10Z

No description provided.

Alejandro Serrano (serras) · 2026-10-27T08:38:54Z

-Data classes in Kotlin are primarily used to hold data. For each data class, the compiler automatically generates 
-additional member functions that allow you to print an instance to readable output, compare instances, copy instances, and more.
-Data classes are marked with `data`:
+A data class is a class whose main job is to hold data.


This feels really abstract to me. I would suggest to include references to things like "data-oriented programming".

Suggested change

A data class is a class whose main job is to hold data.

A data class is a kind of class optimized for holding data, as opposed to packing related behavior.

Thank you! added a reference to data-oriented programming

Alejandro Serrano (serras) · 2026-10-27T08:40:03Z

+* A parameter object that groups several related arguments.
+* A result that consists of more than one value.


Those examples are also quite abstract.

Suggested change

* A parameter object that groups several related arguments.

* A result that consists of more than one value.

* The description of a command or event in your system.

* A result with more than one value, like the quotient and remainder of a division.

Alejandro Serrano (serras) · 2026-10-27T08:42:32Z

+Compared to regular classes, where printing an instance shows just the class name and an identifier, and two instances
+are equal only if they are the same object, data classes benefit from [pre-generated functions](#generated-functions).
+They make it convenient to print an instance as readable text, compare two instances by their content, and copy an instance
+with some values changed.


Suggested change

Compared to regular classes, where printing an instance shows just the class name and an identifier, and two instances

are equal only if they are the same object, data classes benefit from [pre-generated functions](#generated-functions).

They make it convenient to print an instance as readable text, compare two instances by their content, and copy an instance

with some values changed.

The crucial different with regular classes is that an instance of a data class is in principle determined by the _data_ its holds, as opposed to the identity of the instance. This shows in the [pre-generated functions](#generated-functions): printing an instance of a data class shows all the primary properties, and equality ensures that two instances holding the same data are considered equal for all purposes.

Alejandro Serrano (serras) · 2026-10-27T08:43:08Z

 * The primary constructor must have at least one parameter.
 * All primary constructor parameters must be marked as `val` or `var`.
-* Data classes can't be abstract, open, sealed, or inner.
+* A data class can't be abstract, open, sealed, or inner, and it [can't be inherited from](#inheritance).


Isn't it much simpler to just say it's final?

Alejandro Serrano (serras) · 2026-10-27T08:44:40Z

+| [`hashCode()`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin/-any/hash-code.html) | Returns a hash code computed from the properties of the primary constructor, so that instances work as elements of a set and as keys in a map.   |
+| [`toString()`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin/-any/to-string.html) | Returns a string with the class name and the properties of the primary constructor, such as `User(name=John, age=42)`.                           |
+| [`copy()`](#copying)                                                                     | Returns a new instance with the same properties, except for the ones that you pass as arguments.                                                 |
+| [`componentN()`](destructuring-declarations.md)                                          | Returns the property at the given position, which makes [destructuring declarations](#destructuring) possible.                                   |


Note that with name-based destructuring this becomes way less important. It would be great if the documentation could hint this to users.

Let's add "positional" here and a proper note to the destructuring section

Alejandro Serrano (serras) · 2026-10-27T08:45:34Z

+Data classes have no other generated functions, and they inherit the rest of their members from
+[`Any`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin/-any/), the superclass of every Kotlin class.


Note that data classes may inherit from other interfaces or classes. This paragraph makes it sound as if they could not, and only get Any as a superclass. Personally, I would completely drop this paragraph.

Alejandro Serrano (serras) · 2026-10-27T08:46:32Z

 * All primary constructor parameters must be marked as `val` or `var`.
-* Data classes can't be abstract, open, sealed, or inner.
+* A data class can't be abstract, open, sealed, or inner, and it [can't be inherited from](#inheritance).
+* You can't provide explicit implementations of the [generated functions](#generated-functions) like `componentN()` and `copy()`.


This is not true, you can still provide custom equals, hashCode and toString

Alejandro Serrano (serras) · 2026-10-27T08:47:27Z

+
+### Destructuring
+
+The `componentN()` functions generated for data classes make it possible to use them in [destructuring declarations](destructuring-declarations.md).


As mentioned above, please include a note to name-based destructuring becoming the default soon.

Done, when name-based destructuring becomes default, we can rewrite this section and change the code sample

Alejandro Serrano (serras) · 2026-11-02T12:55:50Z

+
+| Member                                                                                   | Description                                                                                                                                      |
+|------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`equals()`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin/-any/equals.html)      | Returns `true` if the other instance is of the same type and all the properties of the primary constructor are equal. Used by the `==` operator. |


Nitpick: are () really required after the member name? I am a bit concerned that copy() is not really a no-argument function, so people may get confused.

Yeah, it's required by our guidelines, but I think the member description and the example right below cover the possible confusion

Alejandro Serrano (serras) · 2026-11-02T12:56:53Z

+
+#### Private properties
+
+A property of the primary constructor can be `private`. The compiler still uses it in the generated functions:


Suggested change

A property of the primary constructor can be `private`. The compiler still uses it in the generated functions:

A primary constructor property can be `private`. The compiler still uses it in the generated functions:

We tend to use that wording more often.

Alejandro Serrano (serras) · 2026-11-02T12:58:01Z

+{kotlin-runnable="true"}
+
+For this reason, prefer `List` over `Array` in data classes. If you have to store an array, for example, because an
+external API returns one, write `equals()`, `hashCode()`, and `toString()` yourself and compare the content explicitly:


Maybe hint that IntelliJ can write this for you?

Alejandro Serrano (serras) · 2026-11-02T12:58:39Z

+
+## Inheritance
+
+A data class is always `final`, so **you can't inherit from a data class**:


Suggested change

A data class is always `final`, so **you can't inherit from a data class**:

A data class is always `final`, so you can't inherit **from** a data class:

Alejandro Serrano (serras) · 2026-11-02T12:59:21Z

+The limitations are the following:
+
+* A data class can't be marked as `open`, `abstract`, `sealed`, or `inner`, so no other class can extend it.
+* A data class can't be the supertype of another class, not even of another data class.


Those are all implications of being final, but the text makes it sound as they are somehow different.

Danil Pavlov (danil-pavlov) added 3 commits October 9, 2026 14:01

feat: data classes revamp

ead7757

fix: anchor

ed35100

update: new version

fb3021b

Danil Pavlov (danil-pavlov) requested a review from a team as a code owner October 23, 2026 18:02

Alejandro Serrano (serras) requested changes Oct 27, 2026

View reviewed changes

fix: review suggestions

236be01

Danil Pavlov (danil-pavlov) requested a review from Alejandro Serrano (serras) October 30, 2026 15:06

Alejandro Serrano (serras) approved these changes Nov 2, 2026

View reviewed changes

fix: review suggestions

0e40821

	A data class is a class whose main job is to hold data.
	A data class is a kind of class optimized for holding data, as opposed to packing related behavior.

		* A parameter object that groups several related arguments.
		* A result that consists of more than one value.

		Data classes have no other generated functions, and they inherit the rest of their members from
		[`Any`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin/-any/), the superclass of every Kotlin class.


		### Destructuring

		The `componentN()` functions generated for data classes make it possible to use them in [destructuring declarations](destructuring-declarations.md).


		#### Private properties

		A property of the primary constructor can be `private`. The compiler still uses it in the generated functions:

	A property of the primary constructor can be `private`. The compiler still uses it in the generated functions:
	A primary constructor property can be `private`. The compiler still uses it in the generated functions:


		## Inheritance

		A data class is always `final`, so you can't inherit from a data class:

	A data class is always `final`, so you can't inherit from a data class:
	A data class is always `final`, so you can't inherit from a data class:

Conversation

Danil Pavlov (danil-pavlov) commented Oct 23, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Uh oh!

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants