Null Safety

Reviewed & published by Brayan K

Kotlin is a modern, concise language whose signature feature is null safety — its type system eliminates the NullPointerExceptions that crash programs in other languages.

Part of the free Kotlin course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

By the end of this lesson you'll understand nullable types, the safe call ?., the Elvis operator ?:, and when (rarely) to use !!.

What You'll Learn in This Lesson

• Why null safety prevents a whole class of crashes
• The difference between String and nullable String?
• The safe call operator ?.
• The Elvis operator ?: for default values
• The not-null assertion !! and when to avoid it
• How smart casts let you use nullable values safely

1️⃣ Nullable Types and Safe Calls

In Kotlin, a regular type like String can never be null. To allow null, you add a question mark: String?. Once a value might be null, the compiler refuses to let you use it carelessly — you must handle the null case. The safe call operator ?. returns null instead of crashing.

fun main() {
    // A normal String can NEVER hold null:
    val name: String = "Ada"
    // name = null  // ❌ won't compile — null is not allowed here

    // Add a ? to the type to make it NULLABLE — now null is allowed:
    val middle: String? = null
    println(middle)               // -> null

    // The compiler stops you from using a nullable value unsafely:
    // println(middle.length)     // ❌ won't compile — middle might be null

    // Use ?. (safe call): returns null instead of crashing.
    println(middle?.length)       // -> null

    val nickname: String? = "Aces"
    println(nickname?.length)     // -> 4
}

The key insight: the line that would crash in other languages doesn't even compile here. You're forced to deal with null up front, which is exactly why Kotlin programs crash so much less.

2️⃣ Elvis, !!, and let

The Elvis operator ?: supplies a fallback when the left side is null. The not-null assertion !! forces a value to non-null and throws if you're wrong — use it sparingly. And ?.let { } runs a block only when the value isn't null.

fun main() {
    val input: String? = null

    // The Elvis operator ?: gives a fallback when the left side is null.
    val text = input ?: "default"
    println(text)                          // -> default

    // Combine safe call + Elvis to compute a safe length:
    val length = input?.length ?: 0
    println("Length is $length")           // -> Length is 0

    // !! forces a non-null value — use ONLY when you are certain.
    val sure: String? = "ok"
    println(sure!!.uppercase())            // -> OK

    // A common safe pattern: only act when not null
    val maybe: String? = "hi"
    maybe?.let { println("Got: $it") }     // -> Got: hi
}

The pattern value?.length ?: 0 is everywhere in real Kotlin: "the length, or 0 if it's missing". Lean on it.

Your turn. Fill in the TODO, then run and compare.

// 🎯 YOUR TURN — replace each TODO then run main()
fun main() {
    // A nullable middle name that might be null:
    val middleName: String? = null   // 👉 try changing this to "Rose" later

    // 1) Use the Elvis operator to default to "(none)" when null
    val display = middleName ?: "TODO"   // 👉 put "(none)" here

    // 2) Safely get the length, defaulting to 0 when null
    val len = middleName?.length ?: 0    // already done for you

    println("Middle: $display, length: $len")

    // ✅ Expected (with null):  Middle: (none), length: 0
}

Mini-Challenge: A Safe Profile Printer

Combine safe calls and the Elvis operator to print a profile that never crashes on missing data.

// 🎯 MINI-CHALLENGE: a safe profile printer.
// Save as Profile.kt and run main().
//
// 1. Make a nullable email: String? (set it to null OR an address).
// 2. Print "Email: <value>" using the Elvis operator to show
//    "not provided" when it is null.
// 3. Print the email length, defaulting to 0 when null,
//    using a safe call ?. combined with ?:
//
// ✅ Example output (email = null):
//    Email: not provided
//    Length: 0

fun main() {
    val email: String? = null
    // your code here
}

Common Errors (and the fix)

• "Only safe (?.) or non-null asserted (!!.) calls are allowed" — You called a method directly on a nullable value. Use ?. (safe) instead of ..
• NullPointerException from !! — You asserted a value was non-null and it wasn't. Replace !! with a safe call and an Elvis fallback.
• "Null can not be a value of a non-null type String" — You tried to assign null to a non-nullable type. Add a ? to the type if null is genuinely possible.
• Overusing ? — Making everything nullable defeats the purpose. Only mark a type nullable if the value can truly be absent.

Pro Tips

• 💡 Smart casts: after if (x != null), Kotlin treats x as non-null inside the block — no ?. needed.
• 💡 Chain safe calls: a?.b?.c returns null if any link is null — no nested if statements.
• 💡 Treat !! as a code smell: most uses can be rewritten with ?: or let.

📋 Quick Reference — Null Safety

🎉 Lesson Complete!

• ✅ Regular types can never be null; Type? allows null
• ✅ The safe call ?. returns null instead of crashing
• ✅ The Elvis operator ?: supplies a default
• ✅ !! forces non-null — use it rarely
• ✅ Smart casts let you use nullable values after a null check

Practice quiz

Continue this course

• Previous: Variables (val & var)
• Next: Operators & Strings — Arithmetic, comparison, and logical operators plus string templates
• Quick reference: Kotlin cheat sheet › Null Safety

Frequently asked questions

What problem does null safety actually solve?

In many languages any reference can be null, so calling a method on a value that happens to be null crashes the program with a NullPointerException (NPE) — famously called 'the billion-dollar mistake'. Kotlin moves this problem from runtime to compile time: a regular type like String can never be null, and a nullable type like String? forces you to handle the null case before the code will even compile. The result is far fewer crashes in production.

What's the difference between ?. and !! ?

The safe call operator ?. evaluates to null instead of crashing when the receiver is null — so value?.length is null if value is null. The not-null assertion operator !! does the opposite: it tells the compiler 'trust me, this is not null', and if you are wrong it throws a NullPointerException at runtime. Use ?. (often with the Elvis operator ?:) by default, and reserve !! for the rare cases where you are absolutely certain a value is present.

What does the Elvis operator ?: do?

The Elvis operator provides a default value for a nullable expression. In a ?: b, if a is non-null the whole expression is a; if a is null the expression is b instead. It is commonly combined with a safe call, as in name?.length ?: 0, which reads 'the length of name, or 0 if name is null'. It's named Elvis because ?: looks like his hairstyle turned sideways.

How does smart casting work with nullable types?

When you check a nullable value with an if (x != null) condition, Kotlin 'smart casts' x to its non-null type inside that block, so you can use it directly without ?. or !!. This works for local vals because the compiler can prove the value did not change. Smart casts also apply after is checks (covered later), making conditional code clean and safe.