Encapsulation in Kotlin

Encapsulation is one of the four fundamental principles of Object-Oriented Programming (OOP). It means bundling data (variables) and methods (functions) that operate on that data within a single unit — a class. In Kotlin, encapsulation is achieved mainly using access modifiers such as private, protected, and public, which control visibility and safeguard the internal state of objects.

1. Why Encapsulation Matters

• Data Protection: Prevents external code from directly modifying sensitive data.
• Controlled Access: Provides controlled exposure through getters, setters, or methods.
• Modularity: Keeps related data and behavior together inside a class, improving maintainability.
• Code Safety: Prevents unintended side effects by hiding implementation details.

2. What is Encapsulation?

Encapsulation hides the internal implementation details of a class and exposes only what’s necessary through public interfaces. This is often referred to as the “black box” concept — you can use the class without knowing how it works inside.

class BankAccount {
    private var balance: Double = 0.0   // Hidden from outside

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

    fun withdraw(amount: Double) {
        if (amount <= balance) balance -= amount
        else println("Insufficient balance")
    }

    fun getBalance(): Double = balance  // Controlled access
}

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

Output:

Current Balance: 400.0
  

3. How Encapsulation Works in Kotlin

• Access Modifiers:
  • private – Visible only inside the same class.
  • protected – Visible in the class and its subclasses.
  • internal – Visible within the same module.
  • public – Visible everywhere (default modifier).
• Getters and Setters: In Kotlin, properties automatically generate getter and setter methods. You can customize them to add validation logic.

3.1 Example: Custom Getters and Setters

class Pilot {
    var name: String = "Unknown"
        private set  // Restrict modification from outside

    var experienceYears: Int = 0
        set(value) {
            if (value >= 0) field = value
            else println("Experience cannot be negative!")
        }

    fun assignName(newName: String) {
        if (newName.isNotBlank()) name = newName
    }
}

fun main() {
    val pilot = Pilot()
    pilot.assignName("Amelia Earhart")
    pilot.experienceYears = 5
    println("${pilot.name} has ${pilot.experienceYears} years of experience.")
}
  

Output:

Amelia Earhart has 5 years of experience.
  

4. How to Implement Encapsulation Manually (without Kotlin’s property syntax)

You can also implement encapsulation manually using private variables and explicit getter/setter functions, similar to Java-style:

class Airplane {
    private var altitude: Int = 0

    fun setAltitude(value: Int) {
        if (value >= 0) altitude = value
    }

    fun getAltitude(): Int {
        return altitude
    }
}

fun main() {
    val plane = Airplane()
    plane.setAltitude(3000)
    println("Current altitude: ${plane.getAltitude()} ft")
}
  

5. Technical Interview Questions

• What is encapsulation?
  It’s the bundling of data and behavior in a class while restricting direct access to internal details.
• How does Kotlin support encapsulation?
  Through access modifiers and property accessors (getters/setters).
• Can we override a getter or setter in Kotlin?
  Yes, you can define custom logic inside them to validate or transform data.
• What happens if you make a property private?
  It becomes inaccessible outside the class, ensuring data safety.
• Difference between encapsulation and abstraction?
  Encapsulation hides implementation and restricts access; abstraction hides complexity by showing only relevant details.
• What is a module in Kotlin?
  A module is a set of Kotlin files compiled together as a unit.
  • Files in the same module can access each other’s internal members.
  • Files in different modules cannot access internal members of other modules, even if they are in the same project.

6. Key Takeaways

• Encapsulation improves security, readability, and maintainability.
• Use private variables and public functions for controlled access.
• Custom getters and setters are powerful for data validation.
• Encapsulation ensures that changes inside a class don’t affect other parts of the program.