Kotlin - Null Safety

Introduction

 

Here we are going to learn about Kotlin Null Safety. Those who are new to Kotlin and willing to learn, go through this article series starting here for the Introduction to Kotlin.

 

 

Kotlin Null Safety 

 

Kotlin null safety is used to eliminate the risk of null references in the code if the Kotlin compiler finds any null argument is passed without executing any other statements.

 

Null Pointer Exception causes

• A forceful call to throw NullPointerException();
• An uninitialized use of "this" operator available in a constructor passed and used.
• Use of Java code as Kotlin is in Java interoperatability.

Kotlin Nullable Types and Non-Nullable Types

 

Kotlin types system differentiates between references which can hold a null reference. The String is not nullable. Explicitly define them by putting the String as: String?

 

Nullable Types

 

Nullable types are declared by ? behind the String.

 

Example

fun main(args: Array < String > ) {
    var str: String ? = "Hello" // variable is declared as nullable
    str = null
    print(str)
}

Output

 

null

 

Non Nullable Types

 

Non-nullable types are declared as String.

 

Example

fun main(args: Array < String > ) {
    var str: String = "Hello"
    str = null // compile error
    print(str)
}

Output

 

It will generate a compile-time error.

 

Smart cast

 

To use nullable types, we can use smart casts. Smart cast is a feature in Kotlin compiler tracks conditions. If compiler finds a not null of type then the compiler will allow accessing the variable.

 

Example

fun main(args: Array < String > ) {
    var string: String ? = "Hello!"
    if (string != null) { // smart cast
        print(string.length) // It works now!
    }
}

Output

 

6

 

Smart cast conditions

• A val variable is always for local properties.
• If a val property is private or internal, it is performed in the same module within which the property is declared.
• If the local var variable is not modified between the check and the usage, it is not captured in a lambda.

Unsafe and Safe Cast Operator

 

Unsafe cast operator: as

 

The cast variable and it throws an exception, this is called unsafe cast. The unsafe cast is performed by the operator as A nullable string cannot be cast to a non-nullabe string.

 

Example

fun main(args: Array < String > ) {
    val obj: String ? = "String unsafe cast"
    val str: String ? = obj as String ? // Works
        println(str)
}

Output

 

String unsafe cast

 

Kotlin Safe cast operator: as?

 

Kotlin provides a safe cast operator as? for the safe cast to a type. It returns a null if the casting is not possible rather than throwing a ClassCastException exception.

 

It casts the value if possible or returns null instead of throwing an exception even when casting is not possible.

 

Example

fun main(args: Array < String > ) {
    val location: Any = "Kotlin"
    val safeString: String ? = location as ? String
    val safeInt: Int ? = location as ? Int
    println(safeString)
    println(safeInt)
}

Output

 

Kotlin

null

 

Elvis Operator (?:)

 

Elvis operator (?:) is used to return the conditional expression as null. It is used to check the null safety of values.

 

We can declare a variable to hold a null reference. When a variable contains null reference, before using it in the program we will check its nullability. If a variable is not null then use its property, otherwise use some other non-null value.

 

Example

fun main(args: Array < String > ) {
    var str: String ? = null
    var str2: String ? = "May be declare nullable string"
    var len1: Int =
        if (str != null) str.length
    else -1
    var len2: Int =
        if (str2 != null) str2.length
    else -1
    println("Length of str is ${len1}")
    println("Length of str2 is ${len2}")
}

Output

 

Length of str is -1

Length of str2 is 30

 

Conclusion

 

In this article, we learned about null safety in Kotlin. In the next part, we will learn about Ranges, Reflections, Annotations. 

 

Next in this series: Kotin - Annotations and Reflection