Class in Kotlin

Kotlin is a modern, expressive, and powerful programming language widely used for Android development, backend services, and cross-platform applications. One of the most fundamental concepts in Kotlin is the class. Understanding how a Kotlin class works is essential for mastering Kotlin OOP (Object-Oriented Programming).

This article provides a lengthy, detailed, and beginner-friendly explanation of classes in Kotlin, including constructors, properties, methods, inheritance, real-world use cases, and best practices. By the end, you will confidently create and use Kotlin classes in real projects.

What Is a Class in Kotlin?

A class in Kotlin is a blueprint used to create objects. It defines:

• Properties (data or state)
• Functions (behavior)
• Initialization logic

In Kotlin object-oriented programming, classes help organize code, improve reusability, and model real-world entities such as users, products, or vehicles.

Why Use Classes in Kotlin?

Classes are central to Kotlin development because they:

• Encapsulate data and behavior together
• Promote clean and maintainable code
• Support inheritance and polymorphism
• Enable real-world problem modeling

Basic Syntax of a Kotlin Class

A simple Kotlin class can be defined using the

class keyword.

📄

class Person {
    var name: String = "Unknown"
    var age: Int = 0
}

Explanation

• Person is the class name
• name and age are properties
• Properties have default values

Creating an Object

📄

val person = Person()
person.name = "John"
person.age = 25

Primary Constructor in Kotlin Class

A Kotlin primary constructor is part of the class header and allows you to initialize properties concisely.

📄

class Person(val name: String, var age: Int)

Key Features of Primary Constructors

• Defined in the class declaration
• Can declare properties directly
• Reduces boilerplate code

Using the Class

📄

val person = Person("Alice", 30)
println(person.name)
println(person.age)

Secondary Constructor in Kotlin

A secondary constructor in Kotlin is useful when multiple initialization options are needed.

📄

class Person {
    var name: String
    var age: Int

    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
    }

    constructor(name: String) {
        this.name = name
        this.age = 18
    }
}

When to Use Secondary Constructors

• When different ways of creating objects are required
• When default values vary based on input

Properties and Methods in Kotlin Class

📄

class Car(val brand: String, var speed: Int) {

    fun accelerate() {
        speed += 10
    }

    fun displayInfo() {
        println("Brand: $brand, Speed: $speed km/h")
    }
}

Explanation

• brand and speed are properties
• accelerate and displayInfo are methods

Inheritance in Kotlin Classes

📄

open class Animal {
    fun eat() {
        println("Eating food")
    }
}

class Dog : Animal() {
    fun bark() {
        println("Barking")
    }
}

Important Rules of Kotlin Inheritance

• Classes are final by default
• Use the open keyword to allow inheritance
• Use the colon symbol to inherit

Real-World Example of Kotlin Class

Bank Account Use Case

📄

class BankAccount(val accountHolder: String) {
    private var balance: Double = 0.0

    fun deposit(amount: Double) {
        balance += amount
    }

    fun withdraw(amount: Double) {
        if (amount <= balance) {
            balance -= amount
        }
    }

    fun getBalance(): Double {
        return balance
    }
}

Why This Example Matters

• Demonstrates encapsulation
• Uses real-world logic
• Common in Android and backend applications

Kotlin Class vs Data Class

Feature	Class	Data Class
Purpose	General behavior	Data storage
equals and toString	Manual	Auto-generated
Use Case	Business logic	DTOs and models

Encapsulate Data in Kotlin: A Complete Guide

Encapsulation is one of the core principles of object-oriented programming (OOP) and is widely used in Kotlin. It allows you to restrict direct access to the properties of a class and control how data is accessed or modified.

What Does Encapsulate Data Mean in Kotlin?

To encapsulate data means to keep the internal state of an object private and provide controlled access using getter and setter methods. This ensures data integrity, protects sensitive information, and makes code more maintainable.

Key Benefits of Data Encapsulation

• Protects data from unauthorized access
• Allows validation before data modification
• Improves maintainability and readability
• Supports OOP principles like abstraction and modularity

How to Encapsulate Data in Kotlin

In Kotlin, encapsulation is typically done using private properties along with getter and setter methods. Let's look at a practical example:

📄

class User {
    private var name: String = "Unknown"
    private var age: Int = 0

    // Getter for name
    fun getName(): String {
        return name
    }

    // Setter for name
    fun setName(newName: String) {
        if (newName.isNotEmpty()) {
            name = newName
        }
    }

    // Getter for age
    fun getAge(): Int {
        return age
    }

    // Setter for age
    fun setAge(newAge: Int) {
        if (newAge > 0) {
            age = newAge
        }
    }
}

Using the Encapsulated Class

📄

fun main() {
    val user = User()
    
    user.setName("Alice")
    user.setAge(25)
    
    println("Name: ${user.getName()}")
    println("Age: ${user.getAge()}")
}

Explanation

• The name and age properties are private, meaning they cannot be accessed directly from outside the class.
• We use getter and setter methods to control access and validate values.
• This ensures that invalid data cannot be assigned, maintaining the integrity of the object.

Kotlin Encapsulation with Property Accessors

Kotlin provides a more concise way to encapsulate data using custom property accessors:

📄

class Employee {
    var salary: Double = 0.0
        get() = field
        set(value) {
            if (value >= 0) field = value
        }
}

Using the Property Accessors

📄

fun main() {
    val emp = Employee()
    emp.salary = 5000.0   // Valid assignment
    emp.salary = -1000.0  // Ignored due to validation
    println(emp.salary)   // Output: 5000.0
}

📄

class BankAccount(private var balance: Double = 0.0) {

    fun deposit(amount: Double) {
        if (amount > 0) balance += amount
    }

    fun withdraw(amount: Double) {
        if (amount > 0 && amount <= balance) {
            balance -= amount
        }
    }

    fun getBalance(): Double {
        return balance
    }
}

Using the BankAccount Class

📄

fun main() {
    val account = BankAccount()
    
    account.deposit(1000.0)
    account.withdraw(500.0)
    
    println("Balance: ${account.getBalance()}")  // Output: Balance: 500.0
}

• Always keep properties private by default.
• Use getters and setters or property accessors to control data.
• Validate data inside setters before updating the property.
• Keep classes focused and small for maintainability.
• Encapsulation improves modularity and security in your Kotlin apps.

Encapsulating data in Kotlin is a fundamental OOP practice that ensures data security, integrity, and maintainability. Using private properties and controlled access through getters and setters makes your Kotlin code robust and easier to maintain, whether you're building Android apps, backend services, or any Kotlin project.

Understanding the class in Kotlin is a crucial step toward mastering Kotlin object-oriented programming. From basic syntax to constructors, properties, inheritance, and real-world examples, Kotlin classes offer flexibility and clarity for modern software development. By following best practices and applying these concepts, you can write clean, maintainable, and scalable Kotlin code.

Frequently Asked Questions (FAQs)

1. What is a class in Kotlin?

A class in Kotlin is a blueprint that defines properties and functions used to create objects. It represents real-world entities and supports object-oriented programming principles.

2. What is the difference between primary and secondary constructors in Kotlin?

The primary constructor is part of the class header and is concise, while secondary constructors provide alternative ways to initialize a class with different parameters.

3. Are Kotlin classes final by default?

Yes, Kotlin classes are final by default. To allow inheritance, you must mark a class as open.

4. When should I use a Kotlin data class instead of a regular class?

Use a data class when the main purpose is to hold data. Regular classes are better for implementing complex business logic.

5. Can Kotlin classes be used in Android development?

Absolutely. Kotlin classes are widely used in Android for activities, view models, repositories, and data models.