Kotlin程序设计（扩展一）

**注意：**开启本视频学习前，需要先完成以下内容的学习：

• 请先完成《Kotlin程序设计》视频教程。
• 请先完成《JavaSE》视频教程。

Kotlin在设计时考虑到了与Java的互操作性，现有的Java代码可以自然地调用Kotlin代码，而Kotlin代码也可以轻松兼容Java的调用。在本扩展篇中，我们会讲解如何通过Kotlin调用Java代码。

Kotlin调用Java

我们先从最基本的内容说起，现在需要让Kotlin与Java互相兼容，并不是直接就可以使用的，我们还要遵循某些约定才可以使得Java兼容Kotlin的语法。

类的定义和使用

在Java中，最关键的就是类，我们来看看如何在Kotlin中进行使用。

我们在Java中定义的类型，可以非常轻松地被Kotlin使用，比如下面这个由Java语言定义的类型：

public class Student {
  	int age;
    String name;
}

在Kotlin中，我们可以直接使用这个类，就像是在Kotlin中定义的那样：

fun main() {
    val student: Student = Student()   //直接使用Java中的类型，无缝衔接
    student.name = "小明"
    println(student.name)  //这里得到的Java中的String类型，可以直接当做Kotlin中的使用
}

以及Kotlin中我们提到的一些基本类型，都可以与Java中的基本类型互相转换：

fun main() {
    val student = Student()
    val age: Int = student.age   //Java中的int/Integer对应了Kotlin中的Int
}

几乎Java中所有基本类型在Kotlin中都存在对应的类型，所以说直接转换为Kotlin支持的基本类型也是可以的。

包括我们在类中定义的方法，也可以在Kotlin中被当做函数使用：

public class Student {
    String name;

    public void hello() {
        System.out.println("大家好，我叫" + name);
    }
}

fun main() {
    val student = Student()
    student.name = "小明"
    student.hello()   //函数调用
}

注意，如果方法的返回类型是void，那么它对应的就是Kotlin中的Unit类型。

包括在Java中定义的构造方法，也可以被Kotlin当做构造函数使用，因为它们的语法其实差不多，可以很轻松完成兼容：

public class Student {
    String name;
    
    public Student(String name) {
        this.name = name;
    }
}

fun main() {
    val student = Student("小明")
}

可以看到，这些内容几乎是没有多少学习成本的，包括在Java类中定义的静态内容：

public class Student {
    public static void test() {
        System.out.println("我是测试静态函数");
    }
}

这些静态属性就像使用Kotlin中的伴生对象一样，可以直接通过类名进行调用，这跟Java中是一样的：

fun main() {
    Student.test()
}

还有，由于Kotlin与Java中的关键字存在差异，我们在Java中定义的某些属性名称可能会成为Kt的关键字：

import java.io.InputStream;
public class Student {
    InputStream in;  //Java中没有问题，因为in不是关键字
}

fun main() {
    val student = Student()
  	//在Kotlin中，由于in是关键字，因此我们需要对其进行转义来消除冲突
  	//使用``字符来完成转义
    student.`in` = FileInputStream("C://")
}

包括Java中的可变参数，也是可以直接兼容的：

public class Student {
    public void test(String... args) {
        
    }
}

我们也可以直接继承Java中提供的类型：

public class Student {

}

class ArtStudent: Student()   //语法与之前是一样的

在后续的学习中，我们再来继续认识更多高级的内容。

Getter和Setter

在Kotlin基础教程中我们说到，类中的成员属性可以具有自己的Getter和Setter函数，比如：

class Student {
    var name: String = ""
        get() = field
        set(value) {
            field = value
        }
}

这样我们就可以实现对于这个变量赋值和获取的进一步控制，比如我们希望在赋值时打印内容：

var name: String = ""
    get() = field
    set(value){
        println("我被赋值了！")   //由于get和set本质上编译后是函数，因此可以自定义
        field = value
    }

而我们知道，在Java中，一个类的属性并不能像这样去编写：

public class Student {
    String name;   //只能定义一个变量，非常简单
}

我们可以对Java中的这个属性进行封装，使得其支持像Kotlin中那样存在Getter和Setter函数：

public class Student {
    private String name;   //将name属性private掉

    public String getName() {  //自定义Get和Set方法设置name属性
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

fun main() {
    val student = Student()
    student.name = "小明"
    println(student.name)
}

这样编写之后，我们同样可以在Kotlin中直接使用对应属性的名称进行访问，但是这本质上是通过其Get和Set函数来完成的，在获取属性时，会调用getName()方法得到对应的结果，设置同理。

注意：这个Get和Set必须遵循命名规则，比如这里我们要为name属性添加Getter方法，那么必须要命名为get + Name这样的名称，来表示对name属性的命名，必须以get开头，而Setter必须以set开头。

如果返回值类型是一个Boolean类型，那么Getter方法名称需要以is开头，而Setter同上。

注意，由于此时name属性由于存在访问权限控制，无法被外部访问，如果我们去掉Setter或是Getter函数，将导致变量只能被赋值或是不可用，比如去掉set方法后：

注意： 如果直接去掉Getter方法，无论是否保留Setter方法，都会导致这个变量不可用，因为Kotlin不支持仅set-only属性。

空安全处理

由于在Java中的任何引用类型值都可能是null，这使得Kotlin对来自Java的对象进行空安全检测不太方便。因此，对于Java声明的类型会在Kotlin中以特定方式处理，我们称为平台类型。对于这种类型，空检查是放宽的，因此它们的安全保证与Java相同，也就是说部分情况下不会进行空安全检查。

比如下面这个例子：

public class Student {
    String name;   //默认情况下name属性的值就是null
}

fun main() {
    val student = Student()
  	//此时name在Kotlin中为平台类型，不会进行空安全检查，这里可以编译通过
    println(student.name.uppercase())
}

很明显，上面的代码出现了空指针异常，因为这里没有进行任何的空安全检查。

对于这种平台类型，IDEA会给我们明确指出，比如这里的name属性时String!类型的，它表示这个类型可能是Srting或String?的其中一种：

我们在接受这个属性的时候，由于其特殊性，也可以使用两种：

fun main() {
    val student = Student()
    val name: String = student.name  //直接使用不可空类型接受，但是可能会出错
    val name2: String? = student.name  //直接使用可空类型接受
  	test(student.name)  //函数同样适用此规则
}

fun test(str: String) {  }

如果我们使用了一个不可空类型接受到来自Java的null值，会直接得到一个空指针异常，这可以防止Kotlin的不可空变量持有空值，包括传递函数参数时也同样适用，总的来说，编译器在尽最大努力防止空值在Kotlin程序中传播。

注意，在某些情况下，持有可空注解的Java类型不会表现为平台类型，比如：

public class Student {
    @NotNull String name;  //由JetBrains提供的注解
}

这些注解包括：

• JetBrains（来自org.jetbrains.annotations包下的@@Nullable和@NotNull）
• JSpecify（org.jspecify.nullness）
• Android（com.android.annotations和android.support.annotations）
• JSR-305（javax.annotation）
• FindBugs（edu.umd.cs.findbugs.annotations）
• Eclipse（org.eclipse.jdt.annotation）
• Lombok（lombok.NonNull）
• RxJava 3（io.reactivex.rxjava3.annotations）

同样的，对于一些泛型类，也存在一些空类型检查问题，这里以List为例：

public class Student {
    List<String> exams;
}

fun main() {
    val student = Student()
    val exams1: MutableList<String?>? = student.exams  //支持多种方式
  	val exams2: MutableList<String?> = student.exams
  	val exams3: List<String?>? = student.exams
  	...
}

可以看到，在我们使用Java中提供的List时，会得到：

这里的(Mutable)List<String!>!包含了很多信息，我们依次来解读一下：

• 首先Mutable表示这个List可以是可变的也可以是不可变的，因为在Java中并没有明确划分可变或是不可变的数组。
• 然后这里的类型参数String和List都带有!表示他们都可以是可空类型也可以是不可空类型。

我们同样可以使用非空注解来提醒编译器这里一定不会为null防止被认定为平台类型：

public class Student {
    @NotNull List<String> exams;
}

以及在Java中的数组类型，对应的就是Kotlin中的Array类型：

public class Student {
    String[] exams;
}

由于数组在Java支持协变（这与Kotlin存在不同）因此，这里我们使用Java中的数组时，可以将其当做一个抗变或是协变的String类型进行使用：

fun main() {
    val student = Student()
    val exams1: Array<String>  = student.exams
    val exams2: Array<out String?>  = student.exams
    val exams3: Array<out String?>?  = student.exams
}

这里的到的Array可以是可空也可以是不可空，里面的类型参数String同样可以是可空或是不可空，并且可以是协变也可以是抗变的。

类型对照表

前面我们提到，在Kotlin中存在Java中相应的基本类型，我们在使用Java提供的类型时，可以直接转换使用：

Java类型	Java包装类型	Kotlin类型
byte	java.lang.Byte	kotlin.Byte
short	java.lang.Short	kotlin.Short
int	java.lang.Integer	kotlin.Int
long	java.lang.Long	kotlin.Long
char	java.lang.Character	kotlin.Char
float	java.lang.Float	kotlin.Float
double	java.lang.Double	kotlin.Double
boolean	java.lang.Boolean	kotlin.Boolean

注意，虽然Java类型可以映射到Kotlin对应的类型，但是平台类型性质依然保留：

public class Student {
    Integer age;
}

可以看到，对于Java中的包装类型Integer，这里虽然可以直接转换为Int类型，但是它依然可以是Int?或是Int这两种类型。只不过，对于Java中的基本类型来说，由于不存在null这种结果，因此我们可以安全的将其当做不可空类型使用：

public class Student {
    int age;
}

除了这些基本类型之外，实际上Kotlin中还有很多其他类型也可以直接映射：

Java类型	Kotlin类型
java.lang.Object	kotlin.Any!
java.lang.Cloneable	kotlin.Cloneable!
java.lang.Comparable	kotlin.Comparable!
java.lang.Enum	kotlin.Enum!
java.lang.annotation.Annotation	kotlin.Annotation!
java.lang.CharSequence	kotlin.CharSequence!
java.lang.String	kotlin.String!
java.lang.Number	kotlin.Number!
java.lang.Throwable	kotlin.Throwable!

集合类型在Kotlin中可以是只读的或可变的，因此Java的集合映射如下（此表中的所有Kotlin类型都定义在kotlin.collections包中）

Java类型	Kotlin只读类型	Kotlin可变类型	转换平台类型
Iterator<T>	Iterator<T>	MutableIterator<T>	(Mutable)Iterator<T>!
Iterable<T>	Iterable<T>	MutableIterable<T>	(Mutable)Iterable<T>!
Collection<T>	Collection<T>	MutableCollection<T>	(Mutable)Collection<T>!
Set<T>	Set<T>	MutableSet<T>	(Mutable)Set<T>!
List<T>	List<T>	MutableList<T>	(Mutable)List<T>!
ListIterator<T>	ListIterator<T>	MutableListIterator<T>	(Mutable)ListIterator<T>!
Map<K, V>	Map<K, V>	MutableMap<K, V>	(Mutable)Map<K, V>!
Map.Entry<K, V>	Map.Entry<K, V>	MutableMap.MutableEntry<K,V>	(Mutable)Map.(Mutable)Entry<K, V>!

以及数组的映射如下，基本类型的数组会被直接映射为基本类型专用的Array类型：

Java类型	Kotlin类型
int[]	kotlin.IntArray!
String[]	kotlin.Array<(out) String>!

注意，在Java中，这些类型可能存在一些静态属性，如果我们需要调用对应的静态属性，需要使用Java中类型的名称进行调用：

//在Integer中定义的静态方法
public static int parseInt(String s) throws NumberFormatException {
    return parseInt(s,10);
}

fun main() {
    Integer.parseInt("666")  //需要使用原本的名称，而不是转换之后的Int
}

泛型转换

Kotlin的泛型与Java型有点不同，当将Java类型导入Kotlin时，将完成以下转换：

• Java的通配符转换：
  • Foo<? extends Bar>成为Foo<out Bar!>!
  • Foo<? super Bar>成为Foo<in Bar!>!

public class Student {
    List<? extends Number> data;  //此时泛型上界为Number
    List<? super Integer> data2;  //此时泛型下界为Integer
}

当这些类型在Kotlin中使用时，会自动被划分为协变或抗变类型：

fun main() {
    val student = Student()
  	//Java中的泛型上界对应Kotlin的协变类型
    val data: MutableList<out Number> = student.data
  	//Java中的泛型下界对应Kotlin的抗变类型
    val data2: MutableList<in Int> = student.data2
}

由于在Kotlin中对in和out进行了严格的使用限制，因此无法像Java那样随意使用。

• Java的原始类型被转换为星形投影：
  • List当做List<*>!也就是List<out Any?>!

public class Student {
    List data;   //对List的原始使用
}

fun main() {
    val student = Student()
  	//在Kotlin中直接以Any?作为实际类型使用，因为没有明确具体类型
    val data: MutableList<Any?>? = student.data
}

与Java一样，Kotlin的泛型不会在运行时保留，也就是说对象不会带有任何实际类型参数的信息，详情请见基础篇。

运算符重载

由于Java不支持运算符重载，我们无法通过关键字支持像Kotlin这样的运算符重载，但是，只要符合我们前面所说的那些运算符重载函数名称的方法，依然可以作为运算符重载函数使用：

public class Student {
    public Student plus(Student other) {
        return this;
    }
}

可以看到，以上代码与Kotlin中+运算符重载函数的定义相同，满足规范，因此，在Kotlin中，可以直接支持使用：

fun main() {
    var student = Student()
    student = student + student
}

异常检查

在Kotlin中，所有异常都不会主动进行检查，这意味着编译器不会强迫您捕获任何异常。因此，当您调用声明了异常的Java方法时，Kotlin不会强制要求进行捕获：

public class Student {
    public void test() throws IOException {
        
    }
}

fun main() {
    var student = Student()
    student.test()
}

Object类型

当Java对象在Kotlin中使用时，Object类型的所有引用都会变成Any类型。由于Any类型不是特定于某一个平台的，考虑到对其他语言的兼容性，因此，它只声明toString()``hashCode()和equals()函数作为其成员，而在Java中，Object存在很多其他的成员方法：

public final native Class<?> getClass();
public final native void notify();
public final native void notifyAll();
...

如果需要让Object类中的其他成员方法可用，可以像下面这样：

fun main() {
    val student = Student()
  	//将student类型转换为Object再调用其
    (student as Object).wait()
}

不过，在Kotlin中不鼓励使用wait()和notify()等线程相关方法，使用JUC中提供的类型效果更佳（详情请见Java JUC篇视频教程）

如果我们要获取某个类的Class对象：

fun main() {
    val student = Student()
    val clazz: Class<Student> = student.javaClass  //使用.javaClass获取到对应的Java类对象
}

函数式接口

Kotlin支持Java的SAM转换，只要是Java中满足要求的函数式接口，都可以开箱即用：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

fun main() {
  	//使用Java中的Runnable接口
    val runnable: Runnable = Runnable {
        println("Hello World")
    }
}

包括我们在函数中一样可以像这样使用：

import java.util.concurrent.ThreadPoolExecutor

fun main() {
    val executor = ThreadPoolExecutor()
    // Java方法定义: void execute(Runnable command)
    executor.execute { println("This runs in a thread pool") }
}

Java调用Kotlin

前面我们介绍了Kotlin如何调用现成的Java代码，我们接着来看Java如何调用Kotlin代码。由于Java和Kotlin之间存在某些差异，在将Kotlin代码集成到Java中时需要注意很多东西。

对象属性

在Kotlin中定义的类型，到了Java中依然可以直接创建其对象：

class Student(var name: String)

public static void main(String[] args) {
    Student student = new Student("小明");   //Kt构造函数就是构造方法
}

只不过，对于类的属性，由于Kotlin中本质是以get和set函数的形式存在的，因此，我们只能使用对应的Getter和Setter方法来进行调用：

public static void main(String[] args) {
    Student student = new Student("小明");
    student.getName();
    student.setName("大明");   //set方法仅在属性为var时可用
}

如果实在是需要在Java中像使用普通变量那样，我们可以添加一个特殊的注解使其支持：

class Student(@JvmField var name: String)

包括懒加载属性也支持：

class Student {
    lateinit var name: String
}

public static void main(String[] args) {
    Student student = new Student("小明");
    student.name = "";
}

当然，这个属性不得是 open、override或const 其中一种，也不能是委托属性。

同时，由于Java中不存在空类型处理，因此，在Kotlin中定义的无论是否为可空类型都可以在Java中直接使用：

class Student {
    var name: String? = null
}

public static void main(String[] args) {
    Student student = new Student();
    student.getName().toUpperCase();   //直接空指针异常
}

静态属性

如果是Kotlin文件中直接编写的顶层定义，可以当做特定文件的静态属性来使用：

fun test() {
    println("Hello World")
}

在编译之后，它本质上就是一个Java中的静态方法，而对应类的名称就是源文件名称+Kt，这里Main.kt对应的名称就是MainKt了：

public static void main(String[] args) {
    MainKt.test();
}

我们也可以使用注解来明确生成的Java字节码文件名称：

@file:JvmName("LBWNB")

public static void main(String[] args) {
    LBWNB.test();
}

对于伴生对象以及单例对象，在Java中使用起来可能会有些别扭：

class Student {
    companion object {
        fun test() {}
    }
}

object Test {
    fun hello() {}
}

public static void main(String[] args) {
    Student.Companion.test();
  	Test.INSTANCE.hello();
}

这并不是我们希望的样子，在Kotlin中我们可以直接使用Student.的形式来直接调用，而在Java中却有一些出入，我们可以为这些函数添加@JvmStatic注解来完成：

class Student {
    companion object {
        @JvmStatic fun test() {}
    }
}

对于伴生对象中的字段，我们也可以为其添加@JvmField注解来使得其可以直接使用，这会在编译时使得此函数作为Student的静态属性存在：

public static void main(String[] args) {
    Student.test();
}

同样的，对于伴生对象中的属性来说，我们也像上一小节那样添加@JvmField注解：

class Student {
    companion object {
        @JvmField var name: String = ""
    }
}

public static void main(String[] args) {
    Student.name = "";   //此时name就是Student的静态属性
}