kotlin中的可空性

参数传入可空性

可空性是kotlin类型系统为了避免发生NullPointerException错误的特性.
如下一段java代码

/*Java*/
int strLen(String s){
    return s.length();
 }

如果调用的时候我们这样去调用strLen(null), 这样一定会抛出NullPointerException. 下面我们用kotlin来改造它
fun strLen(s : String) = s.length
如果现在调用strLen(null)是不允许的

image.png

这个函数的参数声明为String类型，就表示必须传入一个String的实例，不能传入null的实参，如果可以传入可空实参就需要加一个?声明

fun strLenSafe(s : String?) = ...

如果像上面声明一样是一个可空的实参，那实际使用该实参也会受到限制, 不能再直接调用下面的s.length()方法.
那接下来应该怎么办？可以通过if检查处理null

fun strLenSafe(s : String?) : Int = 
    if(s != null) s.length else 0

我们拿String类型来做个栗子，在java中String类型的变量可以持有两种值,分别是String的实例和null . 但是实际过程中String变量可以做所有String相关的操作，而null就不能，这实际上可以被当作两种类型.
kotlin的可空类型为这类问题提供了全面的解决方案. 区分开可空类型和非可空类型使事情变得明朗：哪些对值的操作是允许的，哪些操作有会导致运行时异常并因此被禁止.

方法调用的可控性

kotlin中的安全调用运算符”?”
之前如果不使用if检查处理null也是可以通过?运算符解决编译问题的

fun strLen(s : String?) = s?.length

加上?的调用说明是安全调用.

处理属性的可控性

安全调用不光可以调用方法，还可以处理属性

class Employee(val name : String, val manager : Employee?)
fun managerName(employee: Employee) : String? = employee.manager?.name

val ceo = Employee("Da Boss",null)
val developer = Employee("Bob Smith",ceo)
println(managerName(developer))
println(managerName(ceo))

输出

Da Boss
null

Elvis运算符号?:

class Address(val streetAddress : String, val zipCode : Int, val city : String, val country : String)
class Company(val name: String, val address : Address?)
class Person(val name : String, val company: Company?)

Fun Person.countryName() : String{
    val country = this.company?.address?.country
    return if (country != null) country else “Unknow”
} 
>>> val person = Person(“Dmitry”,null)
>>> println(person.countryName())
Unknow 

不过还有一种更加简单的调用方式来代替null的默认值，它被称为Elvis运算符号?: ，下面看下如何使用

fun foo(s : String?){
    val t : String = s ?: “”
}

Elvis运算符号接收两个运算数：如果第一个运算数不为null,结果就是第一个运算数；如果第一个运算数为null, 运算结果就是第二个运算数.
下面来看如何用Elvis运算符号一行代码完成Person.countryName这个函数

fun Person.countryName() =  company?.address?.country?: “Unknown”

Elvis运算符和throw抛出异常，还是接着上面那个Address例子来调用

fun printShippingLabel(person : Person){
    val address = person.company?.address? : throw IllegalArgumentException(“No address”)
    with(address){
        println(streetAddress)
        println(“$zipCode $city, $country”)
    }
}

>>> val address = Address(“Elsestr. 47”, 80687, “Munich”, “Germany”)
>>> val jetbrains = Company(“JetBrains”, address)
>>> val person = Person(“Dmitry”, jetbrains)

>>> printShippingLabel(person)
Elsestr . 47
80687 Munich, Germany
>>> printShippingLabel(Person(“Alexey”,null))
Java.lang.IllegalArgumentException : No address 

这里调用printShippingLabel，当 person.company?.address? 出现null的情况下会抛出异常IllegalArgumentException.

安全转换 : “as?”

as?用来转换一种类型，例如java中 (A)B，但是这样往往存在风险, 因为B可能不属于A, 这样就会抛出ClassCastException异常，在Kotlin中完全不用担心这种异常的发生, 使用

B as? A

这种转换在B不属于A的情况下会返回null, 不会抛出ClassCastException.
使用as?实现equals

Class Person(val firstName : String, val lastName: String){
    override fun equals(o : Any?) : Boolean{
        val otherPerson = o as? Person ?: return false
        return otherPerson.firstName == firstName && otherPerson.lastName == lastName
    }
}

非空断言 “!!”

非空断言就是由开发者强制断定不为null,但是如果为null, 这种情况下就会抛出NullPointerException.

fun ignoreNulls(s : String?){
    val sNotNull : String = s!!
    println(sNotNull.length)
}
>>> ignoreNulls(null)
Exception in thread “main” kotlin.KotlinNullPointerException…

你可能会想kotlin安全机制怎么会允许这样的异常抛出，但是实际上非空断言确实有存在的必要，当你在一个函数中检查一个值是否为null, 而在另一个函数中使用这个值时，这种情况下编译器无法识别这种用法是否安全，这时候可以使用非空断言避免重复判断.

let函数

通常在编码过程中你可能会传递一个可空参数给一个要求非空参数的函数

fun sendEmailTo(email : String)

下面这种调用在kotlin中是不行的

>>> val email : String ?= ...
>>> sendEmailTo(email)
ERROR: TYPE mismatch : inferred type is String? but String was expected

通常可以这样处理

if (email != null) sendEmailTo(email)

在kotlin中还有另外一种处理方式是,使用安全调用结合let函数

email?.let{  email -> sendEmailTo(email) }

如果结合it这种简明语法就更简短了

email?.let{ sendEmailTo(it) }

延迟初始化属性

有时候成员变量的初始化并不会放在成员变量声明的时候, 但是通常直接声明，编译器不允许，会让你初始化一个null, 如果这样做这就是一个可空的变量，每次使用都要进行null检查或者!!运算符.
通过添加lateinit关键字可以避免每次使用都要进行null检查，它表示该变量延迟初始化，一定为非null变量. 但是如果你没有初始化使用了它，就会抛出“lateinit property myService has not been initialized”

可空类型的扩展

扩展函数的调用可以为null对象(这个取决于如何定义,可以定义为可空也可以是非空)，这个和普通成员方法不一样，普通成员方法是由对象实例来分发的，因此实例为null时永远不能被执行.
例如函数isEmptyOrNull和isNullOrBlank就可以由String?类型的接收者调用

fun verifyUserInput(input : String?){
    if(input.isNullOrBlank()){
        println(“Please fill in the required fields”)
    }
}
>>> verifyUserInput(“”)
Please fill in the required fields
>>> verifyUserInput(null)
Please fill in the required fields

上面展示了扩展函数是不需要安全调用的，下面来看看isNullOrBlank是怎么定义的

public inline fun CharSequence?.isNullOrBlank(): Boolean {
    contract {
        returns(false) implies (this@isNullOrBlank != null)
    }
    return this == null || this.isBlank()
}

当你为一个可空类型（以？结尾）定义扩展函数时，这意味着你可以对可空的值调用这个函数,注意在可空类型的扩展函数中使用this需要进行安全检查.

类型参数的可空性

Kotlin中所有泛型类和泛型参数的类型参数默认都是可空的. 参考下面

fun <T>  printHasCode(t : T){
    println(t?.hashCode())
}

在printHashCode调用中，类型参数T推导出的类型是可空类型Any?. 因此,尽管没有用问号结尾，实参t依然允许持有null.
要使类型参数非空,必须要为它指定一个非空的上界，那样泛型会拒绝可空值作为实参.

fun <T: Any> printHashCode(t : T){
    println(h.hashCode())
} 

注意必须使用问号结尾来标记类型为可空的，没有问号就是非空的。类型参数是这个规则唯一的例外.

可空性和Java

现在来探讨下Kotlin和Java混合使用如何处理可空性，在java中通常通过注解来处理可空性,它和kotlin转换关系如下
@Nullable + Type = Type?
@NotNull +Type = Type
左边是java 右边 是kotlin
另外java还有一种没有注解的情况,这时候会被kotlin当作平台类型.
什么是平台类型:
平台类型本质上就是Kotlin不知道可空性信息的类型。既可以把它当作可空类型处理，也可以当作非空类型处理。这意味着，你要像在java中一样，对你在这个类型上做的操作负有全部责任.
Type = Type? or Type
Java Kotlin
下面来看一个没有可空性注解的Java类

/* Java */
public class Person{
    private final String name;
    
    public Person(String name){
        this.name = name
    }

    public String getName(){
        return name;
    }
} 

不是安全检查访问Java类

fun yellAt(person : Person){
    println(person.name.toUpperCase() + “!!!”)
}
>>>yellAt(Person(nulll))
Java.lang.IllegalArgumentException: Parameter specified as non-null is null : method toUpperCase, parameter &receiver

这种调用就会抛出一个异常，注意不是NullPointerException, 而是一条更详细的错误消息, 告诉你方法toUpperCase不能在null接受者上调用.
这时候我们需要使用空检查来访问Java类

Fun yellAtSafe(person : Person){
    println((person.name ?: “Anyone”).toUpperCase()+”!!!”)
}
>>> yellAtSafe(Person(null))
ANYONE!!

Kotlin重写java方法的时候，可以把参数和返回值定义为可null的,也可以定义为非null的,例如我们来看一个Java中的StringProcessor接口

/* Java */
Interface StringProcessor{
    void process(String value);
}

Kotlin可以通过下面两种方式实现该接口

class StringPrinter : StringProcessor{
    override fun process(value : String){
        if(value != null){
            println(value)
        }
    }
} 
class StringPrinter : StringProcessor{
    override fun process(value : String?){
        if(value != null){
            println(value)
        }
    }
} 

下面来总结一下kotlin中的可空性, 我们讨论了可空类型和非可空类型，以及如何处理它们的手段，安全操作的运算符(安全调用运算符?. Elvis运算符?: 和 安全转换运算符as?), 还有非空断言，let帮你更简洁的非空检查, 也了解了非空检查移动到函数内部.最后我们讨论了Kotlin中表示Java类型的平台类型.