Kotlin第五讲-Kotlin的类型和空处理

##Kotlin的类型
类型就是数据的分类,不同类型代表不同种类的数据。

Kotlin里类型分为:可空类型,非空类型,平台类型

####对平台类型的理解
平台类型:Kotlin不知道可空性信息的类型,即当作可空类型也可当作非空类型。所以在这个类型上的所有操作需要程序员自己负责,编译器允许所有的操作。通常发生在Kotlin调用Java代码的场景上。

以字符串类型举例,字符串平台类型如下:

String!

程序员不能使用这种语法,Java代码转Kotlin代码的时候会出现,表示可控性未知,也可以理解为己有肯能是非空类型也有可能是可空类型

####非空类型和可空类型的理解
可空类型 = 非空类型 + null

Type? = Type + null

因此,String?,String是两种不同的数据类型,就像Int和String是两种数据类型那般。

###基本数据类型
Kotlin不区分基本数据类型和包装类型,都是使用一种基本类型:

下面是非空基本类型

Char, Boolean, Byte, Short, Int,Long, Float, Double

可空基本类型

Char?, Boolean?, Byte?, Short?, Int?,Long?, Float?, Double?

Kotlin的基本类型如果转成Java基本数据类型,要怎么办?

对于变量、属性、参数和返回类型,Kotlin的基本类型会被编译成Java的基本数据类型。
用作泛型类型参数的基本数据类型会被编译成对应的Java包装类型。

注意:

和Java不同,小范围的值不能自动转化为大范围的值,而是看成两种不同的类型

下面的代码演示了数据类型的表示,各类型转化,数据类型智能推断,字符串类型转成基本数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
fun testBasicType() {
val bb: Byte = 127
val boolean = false
val aa: Char = 'a'

var i: Int = 21_4748_3647 //10位
var l: Long = 922_3372_0368_5477_5807L //19位 //不存在小写的l

val f: Float = 123f
val f2: Float = 124F

val a16 = 0x123ef3
val b16 = 0XcCCef3

val c2 = 0b1010
val cc2 = 0B11001

val b: Byte = 1

val eas = b + 1L //Long + Byte => Long , eas为Long类型

fun foo(l: Long) {
println(l)
}

foo(44) //单独写44可能是byte,int long,这里智能推断44会被认为是long

//字符串转基本数据类型
val p = "44".toInt()
val p2 = "44".toLong()
val p3 = "44".toFloatOrNull()
val p4 = "44".toDouble()

val translate = l.toInt().toLong().toFloat().toDouble().toInt()
}

###Any,Unit,Nothing类型

Any 相当于 Object,不同点:是非空类型,缺少Object的wait,notify方法

Unit相当于Java的Void;不同点:Unit是一个完备的类型,可以作为类型参数。Unit是Any的子类

Nothong表明函数不会有返回类型(没有返回类型),该函数不会正常终止,Nothing是Unit的子类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
fun getStrinLenght(s: String?): Int {
if (s == null) {
throw IllegalArgumentException()
} else {
return s.length
}
}

fun fail(): Nothing = throw IllegalArgumentException()

fun getStrinLenght2(s: String?): Int =
if (s == null) {
fail()
} else {
s.length
}

fun testAnyAndNothing(o: Any?): View {
val filterO = o ?: fail()

return when (filterO) {
is View -> {
View("View")
}
is TextView -> {
TextView("TextView", "")
}
else -> {
fail()
}
}
}

可以认为:throw IllegalArgumentException()返回的类型是Nothing,nothing是Int的子类型。

####小结
Any,Unit和Nothing三者关系: A Whirlwind Tour of the Kotlin Type Hierarchy

##空安全相关的运算符

###安全调用?.
如果值是null,整个表达式的值为null。

1
2
3
4
5
6
7
8
open class Company(val name: String, val address: String?)

fun testNullType(){
val company = Company("京东", null)

val length = company.address?.length
println("length = $length")
}

###Elvis运算符 ?:

1
2
3
4
5
6
7
8
9
10
fun testElvis(list: List<Company?>?, defaultAddress: String?){
val defaultAdd = defaultAddress ?: ""
val length = defaultAddress?.length ?: 0 //.?为空调用,表达式返回null,遇到了?:
println("defaultAdd = $defaultAdd, length = $length")

val companyList = list ?: throw IllegalArgumentException("null list")

val address = companyList[0]?.address?.toUpperCase() ?: defaultAddress //多重空安全调用和Elvis联合使用
println("address = $address")
}

###安全转换as?
as?运算法尝试把值转换成制定的类型,如果值不是合适的类型就返回null。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
open class View(val name: String)

class TextView(name: String, val text: String) : View(name)

fun testAsClient(){
val company = Company("JD", "亦庄")
testAs(company)

testAs2(company)

val tv = TextView("TextView", "I am a message content")
testAs2(tv)
}

fun testAs(o: Any){
val tv = o as TextView
println("name = ${tv.name}")
}

fun testAs2(o: Any){
val tv = o as? TextView ?: TextView("Default TextView", "")
println("The content of ${tv.name} is = ${tv.text}")
}

###非空断言 !!

把任何值转换成非空类型

1
2
3
4
5
6
7
8
9
10
fun testNoNullClient(){
val result = testNoNull("Kotlin")
println("result = $result")
}

fun testNoNull(s: String?) : String{
val length = s!!.length
println("$s's length is $length")
return s!!.toUpperCase()
}

###let函数

把可空值作为实参传递一个只接收非空值的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fun testLet(){
val length = getTheBigCompanyInTheWorld().address?.length
val upperCase = getTheBigCompanyInTheWorld().address?.toUpperCase()
val letter = getTheBigCompanyInTheWorld().address?.get(0)
println("address's length is $length , uppercase = $upperCase, letter = $letter")
}

fun testLet2(){
getTheBigCompanyInTheWorld().address?.let {
val upperCase = it.toUpperCase()
val length = it.length
val letter = it[0]
println("address's length is $length , uppercase = $upperCase, letter = $letter")
}
}

fun getTheBigCompanyInTheWorld(): Company = Company("JD", "Beijing")

###可空类型的扩展函数

允许接收者为null的调用,在扩展函数内部处理null。不需要安全调用了

看几个Kotlin标准库,String定义的扩展函数isNullOrEmpty

1
2
3
public inline fun CharSequence?.isNullOrEmpty(): Boolean {
return this == null || this.length == 0
}

注意:

在Java中,this永远是非空的,在Kotlin中,this可以为null。

因此在定义扩展函数时,需要考虑扩展是否需要为可空类型定义。本质上是对null在哪个环节处理的思考,是要在调用时使用空安全调用处理呢,还是在调用的函数内部处理。

###泛型参数默认是可空类型

1
2
3
4
5
6
7
fun <T> myPrintln(t: T){
println(t.toString())
}

fun testGenericityClient(){
myPrintln(null)
}

###转Java代码为Kotlin代码时,对空的处理

####带注解的Java变量翻译到Kotlin时被认为是可空类型或者非空类型

  1. Javax.annotation包下
  2. android.support.annotation包下
  3. org.jetbrains.annotations下

@Nullable + Type = Type?
@NotNull + Type = Type

##参考资料
Kotlin实战