Kotlin反射与Java的互操作性

Question

What are the caveats that a developer should be aware of while writing reflective code that works both with Java and Kotlin?

For example, I have an existing library that uses reflection and it works well with Java. However, when I use the same with Kotlin, my reflective code doesn't seem to pick up the annotations on fields.

Here are some of the differences that I noticed.

1. Acquiring a Class instance

// Example 1.1 - Java
Class<?> userClass = User.class;         // From a class name
userClass = userInstance.getClass();     // OR from an instance

Getting a Java class instance in Kotlin

// Example 1.2 - Kotlin
val userClass = userInstance.javaClass   // From an instance

I'm unable to use the .class facility or the .getClass() method in Kotlin as we do in Java.

2. Delegates

When I use delegated properties in a Kotlin class, the properties that I retrieve have the $delegate suffix. This is a bit contrary to the fields that we get in Java (I do understand Kotlin does not have fields, only properties). How does this affect meta-programming?

However, with delegates I see that most of the methods retain their behavior as they do in Java. Are there any other differences that I have to be aware of?

Making Java and Kotlin interoperable for me would require understanding about 1 discussed above, plus other limitations / differences that Kotlin brings to meta-programming.

Answer 1

For example, I have an existing library that uses reflection and it works well with Java. However, when I use the same with Kotlin, my reflective code doesn't seem to pick up the annotations on fields.

Can it be because the fields are private now?

Anyway, there are issues with annotations on fields at the moment, this will be fixed in on of the upcoming milestones.

Some other relevant issues:

• https://youtrack.jetbrains.com/issue/KT-5967
• https://youtrack.jetbrains.com/issue/KT-4169
• https://youtrack.jetbrains.com/issue/KT-3625

I'm unable to use the .class facility or the .getClass() method in Kotlin as we do in Java.

Only the syntax is different: javaClass<C>() works exactly the same as C.class , and x.javaClass does the same thing as x.getClass()

When I use delegated properties in a Kotlin class, the properties that I retrieve have the $delegate suffix.

Minor correction: the fields have the $delegate suffix, not the properties.

However, with delegates I see that most of the methods retain their behavior as they do in Java. Are there any other differences that I have to be aware of?

The docs here give you a detailed description of how delegated properties are implemented.

Making Java and Kotlin interoperable for me would require understanding about 1 discussed above, plus other limitations / differences that Kotlin brings to meta-programming.

The more your Kotlin code resembles Java code, the smaller is the difference from the reflection point of view. If you write idiomatic Kotlin, eg use default parameter values, traits, properties, delegates, top-level functions, extensions etc, the classes you get differ from idiomatic Java, otherwise they are closely aligned.