Platform types and null safety in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Understanding platform types and null safety

What is the output of this Kotlin code when calling a Java method that returns a platform type?

Kotlin

fun main() {
    val javaString: String = getJavaString()
    println(javaString.length)
}

// Simulated Java method returning platform type
fun getJavaString(): String? = null

A Prints 0

B Throws a NullPointerException at runtime

C Compilation error due to null assignment

D Prints 'null'

💡 Hint

Platform types allow nulls but Kotlin treats them as non-null by default.

The Java method returns a platform type, which Kotlin treats as non-nullable. Assigning null to a non-nullable variable compiles but causes a NullPointerException at runtime when accessing its members.

❓ Predict Output

intermediate

Safe call operator with platform types

Given a platform type from Java, what will this Kotlin code print?

Kotlin

fun main() {
    val javaString = getJavaString()
    println(javaString?.length ?: "null length")
}

fun getJavaString(): String? = null

A null length

B Throws NullPointerException

C 0

D Compilation error

💡 Hint

The safe call operator ?. prevents NullPointerException.

Using ?. safely accesses length only if javaString is not null. Since javaString is null, the Elvis operator ?: returns "null length".

🔧 Debug

advanced

Identify the cause of NullPointerException with platform types

Why does this Kotlin code throw a NullPointerException at runtime?

Kotlin

fun main() {
    val javaList: List<String> = getJavaList()
    println(javaList.size)
}

fun getJavaList(): List<String>? = null

A Because platform types are treated as non-nullable but can be null at runtime

B Because Kotlin does not allow null lists at all

C Because getJavaList() returns an empty list, not null

D Because size property is not available on platform types

💡 Hint

Platform types come from Java and Kotlin assumes non-null but no guarantee.

Platform types have no nullability info, so Kotlin treats them as non-nullable. If the Java method returns null, accessing members causes NullPointerException.

📝 Syntax

advanced

Correctly declaring a platform type variable

Which Kotlin declaration correctly represents a platform type variable from Java that might be null?

A val javaStr: String! = getJavaString()

B val javaStr: String? = getJavaString()

C val javaStr = getJavaString()

D val javaStr: String = getJavaString()

💡 Hint

Platform types are not explicitly declared in Kotlin code.

Platform types are inferred by Kotlin when calling Java code. You cannot explicitly declare a variable as a platform type with '!'. Using 'val javaStr = getJavaString()' lets Kotlin infer the platform type.

🚀 Application

expert

Handling platform types safely in Kotlin

You receive a platform type String! from a Java method that might be null. Which Kotlin code snippet safely handles this value to avoid runtime exceptions?

A

val safeStr: String = javaStr
println(safeStr.length)

B

val safeStr: String = javaStr ?: ""
println(safeStr.length)

C

val safeStr: String = javaStr!!
println(safeStr.length)

D

val safeStr: String? = javaStr
println(safeStr?.length ?: 0)

💡 Hint

Convert platform type to nullable type to safely check for null.

Assigning the platform type to a nullable String allows safe calls and null checks. Options A and C risk NullPointerException. Option D is invalid because ?: cannot be used directly on platform types without explicit nullability.

Practice

1. What is a platform type in Kotlin when interacting with Java code?

easy

A. A type with unknown nullability coming from Java code

B. A Kotlin type that is always non-nullable

C. A Kotlin type that is always nullable

D. A special Kotlin type used only in multiplatform projects

Solution

1. Step 1: Understand Kotlin-Java interoperability

   Kotlin calls Java code but Java does not specify nullability clearly.

2. Step 2: Define platform type meaning

   Platform types represent types from Java with unknown nullability, so Kotlin treats them flexibly but unsafely.

3. Final Answer:

   A type with unknown nullability coming from Java code -> Option A

4. Quick Check:

   Platform type = unknown nullability [OK]

Hint: Platform types come from Java with unclear null info [OK]

Common Mistakes:

• Thinking platform types are always nullable
• Assuming platform types are always non-nullable
• Confusing platform types with Kotlin multiplatform types

2. Which Kotlin syntax correctly declares a variable that can hold a platform type from Java and safely handle nulls?

easy

A. val name: String = javaMethod()

B. val name: String!! = javaMethod()

C. val name: String? = javaMethod()

D. val name: String? = null!!

Solution

1. Step 1: Recognize platform type usage

   Java method returns a platform type, which can be nullable or not.

2. Step 2: Choose safe Kotlin declaration

   Declaring as nullable String? allows safe null handling from platform types.

3. Final Answer:

   val name: String? = javaMethod() -> Option C

4. Quick Check:

   Nullable type for platform type = safe [OK]

Hint: Use nullable type to safely hold platform types [OK]

Common Mistakes:

• Using non-nullable type without null checks
• Using !! which causes exceptions if null
• Using invalid syntax like null!!

3. Given this Kotlin code calling a Java method returning a platform type:

fun printLength() {
    val text: String = javaMethod()
    println(text.length)
}

What happens if javaMethod() returns null?

medium

A. The program compiles but does nothing

B. The program prints 0

C. The program prints "null"

D. The program throws a NullPointerException at runtime

Solution

1. Step 1: Analyze variable declaration

   Variable text is declared as non-nullable String but assigned platform type from Java.

2. Step 2: Consider null return from Java

   If javaMethod() returns null, Kotlin does not check at compile time, but accessing text.length causes NullPointerException.

3. Final Answer:

   The program throws a NullPointerException at runtime -> Option D

4. Quick Check:

   Non-null platform type + null value = runtime exception [OK]

Hint: Non-null platform types can cause runtime null errors [OK]

Common Mistakes:

• Assuming Kotlin prevents null assignment from platform types
• Thinking it prints 0 or "null" instead of crashing
• Ignoring runtime exceptions from platform types

4. Identify the error in this Kotlin code using a platform type:

val length: Int = javaMethod()?.length

where javaMethod() returns a platform type String!.

medium

A. The expression can return null but assigned to non-nullable Int

B. No error, code is correct

C. Platform types cannot be assigned to Int variables

D. Safe call operator ?. cannot be used on platform types

Solution

1. Step 1: Understand the expression type

   javaMethod() returns platform type String!, so javaMethod()?.length returns Int? (nullable Int).

2. Step 2: Check assignment compatibility

   Assigning nullable Int? to non-nullable Int variable length causes a type mismatch error.

3. Final Answer:

   The expression can return null but assigned to non-nullable Int -> Option A

4. Quick Check:

   Nullable result assigned to non-null variable = error [OK]

Hint: Nullable result must not assign to non-null variable [OK]

Common Mistakes:

• Thinking safe call ?. is invalid on platform types
• Ignoring nullability mismatch in assignment
• Assuming platform types cannot be used with Int

5. You have a Java method String getName() that may return null. How should you declare and use it in Kotlin to avoid null pointer exceptions and keep null safety?

hard

A. Declare as val name: String = javaMethod() and use name.length

B. Declare as val name: String? and check if (name != null) before use

C. Declare as val name: String!! and use name.length directly

D. Declare as val name: String and use name?.length ?: 0

Solution

1. Step 1: Recognize Java method nullability

   Java method may return null, so Kotlin platform type is uncertain.

2. Step 2: Choose safe Kotlin declaration and usage

   Declare as nullable String? and check for null before accessing properties to avoid exceptions.

3. Final Answer:

   Declare as val name: String? and check if (name != null) before use -> Option B

4. Quick Check:

   Nullable declaration + null check = safe usage [OK]

Hint: Use nullable type and explicit null check for Java returns [OK]

Common Mistakes:

• Using non-nullable type without null checks
• Using !! which risks runtime exceptions
• Misusing safe call with non-nullable declaration