A Beginner’s Guide to Kotlin Classes, Data Classes, and Constructors

April 2025
M	T	W	T	F	S	S
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30

A Beginner’s Guide to Kotlin Classes, Data Classes, and Constructors

Kotlin is a modern programming language that is concise, expressive, and designed to work seamlessly with Java. One of the core concepts in Kotlin, like most object-oriented programming (OOP) languages, is the use of classes and objects. Classes allow us to define the structure and behaviors of objects, while data classes add a specialized layer to store data efficiently.

In this post, we’ll explore how Kotlin handles classes, properties, member functions, data classes, and how you can work with constructors to create objects.

1. Kotlin Classes: Basics

In Kotlin, a class is a blueprint that defines the properties and behaviors of the objects created from it. To declare a class, we use the class keyword:

class Customer

1 2	class Customer

In the above example, we define a class called Customer. However, it doesn’t contain any properties or methods yet.

Properties in a Class

Properties define the characteristics of an object created from a class. You can declare properties in the class header (within parentheses), or inside the class body.

class Contact(val id: Int, var email: String)

1 2	class Contact(val id: Int, var email: String)

This class has two properties: id (which is read-only) and email (which can be modified).

Alternatively, you can declare properties inside the class body:

class Contact(val id: Int, var email: String) {
    val category: String = "work"
}

class Contact(val id: Int, var email: String) {

val category: String = "work"

}

Default Values for Properties

Kotlin allows you to assign default values to properties, making it more flexible:

class Contact(val id: Int, var email: String = "example@gmail.com") {
    val category: String = "work"
}

class Contact(val id: Int, var email: String = "example@gmail.com") {

val category: String = "work"

}

Creating Instances of a Class

To create an object (or instance) from a class, we use the constructor:

fun main() {
    val contact = Contact(1, "mary@gmail.com")
    println(contact.email)  // Output: mary@gmail.com
}

fun main() {

val contact = Contact(1, "mary@gmail.com")

println(contact.email) // Output: mary@gmail.com

}

Here, contact is an instance of the Contact class with properties initialized through the constructor.

2. Member Functions in Kotlin Classes

In addition to properties, classes can have member functions that define behaviors. These functions are declared within the class body:

class Contact(val id: Int, var email: String) {
    fun printId() {
        println(id)
    }
}

class Contact(val id: Int, var email: String) {

fun printId() {

println(id)

}

To call a member function, simply write the function name after the instance:

fun main() {
    val contact = Contact(1, "mary@gmail.com")
    contact.printId()  // Output: 1
}

fun main() {

val contact = Contact(1, "mary@gmail.com")

contact.printId() // Output: 1

}

You can also use string templates to access the properties of the class in a string:

println("Their email address is: ${contact.email}")

1 2	println("Their email address is: ${contact.email}")

3. Kotlin Data Classes

Kotlin has a special type of class known as data classes, designed specifically for storing data. These classes automatically come with useful member functions like toString(), equals(), and copy().

To declare a data class, use the data keyword:

data class User(val name: String, val id: Int)

1 2	data class User(val name: String, val id: Int)

Common Functions in Data Classes

toString(): Provides a human-readable representation of an instance.

val user = User("Alex", 1)
println(user)  // Output: User(name=Alex, id=1)

val user = User("Alex", 1)

println(user) // Output: User(name=Alex, id=1)

equals(): Compares two instances for equality.

val user2 = User("Alex", 1)
println(user == user2)  // Output: true

val user2 = User("Alex", 1)

println(user == user2) // Output: true

copy(): Creates a copy of an instance, optionally modifying some properties.

val userCopy = user.copy(id = 2)
println(userCopy)  // Output: User(name=Alex, id=2)

val userCopy = user.copy(id = 2)

println(userCopy) // Output: User(name=Alex, id=2)

4. Exercises to Practice Kotlin Classes

To solidify the understanding, here are some exercises to practice working with Kotlin classes and data classes:

Exercise 1: Employee Data Class

data class Employee(val name: String, var salary: Int)

fun main() {
    val emp = Employee("Mary", 20)
    println(emp)
    emp.salary += 10
    println(emp)
}

data class Employee(val name: String, var salary: Int)

fun main() {

val emp = Employee("Mary", 20)

println(emp)

emp.salary += 10

println(emp)

}

Exercise 2: Defining Additional Data Classes

data class Name(val first: String, val last: String)
data class Address(val street: String, val city: City)
data class City(val name: String, val countryCode: String)

data class Person(val name: Name, val address: Address, val ownsAPet: Boolean = true)

fun main() {
    val person = Person(Name("John", "Smith"), Address("123 Fake Street", City("Springfield", "US")), ownsAPet = false)
}

data class Name(val first: String, val last: String)

data class Address(val street: String, val city: City)

data class City(val name: String, val countryCode: String)

data class Person(val name: Name, val address: Address, val ownsAPet: Boolean = true)

fun main() {

val person = Person(Name("John", "Smith"), Address("123 Fake Street", City("Springfield", "US")), ownsAPet = false)

}

Exercise 3: Random Employee Generator

import kotlin.random.Random

data class Employee(val name: String, var salary: Int)

class RandomEmployeeGenerator(var minSalary: Int, var maxSalary: Int) {
    val names = listOf("John", "Mary", "Ann", "Paul", "Jack", "Elizabeth")
    
    fun generateEmployee(): Employee {
        val name = names.random()
        val salary = Random.nextInt(from = minSalary, until = maxSalary)
        return Employee(name, salary)
    }
}

fun main() {
    val empGen = RandomEmployeeGenerator(10, 30)
    println(empGen.generateEmployee())
    println(empGen.generateEmployee())
    println(empGen.generateEmployee())
}

import kotlin.random.Random

data class Employee(val name: String, var salary: Int)

class RandomEmployeeGenerator(var minSalary: Int, var maxSalary: Int) {

val names = listOf("John", "Mary", "Ann", "Paul", "Jack", "Elizabeth")

fun generateEmployee(): Employee {

val name = names.random()

val salary = Random.nextInt(from = minSalary, until = maxSalary)

return Employee(name, salary)

}

fun main() {

val empGen = RandomEmployeeGenerator(10, 30)

println(empGen.generateEmployee())

}

Conclusion

Kotlin offers powerful tools for object-oriented programming, making it easier to create classes, store data in objects, and work with member functions. By using classes, data classes, and constructors effectively, you can write more concise and maintainable code. With this foundation, you’re well on your way to mastering Kotlin and applying it in real-world applications.

Happy coding!