📌  相关文章
📜  Java互操作性——从 Kotlin 调用Java

📅  最后修改于: 2022-05-13 01:54:57.987000             🧑  作者: Mango

Java互操作性——从 Kotlin 调用Java

由于 Kotlin 的开发牢记与Java的互操作性。它使从内部使用Java代码变得更加容易。 Kotlin 类或函数可以以简单的方式引用Java类及其方法。

Java中的 Getter 和 Setter –

Java类中定义的所有类型的 getter 和 setter在 Kotlin 中表示为属性。因此，要访问Java类的数据成员的 getter 和 setter，它必须在 Kotlin 中作为属性进行引用。
声明为 myjava 的Java文件。Java

Java
// Java class
public class myjava {
  private int value;
  public int getValue(){
       return value;
  }
  public void setValue(int value){
       this.value = value;
  }
}

Java
// Kotlin file
fun main(){
   val obj = myjava()
   obj.value = 5 // This will call the setter function
   println(obj.value) // This will call the getter function
}

Java
// Java code
public class myjava {
    public int add(int a, int b){
        return a+b;
    }
}

Java
// Kotlin file
fun main(args: Array) {
    val obj = myjava()
    val ans = obj.add(4, 5)
    println("The sum of two numbers is "+ans)
}

Java
// Java Code
package mypackage;
    public class myjava {
    public static void display() {
        System.out.println("Call successful")
    }
}

Java
// declare kotlin package
package myktpackage
// import java class using java package
import mypackage.myjava 
 
fun main(args: Array) {
    // calling static member of java class
    val str = myjava.display()
    println(str)
}

Java
// Java Code
public class myjava {
    int result = 0;
    public int compute(int[] array)
    {
        for(int a: array){
            result = result + a;
        }
        return result;
    }
}

Java
// Kotlin code
fun main(args: Array) {
    // Kotlin code
    val obj = myjava()
    val array = intArrayOf(1, 2, 3, 4, 5, 6)
    var sum = obj.compute(array)
    println("The sum of an array is "+sum)
}

Java
// Java code
public class myjava {
    public void myfunc(String str,int... numbers) {
        System.out.println("Passed string is " + str);
        for (int n : numbers) {
            System.out.print(" "+n);
        }
    }
}

Java
// Kotlin code
fun main(args: Array) {
    val obj = myjava()
    val array = intArrayOf(10, 20, 30)
    obj.myfunc("Geeks", *array)
}

Kotlin 文件声明为 mykotlin.kt

Java

// Kotlin file
fun main(){
   val obj = myjava()
   obj.value = 5 // This will call the setter function
   println(obj.value) // This will call the getter function
}

输出： 

5

方法 -

从 Kotlin 中调用Java方法是一个简单的概念。在Java和 Kotlin 中提供的参数类型相同，函数的返回类型也是如此。此规则的唯一例外是 void 返回类型。 Java中返回类型为 void 的函数在 Kotlin 中返回Unit类型。所以这个值可以存储在 Kotlin 中，因为 Unit 作为一种类型存在。
声明为 myjava 的Java文件。Java

Java

// Java code
public class myjava {
    public int add(int a, int b){
        return a+b;
    }
}

Kotlin 文件声明为 mykotlin.kt

Java

// Kotlin file
fun main(args: Array) {
    val obj = myjava()
    val ans = obj.add(4, 5)
    println("The sum of two numbers is "+ans)
}

输出： 

The sum of two numbers is 9

注意 – Kotlin 的一些关键字很可能被用作Java中的有效标识符。例如 - any、sealed、object 等。如果发生这种情况，则在 Kotlin 中使用标识符，将它们括在反引号字符(`) 中。
例如，如果Java类 XYZ 恰好有一个名为 any 的方法，那么该方法可以在 Kotlin 中调用为： 

obj.`any`() // obj is the instance of the class XYZ

静态成员 –

Java中类的静态成员成为Kotlin 中伴随对象的成员。但是，这些伴随对象不能直接在表达式中使用。要访问，其成员使用Java中定义的成员的完全限定名称。
声明为 myjava 的Java文件。Java

Java

// Java Code
package mypackage;
    public class myjava {
    public static void display() {
        System.out.println("Call successful")
    }
}

Kotlin 文件声明为 mykotlin.kt

Java

// declare kotlin package
package myktpackage
// import java class using java package
import mypackage.myjava 
 
fun main(args: Array) {
    // calling static member of java class
    val str = myjava.display()
    println(str)
}

输出： 

Call successful

Java数组 –

Kotlin 支持数组的不变形式，即在 Kotlin 中不能将特定类型的数组分配给 Any 类型的数组，这与可以分配给 Object 类型的数组的Java数组不同。
此外，Kotlin 不支持将子类类型的数组分配给超类类型的数组。
现在，由于 Kotlin 不提供原始类型的数组，它提供了几个专门的类来表示Java中的原始类型数组。这些类与 Array 类没有关系，它们被编译成原始的Java数组以获得最佳性能。无论以何种方式使用数组，这种到字节码的转换都不会引入额外的开销。
声明为 myjava 的Java文件。Java

Java

// Java Code
public class myjava {
    int result = 0;
    public int compute(int[] array)
    {
        for(int a: array){
            result = result + a;
        }
        return result;
    }
}

Kotlin 文件声明为 mykotlin.kt

Java

// Kotlin code
fun main(args: Array) {
    // Kotlin code
    val obj = myjava()
    val array = intArrayOf(1, 2, 3, 4, 5, 6)
    var sum = obj.compute(array)
    println("The sum of an array is "+sum)
}

输出： 

The sum of an array is 21

Java可变参数 –

Java支持函数中可变长度参数的概念，即当事先不知道函数的参数数量但知道它们的类型时，我们声明一个可变参数。 Kotlin 不提供 varargs 参数，但是，为了与Java完全兼容，它支持特殊的扩展运算符(*) 来调用具有 varargs 参数的函数。
声明为 myjava 的Java文件。Java

Java

// Java code
public class myjava {
    public void myfunc(String str,int... numbers) {
        System.out.println("Passed string is " + str);
        for (int n : numbers) {
            System.out.print(" "+n);
        }
    }
}

Kotlin 文件声明为 mykotlin.kt

Java

// Kotlin code
fun main(args: Array) {
    val obj = myjava()
    val array = intArrayOf(10, 20, 30)
    obj.myfunc("Geeks", *array)
}

输出： 

Passed string is Geeks
 10 20 30

Java和 Kotlin 映射类型 –

Kotlin 中的类型与Java中的类型不同。然而，为了保持互操作性，Kotlin 提供了从Java类型到 Kotlin 类型的映射。这种映射发生在编译时，并且在运行时没有观察到性能的显着变化。
Java原始类型映射到以下原始类型：

Java TypeKotlin Type
bytekotlin.Byte
shortkotlin.Short
intkotlin.Int
longkotlin.Long
charkotlin.Char
floatkotlin.Float
doublekotlin.Double
booleankotlin.Boolean


Java.lang 包中定义的一些内置类也映射到 Kotlin 类。

Java TypeKotlin Type
java.lang.Objectkotlin.Any!
java.lang.Cloneablekotlin.Cloneable!
java.lang.Comparablekotlin.Comparable!
java.lang.Enumkotlin.Enum!
java.lang.annotationkotlin.Annotation!
java.lang.CharSequencekotlin.CharSequence
java.lang.Stringkotlin.String!
java.lang.Numberkotlin.Number!
java.lang.Throwablekotlin.Throwable!


Java 原始数据类型的装箱类型映射到 Kotlin 中的可为空类型。

Java TypeKotlin Type
java.lang.Bytekotlin.Byte?
java.lang.Shortkotlin.Short?
java.lang.Integerkotlin.Int?
java.lang.Longkotlin.Long?
java.lang.Characterkotlin.Char?
java.lang.Floatkotlin.Float?
java.lang.Doublekotlin.Double?
java.lang.Booleankotlin.Boolean?