DEV Community

Ahmed Moussa
Ahmed Moussa

Posted on

Kotlin Smart Casts vs. Java Casts: A Type-Safe Tale (with Fewer Runtime Surprises!)

#kotlin #java

Kotlin vs Java

Imagine you're a detective investigating a case. You have a mysterious object in front of you, and you need to figure out what it is before you can proceed with your investigation. In Java, you might have to use a magnifying glass (and a lot of instanceof checks) to determine the object's type. But in Kotlin, you have x-ray vision with Smart Casts! 🕵️‍♀️

Java: The Case of the Uncertain Type

In Java, when you deal with objects of a general type (like Object), you often need to check their specific type before accessing their properties or methods. This involves using the instanceof operator and then explicitly casting the object to the desired type.

// Java
Object obj = "Hello, world!";

if (obj instanceof String) {
    String str = (String) obj;
    System.out.println(str.length()); 
}
Enter fullscreen mode Exit fullscreen mode

It's a bit like wearing those bulky safety goggles in a chemistry lab – necessary but not exactly stylish. 🥽

Kotlin: The Smart Cast Detective

Kotlin's Smart Casts are like a superpower for type safety. The compiler acts as your trusty sidekick, automatically casting an object to the correct type once you've checked it with the is operator.

// Kotlin
val obj: Any = "Hello, world!"

if (obj is String) {
    println(obj.length) // obj is automatically cast to String here!
}
Enter fullscreen mode Exit fullscreen mode

No explicit casting needed! It's like the compiler whispers in your ear, "Don't worry, detective, I've got this." 🤫

Why Smart Casts Are So Smart

Smart Casts not only make your code more concise but also safer. They eliminate the risk of ClassCastException errors that can occur in Java when you accidentally cast an object to the wrong type. It's like having a safety net that prevents you from falling flat on your face during your type-checking acrobatics. 🤸

Java's Attempt at Catching Up: Pattern Matching for instanceof (Java 16+)

Java, realizing it might be falling behind in the type-checking game, introduced Pattern Matching for instanceof in Java 16. This allows for a more concise syntax when checking and casting objects.

// Java
Object obj = "Hello, world!";

if (obj instanceof String str) {
    System.out.println(str.length());
}
Enter fullscreen mode Exit fullscreen mode

While this improves readability, it's still not as seamless as Kotlin's Smart Casts, which automatically track the type information throughout the code block.

In Conclusion (The Case Closed)

Kotlin's Smart Casts are a valuable tool for writing type-safe and concise code. They eliminate the need for explicit casting and reduce the risk of runtime errors. So, if you're ready to trade in your Java magnifying glass for Kotlin's x-ray vision, embrace the power of Smart Casts! ✨

P.S. If you're a Java developer still relying on manual casting, don't worry. You can always upgrade to Java 16 or later and enjoy some pattern matching magic. It's not quite the same, but it's a step in the right direction! 😉

Top comments (6)

Collapse
 
khmarbaise profile image
Karl Heinz Marbaise •

While this improves readability, it's still not as seamless as Kotlin's Smart Casts, which automatically track the type information throughout the code block.

Can you explain that part?

Collapse
 
hamada147 profile image
Ahmed Moussa •

Hello @khmarbaise,
Of course. I will try to clarify it with a detailed explanation and example.

Kotlin's Smart Casts

In Kotlin, when you use the is operator to check an object's type, the compiler becomes your ally in maintaining type safety. It's not just a one-time check; the compiler intelligently remembers and tracks this type of information within the scope of the if block (or when expression). This means that once you've confirmed the type, you can directly access the properties and methods of that type without any explicit casting.

Example:

// Kotlin
fun printLengthIfString(obj: Any) {
    if (obj is String) {
        println(obj.length) // obj is automatically treated as a String here
    }
}
Enter fullscreen mode Exit fullscreen mode

In this example, once the obj is String condition is true, the Kotlin compiler remembers that obj is indeed a String within the if block. You can freely use obj.length without casting. The compiler has your back, ensuring type safety.

Java's Pattern Matching

Java's Pattern Matching for instanceof introduced in Java 16 is a definite improvement. It allows you to combine the type check and variable assignment in a single line, making the code more concise.

Example:

// Java
void printLengthIfString(Object obj) {
    if (obj instanceof String str) {
        System.out.println(str.length()); 
    }
}
Enter fullscreen mode Exit fullscreen mode

Here, str is a new variable of type String that is assigned the value of obj if the instanceof check passes. This avoids the separate casting step.

The Key Difference

The crucial distinction lies in how the type of information is handled. In Java's pattern matching, the scope of the type-checked variable (str in the example) is limited to the if block. Outside of that block, the compiler forgets that obj was ever confirmed as a String.

In contrast, Kotlin's Smart Casts have a broader scope. The compiler's awareness of the type extends beyond the initial check. This means that you won't need to repeat the type check or casting even if you have nested conditions or more complex logic within the if block. Kotlin maintains the type of information, making your code cleaner and less prone to errors.

Collapse
 
khmarbaise profile image
Karl Heinz Marbaise • • Edited 
fun printLengthIfString(obj: Any) {
    if (obj is String) {
        println(obj.length) // obj is automatically treated as a String here
    }
}
Enter fullscreen mode Exit fullscreen mode

The assumption that the obj can be looked at as a String is only valid within the if-block... outside the if-block the assumption is not correct anymore and could fail.

In Java that's the same way:

void printLengthIfString(Object obj) {
    if (obj instanceof String str) {
        System.out.println(str.length()); 
    }
}
Enter fullscreen mode Exit fullscreen mode

within the if-block this check makes sure you can treat the obj as String which is explicitly expressed by the instanceof-Pattern here to use a separate name str..

What will happen in Kotlin by using it like this:

fun printLengthIfString(obj: Any) {
    if (obj !is String) {
     ..
    }
   // Here you can access obj like a String..
   println(obj.length()); 
}
Enter fullscreen mode Exit fullscreen mode

That will be exactly the same as in Java:

void printLengthIfString(Object obj) {
    if (!obj instanceof String str) {
       return;
    }
    System.out.println(str.length()); 
}
Enter fullscreen mode Exit fullscreen mode

That means within the block of the method the str is valid..

So I don't see a real difference here... and as already mentioned Java is here a bit more explicit using a separate name for the casted value, than Kotlin.

Thread Thread
 
hamada147 profile image
Ahmed Moussa •

Think of it like comparing two sets of instructions:

  • Java: "Take the box. Check if it contains a screwdriver. If it does, open the box. Take out the screwdriver. Use the screwdriver to tighten the screw."
  • Kotlin: "Take the box. If it contains a screwdriver, use it to tighten the screw."

Both sets of instructions achieve the same goal, but the Kotlin version is more direct and to the point.

Ultimately, the preferred style comes down to personal preference and the specific context of the code.

Collapse
 
latex_wei profile image
LaTex wei •

I think in this case, java is more explicit than kotlin. More code lines means more readable.

Collapse
 
hamada147 profile image
Ahmed Moussa •

Hello @latex_wei,
That's an interesting point! It's true that Java's explicitness can sometimes be helpful, especially for beginners or when debugging complex code. Seeing each step laid out can make the logic easier to follow.

However, Kotlin's Smart Casts offers a different kind of readability. By eliminating the redundant casting, the code becomes more concise and focused on the essential logic. This can improve readability by reducing visual clutter and clarifying the code's intent.

Think of it like comparing two sets of instructions:

  • Java: "Take the box. Check if it contains a screwdriver. If it does, open the box. Take out the screwdriver. Use the screwdriver to tighten the screw."
  • Kotlin: "Take the box. If it contains a screwdriver, use it to tighten the screw."

Both sets of instructions achieve the same goal, but the Kotlin version is more direct and to the point.

Ultimately, the preferred style comes down to personal preference and the specific context of the code.

Read next

mostafa_ profile image

Finding an Element in an Infinite Array Using Java

Mostafa Shariare -

arshisaxena26 profile image

Exploring HashSet: A Dive into Unordered Collections

Arshi Saxena -

snyk_sec profile image

Automatically fix code vulnerabilities with AI

SnykSec -

theplebdev profile image

Quick and easy custom Jetpack compose checkbox

Tristan Elliott -