Since Kotlin doesn't have primitives, how could this interface be implemented?
public interface A {
@NotNull Object get(@NotNull Integer i);
@NotNull Object get(int i);
}
I cannot change the Java code since it's a compiled class file in a binary library.
If a single implementation, as in @zsmb13's answer, is not enough for you and you need separate implementations for the two methods in Kotlin, then you can add an intermediate interface overriding the method accepting Integer with a nullable parameter:
private interface IntermediateA : A {
override fun get(i: Int?): Any
}
Implementing this interface instead of the original A, the Kotlin compiler will distinguish the two methods, allowing you to override them as follows:
class C : IntermediateA {
override fun get(i: Int) = "primitive"
override fun get(i: Int?) = "boxed"
}
val a: A = C()
println(a.get(1)) // primitive
println(a.get(1 as Int?)) // boxed
If you had access to the Java code, you could fix this by adding a nullability annotation to the method accepting the boxed type:
Object get(@Nullable Integer i);
The Kotlin compiler understands different kinds of nullability annotations, here's the list.
Implementing just one method that takes Int as its parameter works, and can be called from either Kotlin or Java.
class B : A {
override fun get(i: Int): Any {
return "something"
}
}
If you decompile the bytecode, you'll see that the Kotlin compiler is smart enough to create both methods, with one of them just redirecting to the real implementation.
One possible problem is that you can't make the method take Int?, and it will crash with a NullPointerException on the .intValue() call if it's called from Java like so:
B b = new B();
Integer i = null;
b.get(i);
I'm not sure if there's a way to solve for that use case.
Edit: hotkey's answer has rest of the answers in it.
int or Integer? How to get that differentiation in Kotlin?
Int to handle primitives and another that takes Int? that handles the boxed type.Int provided it's value is not null.
@Nullable. With no access to the Java code, it seems to be possible only with an intermediate Java interface, see the other answer.Int? paramater type).In Kotlin, we can declare:
IntInt?Your interface can be simplified to:
private interface ModifiedA : A {
override fun get(i: Int?): Any
}
In Kotlin, if you implement this modified interface then Kotlin will provide you two methods to override. One for primitive type and another one for boxed type.
class ImplementationOfA : ModifiedA {
override fun get(i: Int)
override fun get(i: Int?)
}
I write a simple demo in Java.
then convert it to Kotlin with Kotlin plugins in IntelliJ IDEA or Android Studio.
add these lines to implement interface in kotlin
class abc : AppCompatActivity(), interface 1, interface 2,
{
override fun get(i: Int?): Any
}
AppCompatActivity relevant?
fun get(i: Integer /* or Integer? */) = ...; fun get(i: Int) = ...?