Скачать или смотреть Understanding Why Kotlin null is Not Always null

In Kotlin, the combination of `null` and the `!!` operator can lead to unexpected runtime exceptions. Explore how Kotlin handles nullability and why this code can compile without issues, even leading to a NullPointerException.
---
This video is based on the question https://stackoverflow.com/q/76160592/ asked by the user 'Prashant' ( https://stackoverflow.com/u/5602214/ ) and on the answer https://stackoverflow.com/a/76160783/ provided by the user 'DavidT' ( https://stackoverflow.com/u/16893413/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Kotlin `null` is not `null`?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Why Kotlin null is Not Always null

Kotlin's treatment of nullability can sometimes seem perplexing. For instance, the concept that null is not necessarily null in some contexts might feel contradictory. If you've ever written Kotlin code and stumbled upon an instance where you silently received a NullPointerException, you're not alone. Let's dive into this intriguing topic to unravel the nuances of Kotlin's null handling and clarify what's happening when you encounter null!!.

The Conundrum of null!!

A Real-World Example

Imagine you wrote the following code:

[[See Video to Reveal this Text or Code Snippet]]

At first glance, you might expect to see an error, but interestingly, the IDE does not complain. This piece of code may seem nonsensical because it suggests that you are trying to return a ResponseEntity type while actually returning null, yet the compiler allows it. Why does this happen?

The Explanation

To understand this behavior, let’s break it down in a simple way.

Nullable Types in Kotlin: When you declare a variable in Kotlin, you can indicate whether it can hold a null value by appending a ? to its type. For example:

[[See Video to Reveal this Text or Code Snippet]]

Here, x is allowed to be null because it is declared as a nullable type.

The !! Operator: The !! operator asserts that a value is non-null. When you use it, you inform the compiler that you are confident the value is not null. Thus, when you write:

[[See Video to Reveal this Text or Code Snippet]]

The variable y is now treated as a non-nullable ResponseEntity<*>, allowing you to proceed without complaints from the compiler.

Merging the Concepts

Returning to our original code snippet, if you combine these two ideas:

[[See Video to Reveal this Text or Code Snippet]]

You effectively tell the compiler you are forcibly casting null to a non-nullable type. From a compilation perspective, this code is considered valid Kotlin. However, it will lead to a runtime NullPointerException (NPE) every time it is invoked, which makes this pattern quite dangerous.

Compiler vs. Runtime Behavior

Valid Compilation but Risky Execution

While Kotlin's rich type system allows such code to compile, it raises an important question: Shouldn't the compiler issue a warning? Indeed, while the code is valid from a software compilation standpoint, writing code that will always throw an NPE indicates a deeper problem in logic or handling values and may benefit from a warning or a safer coding practice.

Practical Implications

In practice, this phenomenon highlights the importance of understanding your code's behavior during runtime versus just focusing on its compilation. Here are some key takeaways:

Be cautious with !!: Using it without careful consideration can lead to runtime errors.

Embrace null safety: Aim to handle null values properly to avoid introducing bugs.

Read compiler warnings: Even if the compiler allows the code, make sure to validate the logic behind it.

A Fun Tip

As a quirky note, if you’ve ever wanted a succinct way to trigger a NullPointerException, you could do it like this:

[[See Video to Reveal this Text or Code Snippet]]

This clever hack will throw the NPE when the condition is fulfilled, but be sure to use such a pattern with caution!

Conclusion

The journey through Kotlin's handling of null unveils the quirks and pitfalls that can arise in the language's treatment of nullable types and operators like !!. Always remember to think critically about null values in your code to write safer, more reliable Kotlin applications. Understanding these intricacies not only aids in writing better code but also enhances your over