Data classes in Kotlin
Just to add one more difference that Eric's accepted answer doesn't mention.
Data Classes can participate in destructuring declarations.
So if we have
class Person(val name: String, val age: Int)
data class Person2(val name: String, val age: Int)
And then
fun main() {
val person = Person("Kal", 34); //normal class instance
val person2 = Person2("Kal", 34); //data class instance
val (name, age) = person; //This does not compile and shows error
//Destructuring declaration initializer of type Employee must have a 'component1()' function
//Destructuring declaration initializer of type Employee must have a 'component2()' function
val (name2, age2) = person2; //no problem here
}
Briefly speaking:
- Definition 1: this is a data class which primary constructor takes two parameters
name
andage
- Definition 2: this is just a class which primary constructor takes two parameters
name
andage
- Definition 3: this is a class which constructor has no arguments and assigns default values
""
and1
to the propertiesname
andage
respectively
Detailed answered
What is important to understand here is the concept of data class.
Data Class
It is very common to create classes whose main purpose is to hold data. If you want your class to be convenient holder for your data you need to override the universal object methods:
toString()
- string representationequals()
- object equalityhashCode()
- hash containers
Note: equals()
is used for structural equality and it is often implemented with hashCode()
.
Usually, the implementation of these methods is straightforward, and your IDE can help you to generate them automatically.
However, in Kotlin, you don't have to general all of these boilerplate code. If you add the modifier data
to your class, the necessary methods are automatically added for you. The equals()
and hashCode()
methods take into account all the properties declared in the primary constructor. toString()
will have the following format ClassName(parm1=value1, param2=value2, ...)
.
In addition, when you mark a class as a data class, the method copy()
is also automatically generated which allows you to make copies of an existing instance. This feature is very handy when you are using your instances as keys for a HashMap
or if you are dealing with multithreaded code.
Going back to your question:
- Definition 1: you do not need to implement the universal object methods and you have also the
copy()
method ready to use - Definition 2: you will have to implement the universal object methods and the
copy()
method if you need them - Definition 3: you will have to implement the universal object methods and the
copy()
method if you need them, and there is no point in implementing thecopy()
method since your primary constructor has no parameters
Even though the properties of a data class are not required to be val
, i.e., you can use var
as your are doing in your code, it is strongly recommended that you use read-only properties, so that you make the instances immutable.
Finally, componentN()
functions corresponding to the properties in their order of declaration are also generated by the compiler when you mark a class as a data class.
Difference in equals
, hashCode
, & toString
the most important difference between definition 1 and definitions 2 & 3 is that in definition 1, the equals
, hashcode
and toString
methods are overridden for you:
equals
andhashCode
methods test for structural equalitytoString
method returns a nice, human-friendly string
Code example:
NOTE: in Kotlin, the ==
operator calls an object's .equals()
method. see operator overloading on kotlinlang.org for more info.
data class Person1 (var name:String, var age:Int)
class Person2 (var name:String, var age:Int)
@Test fun test1()
{
val alice1 = Person1("Alice", 22)
val alice2 = Person1("Alice", 22)
val bob = Person1("bob", 23)
// alice1 and alice2 are structurally equal, so this returns true.
println(alice1 == alice2) // true
// alice1 and bob are NOT structurally equal, so this returns false.
println(alice1 == bob) // false
// the toString method for data classes are generated for you.
println(alice1) // Person1(name=Alice, age=22)
}
@Test fun test2()
{
val alice1 = Person2("Alice", 22)
val alice2 = Person2("Alice", 22)
val bob = Person2("bob", 23)
// even though alice1 and alice2 are structurally equal, this returns false.
println(alice1 == alice2) // false
println(alice1 == bob) // false
// the toString method for normal classes are NOT generated for you.
println(alice1) // Person2@1ed6993a
}
Difference in constructors
another difference between definitions 1 & 2 and definition 3 is that:
- definitions 1 & 2 both have a constructor that takes 2 parameters
- definition 3 only has a no argument constructor that assigns default values to the class members.
Code example:
data class Person1 (var name:String, var age:Int)
class Person2 (var name:String, var age:Int)
class Person3 ()
{
var name:String = ""
var age:Int = 1
}
@Test fun test3()
{
Person1("alice",22) // OK
Person2("bob",23) // OK
Person3("charlie",22) // error
Person1() // error
Person2() // error
Person3() // OK
}
The copy
method
Finally, another difference between definition 1 and definitions 2 & 3 is that in definition 1, a copy
method is generated for it. Here's an example of how it can be used:
val jack = Person1("Jack", 1)
val olderJack = jack.copy(age = 2)
// jack.age = 1
// olderJack.age = 2
Check out the official documentation for data classes on kotlinlang.org!