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不同，小范围的值不能自动转化为大范围的值，而是看成两种不同的类型
下面的代码演示了数据类型的表示，各类型转化，数据类型智能推断，字符串类型转成基本数据类型
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的子类
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。
open class Company(val name: String, val address: String?)
fun testNullType(){
val company = Company("京东", null)
val length = company.address?.length
println("length = $length")
}
Elvis运算符 ？：
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。
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}")
}
非空断言 !!
把任何值转换成非空类型
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函数
把可空值作为实参传递一个只接收非空值的函数
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
public inline fun CharSequence?.isNullOrEmpty(): Boolean {
return this == null || this.length == 0
}
注意：
在Java中，this永远是非空的，在Kotlin中，this可以为null。
因此在定义扩展函数时，需要考虑扩展是否需要为可空类型定义。本质上是对null在哪个环节处理的思考，是要在调用时使用空安全调用处理呢，还是在调用的函数内部处理。
泛型参数默认是可空类型
fun <T> myPrintln(t: T){
println(t.toString())
}
fun testGenericityClient(){
myPrintln(null)
}
转Java代码为Kotlin代码时，对空的处理
带注解的Java变量翻译到Kotlin时被认为是可空类型或者非空类型
- Javax.annotation包下
- android.support.annotation包下
- org.jetbrains.annotations下
@Nullable + Type = Type?
@NotNull + Type = Type
