Kotlin annotations for Java callers (@JvmStatic, @JvmField) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of @JvmStatic annotated companion object function call from Java

Consider this Kotlin code with a companion object and a function annotated with @JvmStatic. What will be the output when called from Java as Example.Companion.greet() and Example.greet()?

Kotlin

class Example {
    companion object {
        @JvmStatic
        fun greet() = "Hello from @JvmStatic"

        fun greetNormal() = "Hello from normal companion"
    }
}

A Example.Companion.greet() prints "Hello from @JvmStatic"; Example.greet() does not compile

B Example.Companion.greet() prints "Hello from normal companion"; Example.greet() prints "Hello from @JvmStatic"

C Example.Companion.greet() prints "Hello from @JvmStatic"; Example.greet() prints "Hello from @JvmStatic"

D Example.Companion.greet() does not compile; Example.greet() prints "Hello from @JvmStatic"

💡 Hint

Remember that @JvmStatic creates a static method in the containing class for Java callers.

The @JvmStatic annotation generates a static method in the containing class, so Java can call Example.greet() directly. The companion object still has the instance method, so Example.Companion.greet() also works and returns the same string.

❓ Predict Output

intermediate

Effect of @JvmField on Kotlin property visibility in Java

Given this Kotlin class with a property annotated with @JvmField, what is the output or behavior when accessing Example.CONSTANT from Java?

Kotlin

class Example {
    @JvmField
    val CONSTANT = "Kotlin constant"

    val normalConstant = "Normal constant"
}

A Java can access Example.CONSTANT directly as a field; Example.normalConstant requires getter method

B Java cannot access Example.CONSTANT directly; both require getter methods

C Java can access both Example.CONSTANT and Example.normalConstant directly as fields

D Java cannot access either Example.CONSTANT or Example.normalConstant

💡 Hint

Think about how @JvmField changes the generated bytecode for properties.

The @JvmField annotation exposes the Kotlin property as a public field in Java, so Java code can access Example.CONSTANT directly. The normal property generates a private field with a public getter, so Java must use the getter method.

🔧 Debug

advanced

Why does Java code fail to call Kotlin companion function without @JvmStatic?

This Kotlin code defines a companion object function without @JvmStatic. Java code tries to call Example.greet() but fails. Why?

Kotlin

class Example {
    companion object {
        fun greet() = "Hello"
    }
}

A Because the function requires an instance of Example to be called

B Because Kotlin companion objects cannot be called from Java at all

C Because the function is private by default and not visible to Java

D Because without @JvmStatic, the function is only inside the companion object instance, not as a static method in Example class

💡 Hint

Check how Kotlin companion object functions are compiled and accessed from Java.

Without @JvmStatic, the function is compiled as an instance method inside the companion object class. Java must call Example.Companion.greet(), not Example.greet(). The latter does not exist as a static method.

📝 Syntax

advanced

Which Kotlin property declaration with @JvmField is valid?

Select the valid Kotlin property declaration using @JvmField that compiles without error.

A

"class Example {
    @JvmField
    var count: Int = 0
}"

B

"class Example {
    @JvmField
    private val name: String = "Test"
}"

C

"class Example {
    @JvmField
    val age: Int
}"

D

"class Example {
    @JvmField
    fun getValue() = 42
}"

💡 Hint

Remember @JvmField can only be applied to certain property types and visibility.

@JvmField can only be applied to public properties (val or var) without custom getters/setters. Option A is valid: public var with initializer. Option A is invalid because property is private. Option A is invalid because val without initializer or getter is not allowed. Option A is invalid because @JvmField cannot be applied to functions.

🚀 Application

expert

How to expose Kotlin top-level constant as a Java static field?

You want to expose a Kotlin top-level constant so Java code can access it as a static field without calling a getter method. Which Kotlin declaration achieves this?

A

@JvmField
val MAX_COUNT = 100

B const val MAX_COUNT = 100

C

@JvmStatic
val MAX_COUNT = 100

D val MAX_COUNT = 100

💡 Hint

Consider how Kotlin compiles const val and @JvmField at top-level.

const val creates a compile-time constant that is exposed as a static final field in the generated Java class, accessible directly from Java. @JvmField cannot be applied to top-level properties. @JvmStatic applies only to members inside objects or companion objects. Plain val generates a private field with getter.

Practice

1. What is the main purpose of the @JvmStatic annotation in Kotlin when called from Java?

easy

A. To convert Kotlin lambdas into Java anonymous classes

B. To expose Kotlin properties as public fields in Java

C. To make a Kotlin function in a companion object appear as a static method in Java

D. To mark a Kotlin class as a Java interface

Solution

1. Step 1: Understand the role of @JvmStatic

   @JvmStatic makes functions inside Kotlin companion objects look like static methods in Java, so Java code can call them without an instance.

2. Step 2: Differentiate from @JvmField

   @JvmField exposes properties as fields, not functions. The question asks about functions, so @JvmStatic is correct.

3. Final Answer:

   To make a Kotlin function in a companion object appear as a static method in Java -> Option C

4. Quick Check:

   @JvmStatic = static method in Java [OK]

Hint: Remember: @JvmStatic = static method in Java [OK]

Common Mistakes:

• Confusing @JvmStatic with @JvmField
• Thinking @JvmStatic applies to properties
• Assuming it changes Kotlin class types

2. Which of the following is the correct way to expose a Kotlin property as a public field accessible directly from Java?

easy

A. Annotate the property with @JvmStatic

B. Annotate the property with @JvmField

C. Declare the property as val without annotations

D. Use @JvmOverloads annotation

Solution

1. Step 1: Identify the annotation for exposing fields

   @JvmField exposes Kotlin properties as public fields for direct Java access, bypassing getters/setters.

2. Step 2: Eliminate other options

   @JvmStatic applies to functions, not properties. @JvmOverloads is for default parameters. val alone does not expose as field.

3. Final Answer:

   Annotate the property with @JvmField -> Option B

4. Quick Check:

   @JvmField = public field in Java [OK]

Hint: Use @JvmField to expose properties as fields [OK]

Common Mistakes:

• Using @JvmStatic on properties
• Assuming val exposes public field automatically
• Confusing @JvmOverloads with field exposure

3. Given the Kotlin code below, what will be the output when called from Java?

class Example {
    companion object {
        @JvmStatic
        fun greet() = "Hello from static"

        fun greetInstance() = "Hello from instance"
    }
}

// Java code:
System.out.println(Example.greet());
System.out.println(Example.Companion.greetInstance());

medium

A. Compilation error\nHello from instance

B. Hello from static\nCompilation error

C. Compilation error\nCompilation error

D. Hello from static\nHello from instance

Solution

1. Step 1: Understand @JvmStatic effect on Java calls

   @JvmStatic makes greet() callable as a static method on Example class directly from Java.

2. Step 2: Understand companion object function call

   greetInstance() is not annotated, so Java must call it via Example.Companion instance.

3. Final Answer:

   Hello from static\nHello from instance -> Option D

4. Quick Check:

   @JvmStatic allows direct static call, others via Companion [OK]

Hint: @JvmStatic = call directly on class; else use Companion [OK]

Common Mistakes:

• Assuming all companion functions are static in Java
• Trying to call unannotated functions as static
• Ignoring the Companion object in Java calls

4. Identify the error in the Kotlin code below if the goal is to allow Java code to access count as a public field:

class Counter {
    companion object {
        var count = 0
    }
}

medium

A. Missing @JvmField on count

B. Missing @JvmStatic on count

C. Companion object cannot have properties

D. count must be declared as val not var

Solution

1. Step 1: Understand property exposure to Java

   To expose a Kotlin property as a public field in Java, it must be annotated with @JvmField.

2. Step 2: Check annotations and property modifiers

   @JvmStatic applies to functions, not properties. Companion objects can have properties. var is allowed.

3. Final Answer:

   Missing @JvmField on count -> Option A

4. Quick Check:

   Expose property as field = use @JvmField [OK]

Hint: Use @JvmField on properties for Java field access [OK]

Common Mistakes:

• Using @JvmStatic on properties
• Thinking companion objects can't have properties
• Confusing var and val for Java exposure

5. You want to create a Kotlin utility class with a companion object that has a constant integer MAX accessible as a static field from Java, and a function printMax() callable as a static method from Java. Which is the correct Kotlin code?

hard

A. class Utils {
companion object {
@JvmField
val MAX = 100
@JvmStatic
fun printMax() = println(MAX)
}
}

B. class Utils {
companion object {
val MAX = 100
fun printMax() = println(MAX)
}
}

C. class Utils {
companion object {
@JvmStatic
val MAX = 100
@JvmField
fun printMax() = println(MAX)
}
}

D. class Utils {
companion object {
const val MAX = 100
fun printMax() = println(MAX)
}
}

Solution

1. Step 1: Expose constant as static field

   Use @JvmField on val MAX to expose it as a static field in Java.

2. Step 2: Expose function as static method

   Use @JvmStatic on printMax() to make it callable as a static method from Java.

3. Step 3: Verify other options

   class Utils { companion object { val MAX = 100 fun printMax() = println(MAX) } } lacks annotations, so Java calls require Companion. class Utils { companion object { @JvmStatic val MAX = 100 @JvmField fun printMax() = println(MAX) } } swaps annotations incorrectly. class Utils { companion object { const val MAX = 100 fun printMax() = println(MAX) } } uses const val but no @JvmStatic on function.

4. Final Answer:

   The code with @JvmField on MAX and @JvmStatic on printMax() -> Option A

5. Quick Check:

   @JvmField for fields, @JvmStatic for static methods [OK]

Hint: Use @JvmField for fields and @JvmStatic for methods [OK]

Common Mistakes:

• Swapping @JvmField and @JvmStatic annotations
• Omitting annotations and expecting static access
• Using const val without @JvmStatic on functions