开发者

Kotlin的空安全处理方式详解

目录
  • 1python.Java的空安全处理
  • 2.Kotlin的空安全思维
    • 1.Kotlin的空安全表示方式
    • 2.Kotlin与Java混编的空安全
    • 3.Kotlin的空安全——非空断言
    • 4.Kotlin的空安全——泛型可空性

1.Java的空安全处理

在Java中有@NotNull@Nullable等注解,告诉IDE哪些比那辆是可以为空的,哪些是不可为空的。但是这样做的效果缺不显著,原因有两个:

  • 注解很难在项目中大面积的使用,开发者大都没有这个习惯,并且在开发过程中还会影响效率;
  • 即使完全使用注解去编码也不能完全解决NPE的问题。

那么后来在Java8引入了Optional,这种手段的核心思路就是封装数据, 不再直接使用null。举个例子,从前我们直接使用 String 类,使用 Optional 以后,我们就得改成 Optional。如果我们要判断值是否为空,就用 optional.isPresent()

但是Optional有几个缺点:

  • 代码复杂度被提高;
  • 降低代码执行效率,因为声明类型又被封装了一层;
  • 普及度不高;

2.Kotlin的空安全思维

1.Kotlin的空安全表示方式

以String为例,在Kotlin中有三种表示方法:

  • String:不可为空的字符串;
  • String? :可能为空的字符串;
  • String! :不知道是不是可能为空。

2.Kotlin与Java混编的空安全

老项目大多情况下是Kotlin和Java混合开发的,因此就会hpMIVWu出现Kotlin调用Java的情况,那么假如说现在有一个工具类是这样的:

public class NullJava {
    public static String getMsg(String s) {
        return s + "Kotlin";
    }
    @Nullable
    public static String getNullableString(@Nullable String s) {
        return s + "Kotlin";
    }
    @NotNull
    public static String getNotNullString(@NotNull String s) {
        return "Hello World.";
    }
} 

上面的Java代码返回的是一个String类型的值,方法的定义分别是

  • 参数和返回值没有定义是否为空;
  • 参数和返回值均可为空;
  • 参数和返回值均不能为空;

Kotlin调用的代码就要这么写:

fun test() {
    //				这里不加?就会报出类型不匹配的错误
    //					↓
    val nullableMsg: String? = NullJava.getNullableString(null)
    val notNullMsg: String = NullJava.getNotNullString("Hey,")
    val platformMsg1: String? = NullJava.getMsg(null)
    val platformMsg2: String = NullJava.getMsg("Hello")
}

分析上面的代码:

getNullableString在Java中的定义是参数和返回值可为空的因此要用String?进行定义;

getNotNullString在Java中的定义时参数和返回值均不可为空因此只能用String定义;

getMsg什么注解都没有,因此它在使用时可以是String也可以是String?,也就是说它就是Kotlin中的String!,但这会带来NPE的错误。

综合上面的几种情况我们可以得出以下结论:

  • 如果Java源码在项目中,在与Kotlin交互时应该在参数和返回值上加上可空注解@Nullable
  • 如果是第三方的SDK的代码,在与Kotlin交互时如果SDK没有可空注解就需要在SDK与业务代码之间建立一个抽象层,对SDK代码进行封装。

3.Kotlin的空安全——非空断言

Kotlin有一个非空安全的调用语法!!.,这就是非空断言运算符,它可以将任何值转化为非空类型,如果这个值为null则抛出NPE异常。具体用法如下:

fun testNPE(msg: String?) {
//           非空断言
// 			   ↓ 开发者_JS学习
    val i = msg!!.length
}
fun main() {
    testNPE(null)
}

上面的代码就会抛出NPE的异常,非空断言失败有风险的,因此在使用中要尽可能的不使用它,但是在Java转Kotlin代码时还是会出现这个问题,例如下面代码的转换

//JAVA
class Test {
    private String name = null;
    void init() {
        name = "";
    }
    void test() {
        if (name != null) {
            int count = name.length();
        }
    }
}
//Kotlin
class Test {
    private var name: String? = null
    fun init() {
        name = ""
    }
    fun test() {
        if (name != null) {
            val count = name!!.length
        }
    }
}

上面的代码就是将Java代码直接复制到Kotlin中的转换结果,这种情况在将Java代码直接复制到Kotlin中时出现的概率还是比较高的。如果将上面的非空断言!!删除则会报错,致意思是,在这种场景下,Smart Cast 是不可能发生的。

那么为什么不能自动转换成非空类型呢?因为Smart Cast失效了,即使有判空代码也免不了还是要www.devze.com继续使用非空断言。而Smart Cast的失效是因为这个值可能在做空判断时会在其他地方被改变。当然避免Smart Cast失效的问题是有解决办法的:

  • 直接在方法中传参,将参数传递到方法中在做空判断就可以避免,因为这个值已经无法被其他方法改变了;
  • 利用Kotlin的不可变的特性,将变量的声明由var改为val
  • 借助临时不可变变量;
class JavaConvertExample {
    private var name: String? = nuwww.devze.comll
    fun test() {
//        不可变变量
//            ↓
        val _name = name
        if (_name != null) {
            // 在if当中,只使用_name这个临时变量
            val count = _name.length
        }
    }
}
  • 借助let函数
class JavaConvertExample {
    private var name: String? = null
    fun test() {
//                      标准函数
//                         ↓
        val count = name?.let { it.length }
    }
}
  • 借助延迟初始化
class JavaConvertExample {
//         稍后初始化             不可空
//            ↓                   ↓
    private lateinit var name: String
    fun init() {
        name = "Tom"
    }
    fun test() {
        if (this::name.isInitialized) {
            val count = name.length
        } else {
            println("Please call init() first!")
        www.devze.com}
    }
}
fun main() {
    val example = JavaConvertExample()
    example.init()
    example.test()
}
  • 使用懒加载委托by lazy
class JavaConvertExample {
    //         不可变        非空   懒加载委托
    //           ↓           ↓        ↓
    private val name: String by lazy { init() }
    fun init() = "Tom"
    fun test() {
        val count = name.length
    }
}

4.Kotlin的空安全——泛型可空性

泛型在默认情况下是可为空的,但是部分API在调用时却会产生错误,例如下面的代码:

fun <T> saveSomething(data: T) {
    val set = sortedSetOf<T>()
    set.add(data)
}
fun main() {
    saveSomething(null)
}

上面的代码中sortedSetof继承自Java的TreeSet它不能存储null,因此这里就会出现NPE的错误。

代码的参数是data:T看起来是不可为空的但是传null却不会报错,这是为什么?因为这里的T其实等价于<T: Any?>这就意味着泛型的T是可以接收null作为参数的。那这个问题要如何解决呢,就是限制边界将Any?修改为Any即可

fun <T> aveSomething(data: T) {}
//    ↑
//	 等价
//    ↓  
fun <T: Any?> aveSomething(data: T) {
}
//修改后
fun <T: Any> aveSomething(data: T) {
}

修改泛型边界为不可为空之后就可以在传参时避免传入null的问题,传入null时IDE会报出错误,这样就可以在编码期解决问题。

Kotlin的空安全处理方式详解

以上就是Kotlin的空安全处理方式详解的详细内容,更多关于Kotlin空安全处理的资料请关注我们其它相关文章!

0

上一篇:

下一篇:

精彩评论

暂无评论...
验证码 换一张
取 消

最新开发

开发排行榜