Kotlin语法笔记(27) -Kotlin 与 Java 共存(二)

本文涉及的产品
传统型负载均衡 CLB,每月750个小时 15LCU
网络型负载均衡 NLB,每月750个小时 15LCU
EMR Serverless StarRocks,5000CU*H 48000GB*H
简介: 本教程详细讲解Kotlin语法,适合希望深入了解Kotlin的开发者。若需快速入门,建议查阅“简洁”系列教程。本文重点探讨Kotlin与Java共存的高级话题,包括属性访问、空安全、泛型处理、同步机制及SAM转换等,助你在项目中逐步引入Kotlin。

本系列学习教程笔记属于详细讲解Kotlin语法的教程,需要快速学习Kotlin语法的小伙伴可以查看“简洁” 系列的教程

快速入门请阅读如下简洁教程:
Kotlin学习教程(一)
Kotlin学习教程(二)
Kotlin学习教程(三)
Kotlin学习教程(四)
Kotlin学习教程(五)
Kotlin学习教程(六)
Kotlin学习教程(七)
Kotlin学习教程(八)
Kotlin学习教程(九)
Kotlin学习教程(十)

Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)

Kotlin 与 Java 共存(二)
上一期我们简单讨论了几个 Java 调用 Kotlin 的场景,这一期我们主要讨论相反的情况。

  1. 属性
    如果 Java 类存在类似 setXXX 和 getXXX 的方法,Kotlin 会聪明地把他们当做属性来使用,例如:

public class DataClass {
private int id;

public int getId() {
    return id;
}

public void setId(int id) {
    this.id = id;
}

}
Kotlin 的访问也非常简单:

fun main(args: Array) {
val dataClass = DataClass()
dataClass.id = 0
println(dataClass.id)
}

  1. 空安全
    空安全这个特性使得 Kotlin 对变量的值要求更严格了,由于 Java 变量通常没有这样的信息,因此 Kotlin 在访问 Java 变量或者 Java 方法时,变量、方法的参数和返回值的空与否由我们自己决定,编译器不再进行约束。例如定义这么一个 Java 类:

public class NullSafetyJava {
public String getData(){
return null;
}
}
在 Kotlin 当中访问它:

fun main(args: Array) {
val nullSafetyJava = NullSafetyJava()
val data = nullSafetyJava.data
}
这个 data 的类型被称作 『平台类型(Platform Type)』,它既可以为可空类型,也可以为不可空类型,这一切取决于我们自己的决定。

val dataCanBeNull: String? = data
val dataCannotBeNull: String = data
这样在编译期是允许的,不过如果在运行时由于 data 为 null,那你就会遇到异常:

Exception in thread "main" java.lang.IllegalStateException: data must not be null
at net.println.kt15.NullSafetyKt.main(NullSafety.kt:10)
如果继承 Java 类,父类的方法参数也是平台类型,也需要我们根据实际情况来判断是否可空。例如:

public abstract class NullSafetyAbsClass {
public abstract String formatDate(Date date);
}
在Kotlin中继承这个类时,formatDate 方法的参数和返回值的类型我们根据情况写:

class NullSafetySubClass : NullSafetyAbsClass(){
override fun formatDate(date: Date?): String? {
return date?.toString()
}
}

fun main(args: Array) {
val nullSafetySubClass = NullSafetySubClass()
val formattedDate: String? = nullSafetySubClass.formatDate(Date())
println(formattedDate)
}
这样直接写可控类型当然是没有问题的。如果你确信它可以不为空,那么你也可以直接写不可控类型:

class NullSafetySubClass : NullSafetyAbsClass(){
override fun formatDate(date: Date): String {
return date.toString()
}
}

fun main(args: Array) {
val nullSafetySubClass = NullSafetySubClass()
val formattedDate: String = nullSafetySubClass.formatDate(Date())
println(formattedDate)
}
当然,对于这种情况,我们在 Java 也已经开始采用一些『曲线救国』的方式来弥补这一不足,比如 采用 JetBrains 的 @Nullable 和 @NotNull 注解以及 Android 当中类似的注解支持,我们可以把我们的 Java 代码改写成这样:

public abstract class NullSafetyAbsClass {
public abstract @NotNull String formatDate(@NotNull Date date);
}

  1. 泛型
    整体上来讲,Kotlin 的泛型与 Java 的没什么大的差别,Java 的 ? 在 Kotlin 中变成了 *,毕竟 ? 在 Kotlin 当中用处大着呢。另外,Java 泛型的上限下限的表示法在 Kotlin 当中变成了 out 和 in。

不过,由于 Java 1.5 之前并没有泛型的概念,为了兼容旧版本,1.5 之后的 Java 仍然允许下面的写法存在:

List list = new ArrayList();
list.add("Hello");
list.add(1);
for (Object o : list) {
System.out.println(o);
}
而对应的,在 Kotlin 当中要用 List<*> 来表示 Java 中的 List —— 这本身没什么问题。那么我们现在再看一段代码:

public abstract class View

{
protected P presenter;
}

public abstract class Presenter{
protected V view;
}
这个其实是现在比较流行的 MVP 设计模式的一个简单的接口,我希望通过泛型来绑定 V-P,并且我可以通过泛型参数在运行时直接反射实例化一个 presenter 完成 V-P 的实例注入,这在 Java 当中是没有问题的。

那么在 Kotlin 当中呢? 因为我们知道 View 和 Presenter 都有泛型参数的,所以我们在 Kotlin 当中就要这么写:

abstract class View

>{
protected abstract val presenter: P
}

abstract class Presenter>>>{
protected abstract val view: V
}
一直写下去,最终陷入了死循环。编译器给出的解释是:

This type parameter violates the Finite Bound Restriction.

在 @zhangdatou 给我发邮件之前,我曾一直对此耿耿于怀,Kotlin 这么优秀的语言怎么还会有做不到的事情呢。原来不是做不到,而是我没有想到:

abstract class View>>
abstract class Presenter>>

class MyView: View()
class MyPresenter: Presenter()
实际上我们需要 View 的泛型参数 P 只要是 Presenter 的子类即可,并且要求这个泛型参数 P 本身对应的泛型参数也需要是 View 的子类,而这个 View 其实就是最初的那个 View,那么这个 View 的泛型参数当然就是 P 了。有点儿绕,但这么写出来明显感觉比 Java 安全靠谱多了。

  1. Synchronized 和 volatile
    在 Kotlin 当中,这两个关键字被削去了王位,成为平民。也许是设计者们觉得这二位作为关键字出现有点儿太重了,虽然不再身居要职,不过却也是不可或缺。

Synchronized 有两个版本,用于函数的版本是个注解:

var num: Int = 0

@Synchronized fun count(){
num++
}
用于代码块的则是一个函数:

var num: Int = 0

fun count(){
synchronized(num){
num++
}
}
@kotlin.internal.InlineOnly
public inline fun synchronized(lock: Any, block: () -> R): R {
@Suppress("NON_PUBLIC_CALL_FROM_PUBLIC_INLINE", "INVISIBLE_MEMBER")
monitorEnter(lock)
try {
return block()
}
finally {
@Suppress("NON_PUBLIC_CALL_FROM_PUBLIC_INLINE", "INVISIBLE_MEMBER")
monitorExit(lock)
}
}
volatile 的命运差不多,也变成了一个注解:

@Volatile var num: Int = 0

  1. SAM 转换
    看名字一头雾水,其实就是对于只有一个方法的 Java 接口,Kotlin 可以用一个 Lambda 表达式来简化它的书写,例如:

fun main(args: Array) {
val worker = Executors.newCachedThreadPool()
worker.execute {
println(System.currentTimeMillis())
}
}
execute 方法传入了一个 Runnable 接口的实例,不过看样子却是一个 Lambda 表达式。不过这里也是有一个需要注意的点的,既然是『转换』,那么 Java 的 execute 方法接受到的实例就一定不是我们看到的这个 Lambda 表达式实例了,换句话说,我们就算每次传入同一个 Lambda 表达式实例,那么 Java 的 execute 方法收到的也并不是同一个对象。举个例子:

public class SAMInJava {
private ArrayList runnables = new ArrayList();

public void addTask(Runnable task){
    runnables.add(task);
    System.out.println("after add: " + task + ", we " + runnables.size() + " in all.");
}

public void removeTask(Runnable task){
    runnables.remove(task);
    System.out.println("after remove: " + task + ", only " + runnables.size() + " left.");
}

}
然后我们在 Kotlin 当中这么写:

fun main(args: Array) {
val samInJava = SAMInJava()
val lambda = {
println("Hello")
}

samInJava.addTask(lambda)
samInJava.addTask(lambda)
samInJava.addTask(lambda)
samInJava.addTask(lambda)

samInJava.removeTask(lambda)
samInJava.removeTask(lambda)
samInJava.removeTask(lambda)
samInJava.removeTask(lambda)

}
运行结果呢?

after add: net.println.kt15.SAMConversionKt$sam$Runnable$9855366b@6ce253f1, we have 1 in all.
after add: net.println.kt15.SAMConversionKt$sam$Runnable$9855366b@53d8d10a, we have 2 in all.
after add: net.println.kt15.SAMConversionKt$sam$Runnable$9855366b@e9e54c2, we have 3 in all.
after add: net.println.kt15.SAMConversionKt$sam$Runnable$9855366b@65ab7765, we have 4 in all.
after remove: net.println.kt15.SAMConversionKt$sam$Runnable$9855366b@1b28cdfa, only 4 left.
after remove: net.println.kt15.SAMConversionKt$sam$Runnable$9855366b@eed1f14, only 4 left.
after remove: net.println.kt15.SAMConversionKt$sam$Runnable$9855366b@7229724f, only 4 left.
after remove: net.println.kt15.SAMConversionKt$sam$Runnable$9855366b@4c873330, only 4 left.
每次 Java 的 add 和 remove 方法收到的都是不同的实例,所以 remove 方法根本没有起到作用。

  1. 小结
    除了这些之外还有一些细节,比如异常的捕获,集合类型的映射等等,大家可以自行参考官方文档即可。在了解了这些之后,你就可以放心大胆的在你的项目中慢慢渗透 Kotlin,让你的代码逐渐走向简洁与精致了。

最后,作为这一系列视频的最后一集,我还想要告诉大家有关 Android 开发的视频可能会在年后开始筹备,公众号在后续的这段时间内会推送我为大家准备的 Kotlin 的一些有意思的文章,请大家继续关注,并与我互动,谢谢大家!

相关文章
|
2天前
|
Java 编译器 Android开发
Kotlin语法笔记(28) -Kotlin 与 Java 混编
本系列教程详细讲解了Kotlin语法,适合需要深入了解Kotlin的开发者。对于希望快速学习Kotlin的用户,推荐查看“简洁”系列教程。本文档重点介绍了Kotlin与Java混编的技巧,包括代码转换、类调用、ProGuard问题、Android library开发建议以及在Kotlin和Java之间互相调用的方法。
10 1
|
2天前
|
Java 开发工具 Android开发
Kotlin语法笔记(26) -Kotlin 与 Java 共存(1)
本系列教程笔记详细讲解了Kotlin语法,适合需要深入了解Kotlin的开发者。若需快速学习Kotlin,建议查看“简洁”系列教程。本期重点介绍了Kotlin与Java的共存方式,包括属性、单例对象、默认参数方法、包方法、扩展方法以及内部类和成员的互操作性。通过这些内容,帮助你在项目中更好地结合使用这两种语言。
11 1
Java初级笔记-第五章
第五章 面向对象的特点 5.1 继承 面向对象的重要特点之一就是继承。类的继承使得能够在已有的类的基础上构造新的类,新类除了具有被继承类的属性和方法外,还可以根据需要添加新的属性和方法。
1044 0
|
Java Windows 开发框架
Java初级笔记-第一章
第一章 Java概览 1.1 基本简介 Java是一种理想的面向对象的网络编程语言。 1991年,出现了Oak语言,旨在解决编程语言的选择和跨平台的问题。
1370 0
Java初级笔记-第二章
第二章 Java的基本数据类型、运算符及表达式 2.1 标识符 标识符是程序员对程序中的各个元素加以命名时使用的命名记号。
1202 0
|
存储 算法 Java
Java初级笔记-第三章
第三章 程序设计基础 3.1 流程图 3.1.1 什么是流程图: 流程图是通过箭头(流程线)相互连接的几何图形来表达程序运行的方法。
1408 0
Java初级笔记-第四章
第四章 类 4.1 类的概念 Java语言是一种纯面向对象的编程语言(OOP,你所有使用的内容,都是从类开始。
1269 0
|
2天前
|
Java API 调度
Java中的多线程编程:理解与实践
本文旨在为读者提供对Java多线程编程的深入理解,包括其基本概念、实现方式以及常见问题的解决方案。通过阅读本文,读者将能够掌握Java多线程编程的核心知识,提高自己在并发编程方面的技能。
|
1天前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
7 3
|
1天前
|
Java 开发者
在Java多线程编程中,选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中,选择合适的线程创建方法至关重要。本文通过案例分析,探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景,帮助开发者做出明智的选择。
6 2