Kotlin 进阶之路(一) 编程基础

最新推荐文章于 2024-03-29 11:03:42 发布

cczhengv

最新推荐文章于 2024-03-29 11:03:42 发布

阅读量2.9k

点赞数 6

分类专栏： Kotlin 进阶之路文章标签： Kotlin

本文链接：https://blog.csdn.net/u012932409/article/details/91635887

版权

Kotlin 进阶之路专栏收录该内容

7 篇文章 9 订阅

订阅专栏

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 元素 =$ {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 进阶之路(二) 函数

cczhengv

关注

6
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Kotlin 进阶之路(一) 编程基础

运算符运算范例结果=赋值a=6;b=5;a=6;b=5=赋值a=6;b=5;a=6;b=5=赋值a=6;b=5;a=6;b=5=赋值a=6;b=5;a=6;b=5=赋值a=6;b=5;a=6;b=5
复制链接

扫一扫