val kotlinList = listOf(1, 2, 3, 4)
//Java原生的ArrayList
val javaList = ArrayList<Int>()
for (item in kotlinList) {
javaList.add(item)
}
操作Java原生的集合类跟Kotlin中使用类没有什么区别。
假如我们有这样一个Person类。
package com.dengyin2000.java;
public class Person {
private String name;
private Long id;
private boolean isFemale;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public boolean isFemale() {
return isFemale;
}
public void setFemale(boolean female) {
isFemale = female;
}
}
那么在Kotlin中要怎样使用呢?
val person = Person()
person.id = 1
person.name = "Denny"
person.isFemale = false
println("Person(id=${person.id}, name=${person.name}, isFemale=${person.isFemale})")
println函数中的person类调用的是Person类的getter,上面属性设置实际上调用的是Person类的setter方法。
Java声明的类型在Kotlin中会被特别对待并称为平台类型(platform types),对于这种类型的空检查会放宽,这样做就使得跟Java的调用方式一致,但是Java中的任何引用都可能为null,这样我们使用Kotlin调用来自Java的对象的时候就有可能会出现空安全的问题。例如:
val person = Person()
person.id = 1
person.isFemale = false
println(person.name.substring(1))
person.name运行时为null,当然调用的时候会person.name.substring(1)时会发生异常。
异常
当然为了避免null的问题,我们可以使用Koltin的安全调用:
println(person.name?.substring(1)) //打印null
平台类型不能在程序中显式表述,因此在语言中没有相应语法。然而,编译器和 IDE 有时需要(在错误信息中、参数信息中等)显示他们,所以我们用一个助记符来表示他们:
T! : 表示 T 或者 T?
(Mutable) Collection<T>! : 表示 “可以可变或不可变、可空或不可空的 T 的 Java 集合”
Array<(out) T>! : 表示“可空或者不可空的 T(或 T 的子类型)的 Java 数组”
Kotlin 特殊处理一部分 Java 类型。这样的类型不是“按原样”从 Java 加载,而是 映射 到相应的 Kotlin 类型。映射只发生在编译期间,运行时表示保持不变。怎么理解这句话呢?就是说在Kotlin中加载这些Java的类型时,编译器会转成对应的Kotlin类型,这样就能用到Koltin中对Java的增强功能(扩展函数等)。
Java的原生类型映射到对应的Kotlin类型
Java中的一些内置类型也会做相应的映射
Java的基本类型的包装类对应到可空额Kotlin类型
例如:List<java.lang.Integer> 在Kotlin会变成List<Int!>
集合类型在 Kotlin 中可以是只读的或可变的,因此 Java 集合类型作如下映射:(下表中的所有 Kotlin 类型都在 kotlin.collections包中):
类型参数的Java类型映射到Kotlin中的平台类型
Java的数组映射
Kotlin 的泛型与 Java 有点不同。当将 Java 类型导入 Kotlin 时,我们会执行一些转换:
Kotlin中使用Java泛型
和 Java 一样,Kotlin 在运行时不保留泛型,即对象不携带传递到他们构造器中的那些类型参数的实际类型。
假如我们有一个这样的类,有一个可变参数的静态方法:
package com.dengyin2000.java;public class StringUtils {
public static String connect(String... strings) {
StringBuilder sb = new StringBuilder();
for (String string : strings) {
sb.append(string).append(",");
}
return sb.toString();
}
}
因为Kotlin并没有可变类型,所以我们需要使用 *
来传递一个String数组来达到相应的目的:
val listOf = arrayOf("Denny", "Deng")
println(StringUtils.connect(*listOf)) //打印Denny,Deng
在Kotlin中,所有的异常都是Unchecked Exception,也就是说编译器不会强迫你捕获任何的异常,但是在Java中你是需要捕获Checked Exception。如下:
Java Checked Exception
我们需要try catch保护起来。
但是在Kotlin中不需要try catch,只是路过抛出来你没有try catch的话,程序还是会挂。
当 Java 类型导入到 Kotlin 中时,类型 java.lang.Object 的所有引用都成了 Any。而因为 Any 不是平台指定的,它只声明了 toString()、hashCode() 和 equals() 作为其成员, 所以为了能用到 java.lang.Object 的其他成员,你需要如下手段:
需要把对象转成 java.lang.Object
来使用:
val p = Person()
(p as java.lang.Object).wait()
要取得对象的 Java 类,我们可以在类引用上使用 java 扩展属性,它是Kotlin的反射类kotlin.reflect.KClass的扩展属性。
val fooClass = foo::class.java
上面的代码使用了自 Kotlin 1.1 起支持的绑定类引用。我们也可以使用 javaClass 扩展属性。
val fooClass = foo.javaClass
要覆盖 clone()
,需要继承 kotlin.Cloneable
:
class Example : Cloneable {
override fun clone(): Any { …… }
}
我们可以使用 instance::class.java
、 ClassName::class.java
或者 instance.javaClass
通过 java.lang.Class
来进入 Java 的反射类 java.lang.Class
, 之后我们就可以使用Java中的反射的功能特性了。
SAM = single abstract method,在Java中被称为SAM类型。例如:Runnable接口。在Kotlin中我们可以这样创建SAM接口实例:
val runnable = Runnable { println("SAM") }
一些 Kotlin 关键字在 Java 中是有效标识符:in、 object、 is等等。
如果一个 Java 库使用了 Kotlin 关键字作为方法,我们可以通过反引号(`)字符转义它来调用该方法。例如我们有个Java类,其中有个is方法:
public class StringUtils {
public static boolean is(String value, String value1) {
return value.equals(value1);
}
}
我们需要在Kotlin中需要这样调用:
println(StringUtils.`is`("a", "b")) //打印false
Kotlin最终还是会编译成class,所以要怎么调Kotlin其实就是要看Kotlin翻译成的class是怎样的。Kotlin可以通过一些annotation来调整Kotlin翻译成的class结果。
假如我们有下面一个Kotlin的类:
class Student{
var id: Long = -1L
var name: String = "Denny"
var isFemale: Boolean = false
}
我们通过Intellij IDEA的Tools->Kotlin->Show Kotlin Bytecode->Decompile可以看到生成的Java的代码如下:
public final class Student { private long id = -1L;
@NotNull
private String name = "Denny";
private boolean isFemale;
public final long getId() {
return this.id;
}
public final void setId(long var1) {
this.id = var1;
}
@NotNull
public final String getName() {
return this.name;
}
public final void setName(@NotNull String var1) {
Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
this.name = var1;
}
public final boolean isFemale() {
return this.isFemale;
}
public final void setFemale(boolean var1) {
this.isFemale = var1;
}
}
看到Java代码,你应该知道怎么调用了吧。
在 package com.dengyin2000.kotlintest1
包里面的 StringUtil.kt
文件中生命的所有函数、属性、都将编译成一个名为 com.dengyin2000.kotlintest1.StringUtilKt
的Java类的静态方法。假如我们有一个下面的Kotlin文件:
package com.dengyin2000.kotlintest1
fun sayHello() {
println("Hello ${name}")
}
val name:String = "Denny"
fun String.firstChar() :Char{
return this[0]
}
fun main(args: Array<String>) {
println("Denny".firstChar())
}
通过上面的方式可以看到生成的Java代码如下:
package com.dengyin2000.kotlintest1;
import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;
public final class StringUtilKt {
@NotNull
private static final String name = "Denny";
public static final void sayHello() {
String var0 = "Hello " + name;
System.out.println(var0);
}
@NotNull
public static final String getName() {
return name;
}
public static final char firstChar(@NotNull String $receiver) {
Intrinsics.checkParameterIsNotNull($receiver, "$receiver");
return $receiver.charAt(0);
}
public static final void main(@NotNull String[] args) {
Intrinsics.checkParameterIsNotNull(args, "args");
char var1 = firstChar("Denny");
System.out.println(var1);
}
}
可以看到String的扩展函数第一个参数变成了接受者。如果我们想要修改生成的Java对象的名称,我们可以使用 @file:JvmName
注解,如下:
@file:JvmName("Strings")
package com.dengyin2000.kotlintest1
fun sayHello() {
println("Hello ${name}")
}
val name:String = "Denny"
fun String.firstChar() :Char{
return this[0]
}
fun main(args: Array<String>) {
println("Denny".firstChar())
}
这样生成的类名变成了Strings。
如果我们不希望某个属性生成getter setter方法,我们希望生成一个实例字段的话,我们可以使用 @JvmField
注解标注Kotlin的属性。如下:
class Student{ var id: Long = -1L
var name: String = "Denny"
var isFemale: Boolean = false
@JvmField
var grade: Int = 0
}
生成的Java如下:
public final class Student {
private long id = -1L;
@NotNull
private String name = "Denny";
private boolean isFemale;
@JvmField
public int grade;
public final long getId() {
return this.id;
}
public final void setId(long var1) {
this.id = var1;
}
@NotNull
public final String getName() {
return this.name;
}
public final void setName(@NotNull String var1) {
Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
this.name = var1;
}
public final boolean isFemale() {
return this.isFemale;
}
public final void setFemale(boolean var1) {
this.isFemale = var1;
}
}
在伴生对象和命名对象(object 类)的属性上使用 @JvmField
的区别如下:
class Student{
var id: Long = -1L
var name: String = "Denny"
var isFemale: Boolean = false
@JvmField
var grade: Int = 0
companion object {
var teachName = "Sally"
@JvmField
var schoolMaster = "Noah"
}
}
生成的Java代码如下:
public final class Student { private long id = -1L;
@NotNull
private String name = "Denny";
private boolean isFemale;
@JvmField
public int grade;
@NotNull
private static String teachName = "Sally";
@JvmField
@NotNull
public static String schoolMaster = "Noah";
public static final Student.Companion Companion = new Student.Companion((DefaultConstructorMarker)null);
public final long getId() {
return this.id;
}
public final void setId(long var1) {
this.id = var1;
}
@NotNull
public final String getName() {
return this.name;
}
public final void setName(@NotNull String var1) {
Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
this.name = var1;
}
public final boolean isFemale() {
return this.isFemale;
}
public final void setFemale(boolean var1) {
this.isFemale = var1;
}
public static final class Companion {
@NotNull
public final String getTeachName() {
return Student.teachName;
}
public final void setTeachName(@NotNull String var1) {
Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
Student.teachName = var1;
}
private Companion() {
}
// $FF: synthetic method
public Companion(DefaultConstructorMarker $constructor_marker) {
this();
}
}
}
调用方式如下:
String schoolMaster = Student.schoolMaster;
String teachName = Student.Companion.getTeachName();
类似的只要将伴生对象或者命名对象的的方法用 @JvmStatic
注释,这样就能生成Java的静态方法。Kotlin代码如下:
class Student{
var id: Long = -1L
var name: String = "Denny"
var isFemale: Boolean = false
@JvmField
var grade: Int = 0
companion object {
var teachName = "Sally"
@JvmField
var schoolMaster = "Noah"
@JvmStatic
fun sayHello() {
println("Hello world")
}
}
}
生成的Java代码如下:
public final class Student { private long id = -1L;
@NotNull
private String name = "Denny";
private boolean isFemale;
@JvmField
public int grade;
@NotNull
private static String teachName = "Sally";
@JvmField
@NotNull
public static String schoolMaster = "Noah";
public static final Student.Companion Companion = new Student.Companion((DefaultConstructorMarker)null);
public final long getId() {
return this.id;
}
public final void setId(long var1) {
this.id = var1;
}
@NotNull
public final String getName() {
return this.name;
}
public final void setName(@NotNull String var1) {
Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
this.name = var1;
}
public final boolean isFemale() {
return this.isFemale;
}
public final void setFemale(boolean var1) {
this.isFemale = var1;
}
@JvmStatic
public static final void sayHello() {
Companion.sayHello();
}
public static final class Companion {
@NotNull
public final String getTeachName() {
return Student.teachName;
}
public final void setTeachName(@NotNull String var1) {
Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
Student.teachName = var1;
}
@JvmStatic
public final void sayHello() {
String var1 = "Hello world";
System.out.println(var1);
}
private Companion() {
}
// $FF: synthetic method
public Companion(DefaultConstructorMarker $constructor_marker) {
this();
}
}
}
这样调用
Student.sayHello();
通常,如果你写一个有默认参数值的 Kotlin 函数,在 Java 中只会有一个所有参数都存在的完整参数签名的方法可见,如果希望向 Java 调用者暴露多个重载,可以使用 @JvmOverloads 注解。
该注解也适用于构造函数、静态方法等。它不能用于抽象方法,包括在接口中定义的方法。
Kotlin的类如下:
class Animal @JvmOverloads constructor(name: String, type: Int = 0){
fun talk(name: String, by: Int = 1) {
}
@JvmOverloads
fun talkTo(name: String, by: Int = 1) {
}
}
生成的Java代码如下:
public final class Animal { public final void talk(@NotNull String name, int by) {
Intrinsics.checkParameterIsNotNull(name, "name");
}
// $FF: synthetic method
// $FF: bridge method
public static void talk$default(Animal var0, String var1, int var2, int var3, Object var4) {
if ((var3 & 2) != 0) {
var2 = 1;
}
var0.talk(var1, var2);
}
@JvmOverloads
public final void talkTo(@NotNull String name, int by) {
Intrinsics.checkParameterIsNotNull(name, "name");
}
// $FF: synthetic method
// $FF: bridge method
@JvmOverloads
public static void talkTo$default(Animal var0, String var1, int var2, int var3, Object var4) {
if ((var3 & 2) != 0) {
var2 = 1;
}
var0.talkTo(var1, var2);
}
@JvmOverloads
public final void talkTo(@NotNull String name) {
talkTo$default(this, name, 0, 2, (Object)null);
}
@JvmOverloads
public Animal(@NotNull String name, int type) {
Intrinsics.checkParameterIsNotNull(name, "name");
super();
}
// $FF: synthetic method
@JvmOverloads
public Animal(String var1, int var2, int var3, DefaultConstructorMarker var4) {
if ((var3 & 2) != 0) {
var2 = 0;
}
this(var1, var2);
}
@JvmOverloads
public Animal(@NotNull String name) {
this(name, 0, 2, (DefaultConstructorMarker)null);
}
}
生成了两个构造方法,talkTo也生成了两个方法,talk就只有一个;
重载构造方法
重载方法
Kotlin 的可见性与Java的可见性的映射关系如下表所示:
可见性
在Kotlin中是不需要显示的try catch Checked Exception的,比如下面这个throwException方法:
class Animal @JvmOverloads constructor(name: String, type: Int = 0){
fun talk(name: String, by: Int = 1) {
}
@JvmOverloads
fun talkTo(name: String, by: Int = 1) {
}
fun throwException() {
throw Exception("hahaha")
}
}
在Java中调用不需要try catch。
no try catch
如果你想让Java调用时需要主动try catch的话,那你需要使用 @Throws(Exception::class)
注解。
注解
这时候Java调用方就需要try catch了。
关注我获取更多知识或者投稿
作者:dengyin2000
链接:https://www.jianshu.com/p/d8a115427242