?? Exploring Key Features of Kotlin

Kotlin has become a go-to language for modern software development, especially for android apps, backend services and multi platform applications.

Here, we will explore some key Kotlin features in real world examples that can enhance code efficiency and maintainability.

?? 1. lateinit – Lazy Initialization for Properties

In Kotlin, non-nullable properties must be initialized at declaration. However, in some cases, (e.g. dependency injection, unit tests or android views) we don't have the value immediately. That's where lateinit comes in.

? Example: Using lateinit in Dependency Injection

class Database {
     fun connect() = "Connected to DB"
}

class Repository {
    lateinit var database: Database

    fun initialize() {
        database = Database()
    }
    fun fetchData() = database.connect()
}

fun main() {
    val repo = Repository()
    repo.initialize()
    println(repo.fetchData()) 
}        

?? Key Points:

• lateinit allows the variable to be initialized later.
• Cannot be used with primitive types (e.g., Int, Double).
• Accessing before initialization throws an UninitializedPropertyAccessException.

?? 2. object – Singleton in Kotlin

Kotlin makes implementing the Singleton pattern straightforward using object.

It ensures only one instance exists across the application.

? Example: Using object as a Singleton

object Logger {
   fun log(message: String) {
        println("LOG: $message")
    }
}

fun main() {
    Logger.log("Application started") 
}        

?? Key Points:

? object creates a thread-safe singleton.

? No need for manual instance creation (Logger()).

? Great for logging, configurations, or utility classes.

?? 3. Immutability in Kotlin

Kotlin encourages immutability with val (like final in java) and data class for immutable models.

? Example: Immutable Data with val and copy()

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

fun main() {
    val user1 = User("Alice", 25)
    val user2 = user1.copy(age = 26) 
    println(user1) // Output: User(name=Alice, age=25)
    println(user2) // Output: User(name=Alice, age=26)
}        

?? Key Points:

? val prevents reassignment (var allows mutation).

? data class provides copy(), ensuring a new instance is created instead of modifying the original.

?? 4. companion object – Static-like Features in Kotlin

Kotlin doesn't have static methods, but companion objects allow class-level functions.

? Example: Using companion object for Factory Methods

class User private constructor(val name: String) {
    companion object {
        fun create(name: String): User {
            return User(name)
        }
    }
}

fun main() {
    val user = User.create("Charlie")
    println(user.name) 
}        

?? Key Points:

? companion object lets you define functions at the class level.

? Useful for factory methods, constants, or utility functions.

? Acts like a static method in Java but is more powerful.

Kotlin provides powerful features that improve code readability and maintainability. Understand lateinit for deferred initialization, object for singletons, immutability for safe data handling, and companion object for static-like behavior can help? you write better Kotlin code.

What are your favorite Kotlin features??

???? #Kotlin #Programming #SoftwareDevelopment