Kotlin 进阶之路(一) 编程基础
Kotlin 进阶之路(一) 编程基础
1.1 Kotlin 基本语法
- 代码基本格式
fun main(args:Array<String>){
println("it's just for fun")
//HelloKotlin::class.constructors.map (::println)
}
- kotlin 中严格区分大小写
- 编码规范可按照 Java 编码规范，使用驼峰式命名
- kotlin 编码风格最大区别于 Java 即语句结束不再需要写分号 ;
- 注释
Kotlin 中的注释和 java 中注释大体一样
- 单行注释 //
- 多行注释 /* 开头 */结尾
- 文档注释 /** 开头 */结尾
区别
Kotlin 中的多行注释可以嵌套单行注释，多行注释可以嵌套多行注释
fun main(args:Array<String>){
println("it's just for fun")
/*HelloKotlin::class.constructors.map (::println)
//println("hello world")
/*
println("test annotation")
*/
*/
}
1.2 Kotlin 变量声明
- 变量定义
Kotlin 中的变量分为两种类型
可变变量 用关键字 var 修饰(对应 Java 中的普通变量)
不可变变量 用关键字 val 修饰(对应 Java 中的 final)
fun main(args:Array<String>){
var a : Int //声明一个Int类型的可变变量a
val b : String //声明一个String类型的不可变变量b
var c : Int = 1
var c1 = 1 //和上面的语句一样，Kotlin 会根据变量值自动识别数据类型
var d : Int
d = 10
}
- 变量数据类型
Kotlin 中的数据类型分为 数值型、字符型、布尔型、数组型、字符串型
1.数值型变量
| 类型名 | 描述 | 占用空间 | 存储值范围 | 示例 |
|---|---|---|---|---|
| Byte | 字节 | 8位(1个字节) | -2⁷ ~（2⁷ - 1） | var a : Byte = 1 |
| Short | 短整型 | 16位(2个字节) | -2¹⁵ ~（2¹⁵ - 1） | var b : Short = 1 |
| Int | 整型 | 32位(4个字节) | -2³¹ ~（2³¹ - 1） | var c : Int = 1 |
| Long | 长整型 | 64位(8个字节) | -2⁶³ ~（2⁶³ - 1） | var d :Long = 1L |
| Float | 浮点型 | 32位(4个字节) | 1.4E-45 ~ 3.4E+38 -3.4E+38 ~ -1.4E-45 |
var e : Float = 1f |
| Double | 双精度浮点型 | 64位(8个字节) | 4.9E - 324 ~ 1.7E+308, -1.7E+308 ~ -4.9E - 324 |
var f : Double = 1.0 |
2.字符型变量
在 Kotlin 中用 “Char” 表示，每个字符类型变量会占用2个字节。给 Char 类型的变量赋值，需要使用 ‘’ 把字符括起来。
var a : Char = 'a'
var b = 'b'
3.布尔型变量
在 Kotlin 中用 Boolean 表示，分别是 true 和 false
var a : Boolean = true
var b = false
4.数组型变量
在 Kotlin 中数组用 Array 表示，类型包括 数值类型、布尔类型、字符类型。
两种初始化方式：
以数据类型 ArrayOf() 方法进行初始化
以 arrayOf() 方法进行初始化
var int_array : IntArray = intArrayOf(1, 2, 3)
var boolean_array : BooleanArray = booleanArrayOf(true, false, true)
var char_array : CharArray = charArrayOf('a', 'b', 'c')
注意： Kotlin 中不能使用 stringArrayOf() 方法创建字符串类型数组，因为 String 不属于基本数据类型。可以通过 Array,对应的初始化数组的方法也变成了 arrayOf()
var int_array : Array<Int> = arrayOf(1, 2, 3)
var boolean_array : Array<Boolean> = arrayOf(true, false, true)
var char_array : Array<Char> = arrayOf('a', 'b', 'c')
var string_array : Array<String> = arrayOf("Hello", "Kotlin", "Fun")
//变量的数据类型均可省略
//var int_array = arrayOf(1, 2, 3)
//var boolean_array = arrayOf(true, false, true)
//var char_array = arrayOf('a', 'b', 'c')
//var string_array = arrayOf("Hello", "Kotlin", "Fun")
5.字符串型变量
Kotlin 中的字符串和 Java 中的字符串非常相似，使用 String 表示
var a : String = "Hello Kotlin"
var a = "Hello Kotlin"
1.3 Kotlin 运算符
- 算术运算符
Kotlin 中的算术运算符就是用来处理四则运算的符号，也就是常见的加减乘除。
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| + | 正号 | +5 | 5 |
| - | 负号 | b=6;-b | b=-6 |
| + | 加 | 4+4 | 8 |
| - | 减 | 6-5 | 1 |
| * | 乘 | 5*3 | 15 |
| / | 除 | 6/3 | 2 |
| % | 取模(算术中的求余数) | 8%3 | 2 |
| … | 范围 | a=1;b=a…2; | a=1;b=1…2 |
| ++ | 自增(前) | a=1;b=++a; | a=1;b=2 |
| ++ | 自增(后) | a=1;b=a++; | a=1;b=1 |
| - - | 自减(前) | a=1;b=–a; | a=0;b=0 |
| - - | 自减(后) | a=1;b=a–; | a=0;b=1 |
注意:
1.在进行除法运算时，当除数和被除数都为整数时，结果也是整数。若当中有小数参与，
得到的结果也会是小数。
var a = 3/2 //1
var b = 1.0/2 //0.5
var c = 1500/1000*1000 //1000
2.在进行取模运算时，运算结果的正负取决于(%左边的数)的符号
var a = (-1)%2 //-1
var b = 1%(-2) //1
3.自增 “++” 和自减 “–” 运算符，在操作数的左边则先加/减再引用，
在操作数的右边则先引用再加/减
- 赋值运算符
Kotlin 中的赋值运算符也遵循从左往右的运算顺序，将右边表达式的结果赋值给左边变量。
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| = | 赋值 | a=6;b=5; | a=6;b=5; |
| += | 加等于 | a=6;b=5;a+=b; | a=11;b=5 |
| -= | 减等于 | a=6;b=5;a-=b; | a=1;b=5 |
| *= | 乘等于 | a=6;b=5;a*=b; | a=30;b=5 |
| /= | 除等于 | a=6;b=5;a/=b; | a=1;b=5 |
| %= | 模等于 | a=6;b=5;a%=b; | a=1;b=5 |
- 比较运算符
比较运算符用于对两个数值、变量或者表达式进行比较，结果为布尔值，true 或 false
| 运算符 | 运算 | 翻译 | 范例 | 结果 |
|---|---|---|---|---|
| == | 等于 | == ; | a=6;b=5; a==b | false |
| != | 不等于 | != ; | a=6;b=5; a!=b | true |
| < | 小于 | a.compareTo(b) < 0; | a=6;b=5; a < b | false |
| > | 大于 | a.compareTo(b) > 0; | a=6;b=5; a > b | true |
| <= | 小于等于 | a.compareTo(b) < =0; | a=6;b=6; a <= b | true |
| >= | 大于等于 | a.compareTo(b) >= 0; | a=6;b=6; a >= b | true |
- 逻辑运算符
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| ! | 非 | !true | false |
| !false | true | ||
| && | 短路与 | true&&true | true |
| true&&false | false | ||
| fasle&&false | false | ||
| false&&true | false | ||
| || | 短路或 | true||true | true |
| true||false | true | ||
| fasle||false | false | ||
| false||true | true |
注意：
- && 称为短路与，当运算符左边的值为 false 时，右边不进行运算
- || 称为短路或，当运算符左边的值为 true 时， 右边不进行运算
1.4 Kotlin 字符串
- 字符串声明
Kotlin 中用 String 表示字符串，定义如下
var str : String = "Hello Kotlin"
var str = "Hello Kotlin"
- 字符串常用操作
1.字符串查找
Kotlin 中提供了多个查找函数， first()、 last()、 get(index),分别对应查找字符串的第1个、最后1个、具体角标为 index 的元素
fun main(args : Array<String>){
var str = "Hello Kotlin"
println(str.first())// H
println(str.last())// n
println(str.get(3))// l
println(str.indexOf('o'))// 4
println(str.lastIndexOf('o'))// 6
}
2.字符串截取
Kotlin 中截取字符串函数为 subString() 和 subSequence(),对应重载函数见下表
| 方法声明 | 功能描述 |
|---|---|
| subString(startIndex : Int) | startIndex 为起始索引下标，从下标位置截取到字符串末尾，返回值为 String 类型 |
| subString(startIndex : Int, endIndex : Int) | startIndex 为起始索引下标， endIndex 为结束索引下标，字符串从 startIndex 位置截取到 endIndex - 1 处的字符 |
| subString(range: IntRange) | IntRange 表示 截取范围， 截取范围内的字符串 |
| subSequence(startIndex : Int, endIndex : Int) | 与 subString() 类似，字符串从 startIndex 位置截取到 endIndex - 1 处的字符， 只不过返回值类型为 CharSequence |
| subSequence(range : IntRange) | 与 subString() 类似，截取一定范围的字符串， 返回值类型为 CharSequence |
fun main(args : Array<String>){
var str = "Hello Kotlin"
println(str.substring(3))// lo Kotlin
println(str.substring(3, 7))// lo K
println(str.subSequence(3, 7))// lo K
println(str.substring(IntRange(3, 7)))// lo Ko
println(str.subSequence(IntRange(3, 7)))// lo Ko
}
3.字符串替换
Kotlin 中替换字符串函数为 replace()、replaceFirst()、replaceAfter()、replaceBefore()
| 方法声明 | 功能描述 |
|---|---|
| replace(oldChar, newChar, ignoreCase=false) | oldChar 表示要替换的字符串，newChar表示新字符串，ignoreCase 表示是否引用 java 中的 replace() 方法，默认 false |
| replaceFirst(oldValue, newValue) | 在原始字符串中查找第1个与 oldValue 相同的字符串，把满足条件的第1个字符串替换成 newValue 新的字符串。如果不满足条件，则返回原始字符串 |
| replaceBefore(delimiter, newValue) | 在原始字符串中查找第1个与delimiter 相同的字符串，将满足条件的第1 个字符串之前的所有字符串替换为 newValue，如果不满足条件，则放回原始字符串 |
| replaceAfter(delimter, newValue) | 在原始字符串中查找与 delimiter 相同的字符串，将满足条件的第1个字符串之后的所有字符串替换为 newValue，如果没有满足条件，则返回原始字符串 |
fun main(args : Array<String>){
var str = "Hello World! Hello World!"
println(str.replace("World", "Kotlin"))
println(str.replaceFirst("World", "Kotlin"))
println(str.replaceBefore("!", "Kotlin"))
println(str.replaceAfter("Hello ", "Kotlin!"))
/*Hello Kotlin! Hello Kotlin!
Hello Kotlin! Hello World!
Kotlin! Hello World!
Hello Kotlin!*/
}
4.字符串分割
Kotlin 中字符串分割函数为 split()
fun main(args : Array<String>){
var str = "hello.kotlin"
val split = str.split(".")
println(split)
//[hello, kotlin]
var test = "hello.kotlin/world"
var splitTest = test.split(".", "/")
println(splitTest)
//[hello, kotlin, world]
}
5.字符串去空格
Kotlin 中字符串去空格函数为 trim()、 trimEnd()等，分别去除前面、后面的空格
fun main(args : Array<String>){
var str = " Hello Kotlin! "
println(str.trim())
println(str.trimEnd())
//Hello Kotlin!
// Hello Kotlin!
}
6.字符串字面值
字符串的字面值是一串字符常量，字符串字面值常量是用双引号括起来" "的零个或多个字符，
如"hello". Kotlin 中有两种类型的字符串字面值,一种是转义字符串，可以包含转义字符，另一种是
原生字符串，可以包含转义字符、换行和任意文本。
- 转义字符串
转义采用传统的反斜杠 “” 方式将字符进行转义，
比如 \t, \b, \n, \r, ', ", \, \￥
fun main(args : Array<String>){
var str = "您\n好"
println(str)
//您
//好
}
- 原生字符串
原生字符串是使用 3 对引号( “”" “”" )把所有字符括起来，原生字符串可以有效地保证字符串中原有
内容的输出，即使原生字符串中包含转义字符串也不会转义。
fun main(args : Array<String>){
//转义字符串
var str1 = "您\n好"
println(str1)
//原生字符串
var str2 = """您 \n 好"""
println(str2)
/*您
好
您 \n 好*/
}
7.模版表达式
字符串可以包含模版表达式，所谓模板表达式就是在字符串中添加占位符，字符串模版表达式由
变 量 名 / 函 数 / 表 达 式 组 成 ， 也 可 以 省 略 , 例 如 " {变量名/函数/表达式} 组成，也可以省略{}, 例如 " 变量名/函数/表达式组成，也可以省略,例如"变量名"。
- 在字符串中，使用模板标识式存储字符串的值
fun main(args : Array<String>){
var a = 1
//语法格式 ${变量}
var s1 = "a is ${a}"
//可以省略大括号
var s2 = "a is $a"
println(s1)
println(s2)
//a is 1
//a is 1
}
- 在字符串中，使用模板表达式调用其它方法
fun main(args : Array<String>){
//语法格式 ${方法()}
println("${helloWorld()}")
//hello world
}
fun helloWorld() : String{
return "hello world"
}
- 在字符串中，使用模版表达式执行替换操作
fun main(args : Array<String>){
var s2 = "a is 1"
//语法格式 ${表达式}, 执行表达式
var s3 = "${s2.replace("is", "was")}"
println(s3)
//a was 1
}
- 在原生字符串中，使用模版表达式输出 $ 需要使用 KaTeX parse error: Expected '}', got 'EOF' at end of input: {''}, 因为原生字符串不支持反斜杠转义
fun main(args : Array<String>){
var price = """${'$'}8.88"""
println(price)
//$8.88
}
1.5 选择结构语句
- if 条件语句
当 if 条件满足时，即为 true 时，就走对应的代码块执行语句
fun main(args : Array<String>){
var max : Int = 0
var a : Int = 5
var b : Int = 6
if (a < b){
max = b
}else{
max = a
}
print("max="+ max)
//max=6
//上面的if else 可以简写成 三元运算符
var maxx = if (a > b) a else b
print("maxx="+ maxx)
}
kotlin 中的三元运算符表达式写法 if ( a > b) a else b
- when 条件语句
fun main(args : Array<String>){
var week : Int = 3
when(week){
1 -> print("星期一")
2 -> print("星期二")
3 -> print("星期三")
4 -> print("星期四")
5 -> print("星期五")
6 -> print("星期六")
7 -> print("星期日")
else -> {
print("输入的数字不正确.....")
}
}
//星期三
}
当 when 中表达式值和目标值匹配时，就执行 -> 后面的语句，类似 Java 中的 switch
fun main(args : Array<String>){
var month : Int = 9
when(month){
12, 1, 2 -> print("冬季")
3, 4, 5 -> print("春季")
6, 7, 8 -> print("夏季")
9, 10, 11 -> print("秋季")
else -> {
print("没有该月份，请重新输入.....")
}
}
//秋季
}
1.6 循环结构语句
- while 循环语句
fun main(args : Array<String>){
var n : Int = 4
while (n > 0){
println("n="+n)
n--
}
//n=4
//n=3
//n=2
//n=1
}
- do…while 循环语句
fun main(args : Array<String>){
var n : Int = 4
do {
println("n="+n)
n--
} while (n > 0)
//n=4
//n=3
//n=2
//n=1
}
- for 循环语句
fun main(args : Array<String>){
//循环4次，且步长为1进行递增，0..3 表示[0,3]之间的数字
for (i in 0..3){
println("i => $i \t")
}
//i => 0
//i => 1
//i => 2
//i => 3
}
当 for 循环只有一条执行语句，可以省略 {}, 简写成
for (i in 0…3) println(“i => $i \t”)
- 循环嵌套
fun main(args : Array<String>){
//循环5次，且步长为1进行递增，0..5 表示[0,5]之间的数字
for (i in 0..5){
for(j in 0..i){
print("*")
}
print("\n")
}
//*
//**
//***
//****
//*****
//******
}
- forEach 循环语句
1.普通的 forEach 语句
调用者.forEach(){
println(“it=${it}”)
}
调用者可以是数组或集合， it 表示数组中的元素
fun main(args : Array<String>){
//定义arr数组并初始化
var arr : IntArray = intArrayOf(1, 2, 3, 4)
arr.forEach { print(it.toString() + "\t") }
//1 2 3 4
}
2.带角标的 forEachIndexed 语句
调用者.forEachIndexed(){
index, it ->
println(“角标= i n d e x 元 素 = index元素= index元素={it}”)
}
index 表示数组角标或集合索引， it 表示数组角标或集合索引 对应的元素
fun main(args : Array<String>){
//定义arr数组并初始化
var arr : IntArray = intArrayOf(1, 2, 3, 4)
arr.forEachIndexed { index, it ->
println("角标=$index 元素=${it}")
}
//角标=0 元素=1
//角标=1 元素=2
//角标=2 元素=3
//角标=3 元素=4
}
- 跳转语句(continue、break）
1.break 语句
停止循环，跳出整个循环
注意: 当 break 出现在嵌套循环的内层循环中时，它只能跳出内存循环，如果想要跳出外层循环则需要对外层循环添加 loop@
fun main(args : Array<String>){
//循环9次，且步长为1的递增
loop@
for (i in 0..9){ //外层循环
for (j in 0..i){ //内层循环
if (i > 4){ //判断i是否大于4
break@loop //跳出外层循环
}
print("*") //打印*
}
print("\n") //换行
}
//*
//**
//***
//****
//*****
}
2.continue 语句
终止当前这一次循环，继续下一次
fun main(args : Array<String>){
var sum : Int = 0 //定义一个变量sum，用于记录奇数的和
//循环100次，且步长为1的递增，1 until 101 表示 [1,101], 其中不包含数字101
for (i in 1 until 101){
if (i % 2 == 0){ //判断i是一个偶数时，不累加
continue //结束本次循环
}
sum += i //实现sum和i的累加
}
print("sum="+ sum) //打印奇数的和
//sum=2500
}
1.7 Kotlin 区间
- 正向区间
区间通常是指一类数据的集合。例如，由符合 0 <= a <= 1 的实数组成的一个集合便是一个区间。
在 Kotlin 中，区间通过 rangeTo(other : Int) 函数构成区间表达式，也可以用 “…” 操作符表示。
fun main(args : Array<String>){
for(i in 1.rangeTo(4)){
print(i.toString() + "\t")
}
print("\n")
for (i in 1..4){
print(i.toString() + "\t")
}
//1 2 3 4
//1 2 3 4
}
注: Kotlin 中还有另外一个函数 until(to : Int), 该函数和 rangeTo() 非常相似，只不过前
者不包含结尾元素，并且该函数使用时可省略(),在 util 后面加上空格符，空格符后面加上范围值即可
fun main(args : Array<String>){
for(i in 1 until 4){
print(i.toString() + "\t")
}
// 1 2 3
}
- 逆向区间
上面的区间其实是按照一个正向顺序执行的区间，在 Kotlin 中，也可以通过 downTo(to : Int) 函
数实现逆向区间，该函数也可省略()， 在 downTo 后面加上空格符。
fun main(args : Array<String>){
for(i in 4 downTo 1){
print(i.toString() + "\t")
}
// 4 3 2 1
}
- 步长
上面介绍的区间默认使用的步长都是1，即每次递增或递减的差值为1，可以通过 step(step : Int）
函数来指定步长。同样可以省略()， 在 step 后面加空格符，再加上步长。
fun main(args : Array<String>){
for(i in 1..4 step 2){
print(i.toString() + "\t")
}
print("\n")
for (i in 4 downTo 1 step 2){
print(i.toString() + "\t")
}
// 1 3
// 4 2
}
1.8 Kotlin 数组
- 数组定义
在 Kotlin 中，数组使用 Array 表示，其中可定义的类型有 数值类型、布尔类型、字符类型、字符串类型。
//第一种定义方式
var int_array : IntArray = intArrayOf(1, 2, 3)
//第二中定义方式
var int_array1 : Array<Int> = arrayOf(1, 2, 3)
var string_array : Array<String> = arrayOf("a", "b", "c")
- 数组常用操作
1.数组遍历
- for 循环遍历数组，依次访问数组中的每个元素
fun main(args : Array<String>){
var intArray : IntArray
intArray = intArrayOf(1, 2, 3, 4)
for (i in intArray){
println(i)
}
// 1
// 2
// 3
// 4
}
- for 循环遍历数组中元素及角标
fun main(args : Array<String>){
var intArray : Array<Int>
intArray = arrayOf(1, 2, 3, 4)
intArray[0] = 10 //将角标为0对应的元素设置为10
intArray.set(3, 16) //将角标为3对应的元素设置为16
intArray.forEachIndexed { index, i ->
println("角标=$index 元素=$i")
}
//角标=0 元素=10
//角标=1 元素=2
//角标=2 元素=3
//角标=3 元素=16
}
2.数组最值
操作数组元素时，经常需要获取数组中的元素的最值。
fun main(args : Array<String>){
var arr : IntArray = intArrayOf(1, 2, 3, 4)
var max = arr[0]
for (i in arr){
if (i > max){
max = i
}
}
println("max=" + max)
//max=4
}
3.数组元素修改
例1中已经演示过了，通过 数组[角标] = 新值，或通过 set(角标， 新值) 函数修改
4.查找数组元素角标
fun main(args : Array<String>){
var newArray : Array<Int> = arrayOf(8, 4, 5, 4, 9)
println("第1个元素4的角标="+newArray.indexOf(4))
var index = newArray.indexOfFirst {
it == 4
}
println("第1个元素4的角标="+index)
println("最后1个元素4的角标="+newArray.lastIndexOf(4))
var indexL = newArray.indexOfLast {
it == 4
}
println("最后1个元素4的角标="+indexL)
//第1个元素4的角标=1
//第1个元素4的角标=1
//最后1个元素4的角标=3
//最后1个元素4的角标=3
}
1.9 Kotlin 变量类型转换
- 类型检查
为避免变量在进行类型转换时，由于类型不一致而出现类型转换异常问题，可通过操作 is 或 !is 检测
对象是否是特定类的一个实例，有点类型 Java 中的 instance
fun main(args : Array<String>){
var a : Any = "hello"
var result1 = a is String
var result2 = a !is String
println(result1)
println(result2)
//true
//false
}
- 智能类型转换
Kotlin 编译器是非常智能的，它能识别 is 和 !is 操作符，这样就能判断出当前对象是否属于后面的
数据类型。如果当前对象属于 is 后面的数据类型，则在使用该对象时会自动进行智能类型转换。
fun main(args : Array<String>){
var a : Any = "hello"
if (a is String){
println("a is String")
println("字符串长度:" + a.length)//操作时自动转换为String类型
}else if (a !is Int){
println("a !is Int")
}else{
println("I don't know")
}
//a is String
//字符串长度:5
}
- 强制类型转换
使用到的操作符为
as 进行强制类型转换，转换失败则抛出异常
as? 进行强制类型转换，转换失败，不抛出异常，返回 null
fun main(args : Array<String>){
var a = 1
var b : String = a as String
print(b.length)
//上面的情况会抛出 异常
var c : String? = a as? String
print(c?.length)
}
2.0 Kotlin 空安全
- 可空类型变量( ? )
Kotlin 中声明可空类型变量和非空类型变量如下
var name : String //声明可空变量
var age : Int? //声明非空变量
在使用可空变量时，如果不知道变量的初始值，则需要将其赋值为 null， 否则会报 " Variable age must be initalizd" 异常。
fun main(args : Array<String>){
var name : String = "Mike"
var telephone : String? = null
if (telephone != null){
print(telephone.length)
}else{
telephone = "18386868989"
print("telephone = " + telephone)
}
//telephone = 18386868989
}
- 安全调用符( ?. )
为了替代上面的复杂可空变量判断 if…else 逻辑, Kotlin 提供了一个安全调用符 ?.
语法格式为， “变量?.成员”, 只有当变量不为 null 时，才调用变量的成员方法或属性
fun main(args : Array<String>){
var name : String = "Mike"
var telephone : String? = null
var result = telephone?.length
print(result)
//null
}
- Evlis 操作符( ?: )
在使用安全调用符调用可空变量中的成员方法或属性时，如果当前变量为空，则会返回一个 null 值，
但有时即使当前变量为 null，也不想返回一个 null 而是指定的一个默认值。那么该如何处理呢？
Kotlin 为此提供了一个 Evlis 操作符( ?: ), 语法格式为 “表达式?:表达式”。如果左侧表达式
非空，则返回左侧表达式的值，若为空，则返回右侧表达式的值。
fun main(args : Array<String>){
var name : String = "Mike"
var telephone : String? = null
var result = telephone?.length ?: "18386868989"
print(result)
//18386868989
}
- 非空断言( !!. )
在 Kotlin 中还可以通过非空断言( !!. )来调用可空类型变量的成员方法或属性。 语法格式为
“变量!!:成员”， 非空断言会将任何变量(可空类型变量或非空类型变量)转换为非空类型的变量，若为
空则抛出异常。
fun main(args : Array<String>){
var name : String = "Mike"
var telephone : String? = null
var result = telephone!!.length
print(result)
//Exception in thread "main" kotlin.KotlinNullPointerException
// at cn.test.kotlin.KtTestKt.main(KtTest.kt:8)
}
程序抛出了空指针异常，如果变量 telephone 赋值不为空，则程序正常运行。
空安全调用符 和 非空断言都可以调用可空变量的方法，当相比而言，空安全调用符更安全，不会抛出异常，推荐使用空安全调用符。
后续
Kotlin 进阶之路(二) 函数