Platform types from Java interop in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What are platform types in Kotlin when interoperating with Java?

Platform types are types Kotlin uses to represent Java types whose nullability is unknown. Kotlin treats them as if they could be nullable or non-nullable, allowing flexibility but requiring caution.

beginner

How does Kotlin handle null safety with platform types?

Kotlin does not enforce null safety on platform types. You can assign them to nullable or non-nullable variables, but you must be careful to avoid null pointer exceptions at runtime.

intermediate

Why do platform types exist in Kotlin when working with Java code?

Platform types exist because Java does not have built-in nullability annotations by default, so Kotlin cannot be sure if a Java type is nullable or not. Platform types let Kotlin handle this uncertainty.

intermediate

What happens if you assign a platform type to a non-nullable Kotlin variable and the value is actually null?

A null pointer exception will occur at runtime because Kotlin assumes the value is not null, but the platform type could be null since Kotlin has no compile-time check.

beginner

How can you explicitly handle platform types to avoid null pointer exceptions?

You can explicitly check for null before using the value, or assign the platform type to a nullable Kotlin type (e.g., String?) to safely handle possible nulls.

What does a platform type in Kotlin indicate when working with Java code?

A The nullability of the type is unknown

B The type is always non-null

C The type is always nullable

D The type is deprecated

Platform types mean Kotlin cannot be sure if the Java type is nullable or not.

If you assign a platform type to a non-nullable Kotlin variable without checks, what risk do you face?

A Compile-time error

B No risk at all

C Automatic null safety

D Null pointer exception at runtime

Kotlin assumes non-null, so if the value is null, a runtime exception occurs.

How can you safely handle a platform type in Kotlin?

A Ignore null checks

B Assign it to a nullable type and check for null

C Use platform types as non-nullable always

D Convert it to Java type

Assigning to a nullable type lets you check for null safely.

Why can't Kotlin determine nullability of Java types by default?

A Java types are always nullable

B Kotlin does not support Java

C Java lacks built-in nullability annotations

D Kotlin ignores Java types

Java does not have nullability info by default, so Kotlin treats types as platform types.

What is a good practice when using platform types from Java in Kotlin?

A Perform null checks or use nullable types

B Avoid null checks

C Always trust they are non-null

D Convert all Java code to Kotlin

Null checks or nullable types help avoid runtime errors with platform types.

Explain what platform types are in Kotlin and why they are important when working with Java code.

Think about how Kotlin handles Java types without nullability info.

Describe how you can safely use platform types in Kotlin to avoid runtime errors.

Consider Kotlin's null safety features and how they apply to platform types.

Practice

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

easy

A. A type whose nullability is unknown and can be treated as nullable or non-nullable

B. A Kotlin type that is always non-nullable

C. A Java type that is always nullable

D. A Kotlin type that enforces strict null checks at compile time

Solution

1. Step 1: Understand Kotlin-Java interoperability

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

2. Step 2: Define platform types

   Platform types are types from Java whose nullability Kotlin cannot be sure about, so Kotlin treats them flexibly as nullable or non-nullable.

3. Final Answer:

   A type whose nullability is unknown and can be treated as nullable or non-nullable -> Option A

4. Quick Check:

   Platform type = unknown nullability [OK]

Hint: Platform types have unknown nullability from Java [OK]

Common Mistakes:

• Thinking platform types are always non-nullable
• Assuming platform types enforce null checks
• Confusing platform types with Kotlin nullable types

2. Which of the following Kotlin declarations correctly handles a Java platform type that might be null?

easy

A. val name: String!! = javaObject.getName()

B. val name: String = javaObject.getName()

C. val name: String? = javaObject.getName()

D. val name: String = javaObject.getName()!!

Solution

1. Step 1: Recognize platform type usage

   Java method returns a platform type; Kotlin doesn't know if it's nullable.

2. Step 2: Choose safe Kotlin type

   Declaring as nullable String? safely handles possible null values.

3. Final Answer:

   val name: String? = javaObject.getName() -> Option C

4. Quick Check:

   Use nullable type for platform types to avoid crashes [OK]

Hint: Use nullable type (String?) for uncertain Java values [OK]

Common Mistakes:

• Using non-nullable type without null check
• Using double-bang (!!) unnecessarily
• Declaring invalid Kotlin types like String!!

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

val length = javaObject.getName().length

What happens if getName() returns null at runtime?

medium

A. The code throws a NullPointerException at runtime

B. The code fails to compile due to null safety

C. The code compiles and runs safely, length is 0

D. The code returns length as -1

Solution

1. Step 1: Understand platform type nullability

   Platform types can be null but Kotlin treats them as non-nullable unless specified.

2. Step 2: Analyze code behavior

   Calling length on a null value causes a NullPointerException at runtime.

3. Final Answer:

   The code throws a NullPointerException at runtime -> Option A

4. Quick Check:

   Platform types can cause runtime NPE if null used unsafely [OK]

Hint: Accessing platform type without null check risks NPE [OK]

Common Mistakes:

• Assuming Kotlin prevents runtime null errors
• Thinking length returns 0 for null
• Expecting compile-time error for platform types

4. This Kotlin code calls a Java method returning a platform type:

val length = javaObject.getName()?.length ?: 0

What is the main benefit of using ?. here?

medium

A. It forces the compiler to treat the value as non-null

B. It throws an exception if the value is null

C. It converts the platform type to a non-nullable type

D. It safely handles null by returning 0 instead of crashing

Solution

1. Step 1: Identify safe call operator usage

   The ?. operator calls length only if getName() is not null.

2. Step 2: Understand Elvis operator fallback

   If getName() is null, the expression returns 0 instead of crashing.

3. Final Answer:

   It safely handles null by returning 0 instead of crashing -> Option D

4. Quick Check:

   Safe call + Elvis operator prevent null crashes [OK]

Hint: Use ?. and ?: to avoid null crashes with platform types [OK]

Common Mistakes:

• Thinking ?. forces non-null type
• Assuming it throws exception on null
• Confusing safe call with non-null assertion (!!)

5. You have a Java method fun getUser(): User returning a platform type. You want to safely get the user's email or return "unknown" if null. Which Kotlin code correctly handles this?

hard

A. val email = getUser().email ?: "unknown"

B. val email = getUser()?.email ?: "unknown"

C. val email = getUser().email!!

D. val email = getUser().email

Solution

1. Step 1: Recognize platform type and possible nulls

   getUser() returns a platform type; email might be null.

2. Step 2: Use safe call and Elvis operator

   Using ?. safely accesses email; ?: provides fallback "unknown" if null.

3. Final Answer:

   val email = getUser()?.email ?: "unknown" -> Option B

4. Quick Check:

   Safe call + fallback handles null platform types safely [OK]

Hint: Use ?. with ?: to safely access nullable Java values [OK]

Common Mistakes:

• Using non-null assertion (!!) risking runtime crash
• Ignoring possible null from platform type
• Not providing fallback for null values