Type casting is a common operation in Kotlin, allowing developers to convert one type into another. Kotlin provides two main ways to perform type casts: as (unsafe casting) and as? (safe casting). Understanding the differences between these two is crucial for writing robust and error-free Kotlin code.

Understanding Type Casting in Kotlin

Before diving into safe vs. unsafe casting, let’s briefly review how type casting works in Kotlin.

Kotlin uses type casting to convert an object from one type to another. The two primary casting operators are:

• as (Unsafe Cast): Forces a cast and throws a ClassCastException if the cast fails.
• as? (Safe Cast): Returns null if the cast is not possible, preventing runtime exceptions.

Let’s explore both in detail.

Unsafe Casting Using as

Unsafe casting with as is straightforward but risky. If the object cannot be cast to the desired type, a ClassCastException occurs.

fun main() {
    val obj: Any = "Hello, Kotlin!"
    val str: String = obj as String // Successful cast
    println(str)
}

This works fine because obj is indeed a String. However, let’s see what happens when the type does not match:

fun main() {
    val obj: Any = 42
    val str: String = obj as String // Throws ClassCastException
    println(str)
}

Output:

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

Here, obj is an Int, and forcing it into a String type results in a crash. This is where safe casting (as?) is useful.

Safe Casting Using as?

The safe cast operator as? prevents runtime exceptions by returning null if the cast is not possible.

fun main() {
    val obj: Any = 42
    val str: String? = obj as? String // Returns null instead of throwing an exception
    println(str) // Output: null
}

Using as?, we avoid the crash because instead of forcing an invalid cast, it simply assigns null to str.

When to Use as? Instead of as

When Type is Uncertain

• If you’re dealing with dynamic or uncertain types, always prefer as? to avoid crashes.

fun safeCastExample(value: Any) {
    val number: Int? = value as? Int
    println(number ?: "Not an Int")
}

fun main() {
    safeCastExample(100)   // Output: 100
    safeCastExample("Kotlin") // Output: Not an Int
}

When Handling Nullable Types

• Since as? returns null on failure, it works well with nullable types.

fun main() {
    val obj: Any = "Kotlin"
    val str: String? = obj as? String // No crash, just null if not castable
    println(str ?: "Cast failed")
}

To Avoid ClassCastException

• Using as? ensures the program does not terminate due to a casting error.

When to Use as

Although unsafe, as is still useful when you’re certain of the type.

fun main() {
    val text: Any = "Safe Casting"
    val str: String = text as String // Works because the type matches
    println(str)
}

Using as is fine in cases where you control the input type and are confident about the cast.

Conclusion

Type casts in Kotlin play an essential role in handling object types. However, using as carelessly can lead to runtime crashes. To ensure safer code, always prefer as? when the type is uncertain. This approach avoids ClassCastException and makes your Kotlin applications more robust and error-free.