Interoperabilidad de Java: llamar a Kotlin desde Java

Cuando se desarrolló Kotlin, funcionaba únicamente en JVM , por lo tanto, proporciona un conjunto completo de características que hacen que llamar a Kotlin desde Java sea bastante fácil. Por ejemplo, los objetos de las clases de Kotlin se pueden crear fácilmente y sus métodos se pueden invocar en los métodos de Java. Sin embargo, existen algunas reglas sobre cómo se puede usar el código Kotlin en Java .

Propiedades de Kotlin –

Una propiedad en Kotlin se define en Java como un campo privado con el mismo nombre que el de la propiedad, y una función getter y setter , con get y set antepuestos al nombre de la propiedad. Este campo privado existe en la clase java generada a partir del archivo kotlin.
Por ejemplo, la propiedad var age: Int , se compila en el siguiente código en Java:

private int age;
  
public int getAge(){
  return age;
}
public void setAge(int age){
  this.age = value;
}

Se puede acceder a estas propiedades utilizando el objeto de la clase, de la misma forma que se hace en Java. Sin embargo, si el nombre de la propiedad comienza con is , la palabra clave get se omite en el nombre de la función getter .

Funciones a nivel de paquete:

Todas las funciones definidas en un archivo Kotlin, dentro de un paquete, se compilan en métodos estáticos en Java dentro de una clase cuyo nombre de clase es una combinación del nombre del paquete y el nombre del archivo .

Por ejemplo, si hay un paquete llamado kotlinPrograms y un archivo Kotlin llamado firstProgram.kt con el siguiente contenido.

// Kotlin file
  
package kotlinPrograms
  
class myClass {
  
  fun add(val a:Int, val b:Int): Int {
   return a+b;
 }
}

Esta función se puede invocar en Java usando la siguiente sintaxis:

// Java
new kotlinPrograms.firstProgram.myClass()
kotlinPrograms.FirstProgramkt.add(3, 5);

Podemos cambiar el nombre de la clase Java generada usando la anotación @JvmName .

// Kotlin file
@file : Jvmname("Sample")
  
package kotlinPrograms
  
class myClass {
  
  fun add(val a:Int, val b:Int): Int {
   return a+b;
 }
}

Esta función se puede invocar en Java usando la siguiente sintaxis:

// Java
new kotlinPrograms.firstProgram.myClass()
kotlinPrograms.Sample.add(3, 5);

Sin embargo, tener varios archivos con el mismo nombre es lógicamente un error. Para superar este problema, Kotlin brinda a su compilador la capacidad de crear una clase de fachada que tiene un nombre particular y contiene todas las declaraciones de todos los archivos con el mismo nombre. Para permitir la creación de una clase de fachada de este tipo, la anotación @JvmMultiFileClass en todos los archivos.

Ejemplo

// Kotlin code
@file:JvmName("Sample")
@file:JvmMultiFileClass
  
package sample.example
  
fun print(){.......}

Otro archivo Kotlin –

// Kotlin code
@file:JvmName("Sample")
@file:JvmMultiFileClass
  
package sample.example
  
fun printString(){.......}

Ambas funciones se pueden invocar en Java usando la siguiente sintaxis:

// Java calling statements
sample.example.Sample.print()
sample.example.Sample.printString()

campos estáticos –

Las propiedades en Kotlin que se declaran dentro de un objeto con nombre o un objeto complementario se usan como campos estáticos en Java. Para acceder a estos campos en Java, estos deben anotarse con la anotación @JvmField , el modificador lateinit o deben declararse con un modificador const .

Ejemplo :

// filename Program.kt
  
// Property in a companion object
class abc{
 companion object{
      @JvmField
      val x = 5;
  }
}
  
// A constant property
const val y = 5;

//Java Usage
abc.x
Programkt.y

Métodos estáticos –

Los métodos definidos a nivel de paquete siempre se generan como métodos estáticos en el archivo Java. Además, los métodos definidos en objetos con nombre y objetos complementarios, si se anotan con la anotación @JvmStatic , se generan como métodos estáticos. Esta anotación declara que la siguiente función es una función de clase.

Ejemplo para el objeto complementario

// filename Programs.kt
class abc {
  companion object {
     @JvmStatic fun add(val a:Int, val b:Int):Int{
        return a+b;
      }
     fun sub(val a:Int, val b:Int):Int{
        return a-b;
      }
   }
}

//Java usage
abc.add(); // works fine
abc.sub(); // error: not a static method
abc.Companion.add(); // instance method remains
C.Companion.sub(); // the only way it works

Del mismo modo, funciona para el objeto con nombre.

Campos de instancia –

Kotlin proporciona una función para usar una propiedad como un campo de instancia en Java. Para hacer esto, anote la propiedad con la anotación @JvmField . Estos campos de instancia tienen la misma visibilidad que la propiedad de Kotlin. Sin embargo, la propiedad debe tener un campo de respaldo y no debe declararse con los modificadores private , open , const y override .

Ejemplo

// Kotlin code
class ABC(c: Int){
 @JvmField val id = c
}

Ahora se puede acceder a esta propiedad en Java como

ABC obj = new ABC(5);
System.out.println(obj.id);

Excepciones marcadas

Todas las excepciones en Kotlin están desmarcadas. Por lo tanto, las firmas de Java de las funciones de Kotlin no declaran ni manejan las excepciones lanzadas. Para superar este problema, la función de Kotlin se debe anotar con la anotación @Throws que especifica la excepción que se lanzará. En este caso, la firma de Java también declarará la función que se lanzará.

Ejemplo

// A sample Kotlin function
  
// filename program.kt
package Sample
  
fun print(){
 throws IOException()
}

// Java code trying to call the above  function
try {
    Sample.Program.print(); 
    }
   // This statement causes error because does not declare IOexception in throws list
   catch(IOException e) { 
}

Entonces, para resolver el error, declaramos la anotación @Throws en la parte superior.

// Overcoming the problem with @Throws annotation
package Sample
  
@Throws(IOException::class)
fun print()
{
throws IOException()
}