针对空指针问题， Kotlin有专门的针对语法以避免问题。

可空类型
默认声明的变量是不能为 null 的，如果要使变量能为 null， 需要添加 ?



val name: String = null // 编译错误

var name = "harry"
name = null // 编译错误

// 正确的写法
var name: String? = null

var name: String? = "harry"
name = null

同样， 方法的返回值，如果可能返回空，也要加 ?



fun test(): String? = if ... else null

安全空访问
智能类型转换是一个相当好的特点，可以安全访问可空变量， 如：



var name: String? = "harry"

if (name != null) {
println(name.length)
}

但是，考虑到多个 null 检测，代码的可读性就变差，示例：



class Country(val name: String)
class City(val name: String, val country: Country?)
class Persion(val name: String, val city: City?)t

fun getCountryName(persion: Persion?): String? {
    var countryName: String? = null
    if (persion != null) {
        val city = persion.city
        if (city != null) {
            val country = city.conutry
            if (country != null) {
                countryName = country.name
            }
        }
    }
    return countryName
}

嵌套的 null 检测， 代码可读性较差， Kotlin提供了简明的写法 ?.



fun getCountryName(persion: Persion?) = persion?.city?.country?.name

非空断言
有时候，要将可空的变量转成非空的， 常见于Java， 我们知道变量是不可能为 null 的， 可以用非空断言 !!



val nullableString: String? = "hello world"
val string: String = nullableString!!

var name: String? = null
name = "jason"
val len = name!!.length

Elvis操作
Java里面， 有个三元操作?:， 实现 if … else … 的赋值。Kotlin 也有这个操作符， 但是用法不一样，如：



val nullableName: String? = ...
val name: String = nullableName ?: "default_name"

如上代码意思了， 如果 nullableName 为 null， 就赋值 “default_name”。

?:主要用于如果变量为 null就设置默认值。

安全类型转换
如果想安全地进行类型转换， 当转换失败时结果 null， 这种情况可用 as?



val location: Any = "London"
val safeString: String? = location as? String
val safeInt: Int? = location as? Int

参考 

《Programming Kotlin》Stephen Samuel ，Stefan Bocutiu  

《Kotlin in Action》Dmitry Jemerov，Svetlana Isakova

1.可为null类型
在Kotlin中通常我们直接定义的类型是不可以为null的,如下：
fun main() {
    var s = "abc"
    s = null  //编译错误：null can not be a value of a non-null type String

    var i = 1
    i = null  //编译错误：null can not be a value of a non-null type Int

    var p = Person("Denny")
    p = null  //编译错误：null can not be a value of a non-null type Person
}
如果想要允许为null，我们需要在变量的类型后面加上一个?号。如下:
fun main(args: Array<String>) {
    var s: String? = "abc"
    s = null

    var i:Int? = 1
    i = null

    var p:Person? = Person("Denny")
    p = null

    var list:MutableList<Int>? = mutableListOf(1, 2, 3)
    list = null
}
这样就不会编译报错了
2.安全调用
上面的例子中，如果调用s.length的话，这将是不安全的,编译器直接报错
private fun testNullSafe() {
    var s:String? = "safe"
    s = null
    println("lhf:  ${s.length}")
}
在println中的小点 . 会报这样的错误
(只有安全(2)或非空断言(.)调用才允许在类型为String的可空接收器上调用?)

当s为空时，返回null。如果s可能为空，使用s获取它的长度，有可能会导致空指针异常，为了解决这个问题，在s后面添加？号。

这样就可以保证不出现空指针异常。当s为空时，停止获取它的length，直接返回null。
所以：
private fun testNullSafe() {
    var s:String? = "safe"
    s = null
    println("lhf:  ${s?.length}")
}
使用双！！感叹号，代表的是当前字符串一定不为空，系统不会帮你检查了。
private fun testNullSafe() {
    s = "abc"
    println("lhf:  ${str!!.length}")
}
如果这里让s=null编译时可以通过 但运行时会报空指针异常

在Android系统中，崩溃率最高的异常类型就是空指针。若要分析其根源，主要是因为空指针是一种不受编程语言检查的异常情况，只能有我们自己主动编写判断。
Kotlin非常科学地解决了这个问题，他利用编译时判空检查的机制 基本杜绝空指针异常情况。虽然这样代码会比较难写，不过Kotlin提供了一系列的辅助工具使判空过程更加简单。
下面我们来看一段程序，仍然是我们以前定义的Student.kt：
package com.example.helloword

class Student(name: String, age: Number): Human(name,age), Study{
    override fun learnMath() {
        println(name + "is learning Math.")
    }
}

fun tuDo(study:Study){
    study.learnMath()
    study.learnEnglish()
}

当我们在main()函数内执行tuDo函数，当传入值为null时，编译系统直接报错。因为Kotlin不允许传入值为空。



当我们需要参数或变量为空时，Kotlin提供另外一套可空的类型系统，我们需要在编译时期排除所有潜在空指针异常。否则代码将无法编译通过。
可空的类型系统
非常简单，就是在类名后面加一个问号。比如Int表示不可空整型，Int?表示可空的整型。



当我们在Study后面加上?，即表示我们希望传入的参数可为空。但我们调用的learnMath()和learnEnglish()仍然报错，因为这两个方法依然会造成空指针异常，所以编译出错。
所以我们应用if判断，把空指针都处理掉即可：
fun tuDo(study:Study?){
    if (study != null){
        study.learnMath()
        study.learnEnglish()
    }
}

我们这一期基本了解了空指针异常的处理办法，下一期我们讲解更加方便地判断辅助工具。

欢迎关注小试编程

​​​​

上面的参数传入一个null,提示类型是String,不能传入null 

 

fun main(array:Array<String>){
    doStudy(null)
}
fun doStudy(name:String ? ){
    println(name)
}
打印：null

上面的代码再加深一下

先创建一个类
class A{
    fun doA(){
        println("doA")
    }
}
再main()调用A类的方法，不需要new ;



fun main(array:Array<String>){

    var a=A();

    if (a!=null){

        a.doA()

    }

}

打印： doA

?.用法-->再简化代码，去掉if条件语句：

fun main(array:Array<String>){

    var a=A();

    a?.doA()

}

打印：doA 结果相同

下面接着看 ?:  用法  

var a:String? =null;
var b ="B" ;
var c = if(a!= null){
    a
 }else{
    b
 }
print(c)



打印:B

用 ?: 简写

 

fun main(array:Array<String>){
    var a:String? =null;
    var b ="B" ;
    var c = a ?: b
    print(c)
}
打印：B
打印的结果相同，?: 简化，不用if 条件语句 ，代码减少了

 

fun main(array:Array<String>){
    print(doStudy("张三"))
}
fun doStudy(name:String ? ):Int{
    if(name != null){
        return name.length
    }else{
        return 0
    }
}
打印：2
很简单上面的代码是：参数如果是null，返回0，否则返回输入参数的长度
再简化代码:


fun main(array:Array<String>){
    print(doStudy("张三"))
}
fun doStudy(name:String ? ):Int = name ?. length ?: 0
结果打印： 2 参数的长度