[移动开发]Kotlin学习——基础

基本概念

函数

//带有两个 Int 参数、返回 Int 的函数
fun sum(a: Int, b:Int): Int{
 return a+b
}

//将表达式作为函数体、返回值类型自动推断的函数
fun sum(a:Int, b:Int) = a+b

//函数返回无意义的值, Unit返回类型可以省略
fun printSum(a:Int, b:Int): Unit{
    println("sum of $a and $b is ${a+b}")
}

fun printSum(a:Int, b:Int){
    println("sum of $a and $b is ${a+b}")
}

变量

val：定义只读局部变量实用关键字val定义，只能为其赋值一次

val a:Int = 1   //立即赋值
val b =2    //自动推断出‘Int’类型
val c: Int  //如果没有初始值类型不能省略

var：可重新赋值的变量使用var关键字

var x = 6 //自动推断出 Int 类型
x+=1

空值与null检测

当某个变量的值可以为null的时候，必须在声明处的类型后添加 ‘?’ 来标识该引用可为空

fun parseInt(str: String): Int?{
    //....
}

fun parseInt(str: String): Int?{
    return str.toIntOrNull()
}

类型检测与自动类型转换

is 运算符检测一个表达式是否某类型的一个实例。如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中（该方法中）可以直接当作该类型使用，无需显式转换

when表达式

fun describe(obj: Any):String =
    when(obj){
        1           -> "One"
        "Hello"     -> "Greeting"
        is Long     -> "Long"
        !is String  ->"Not a String"
        else        -> "Unknown"
    }

使用区间（range）

使用 in 运算符来检测某个数字是否在指定区间内

val x = 10
val y = 9
if( x in 1..y+1){
    println("fits in range")
}

//检测某个数字是否在指定区间外
val list = listOf("a", "b", "c")
if(-1 !in 0..list.lastIndex){
    println("-1 is out of range")
}

//区间迭代
for(x in 1..5){
    print(x)
}

//数列迭代
for(x in 1..10 step 2){
    print(x)
}

基本类型

数字

对于整数，有四种不同大小的类型，因此值的范围也不同。所有未超出Int最大值的整型值初始化的变量都会推断为Int类型。如果初始值超过了其最大值，那么推断为Long类型。如需要显式指定Long型值，需在该值后追加L后缀

对于浮点数，提供了Float和Double类型。对于以小数初始化的变量，编译器会推断为Double类型。如需将一个值显式指定为Float类型，需添加f或F后缀，如果这样的值包含多于6～7位十进制数，那么会将其舍入。

注意Kotlin中的数字没有隐式拓展转换。例如，具有Double参数的函数只能对Double值调用，而不能对Float、Int或者其它数字值调用，如果要将数值转换为不同的类型，请使用显示转换

字面常量

数值常量字面值有以下几种：

• 十进制：123（Long类型用大写L标记：123L）
• 十六进制：0x0F
• 二进制：0b00001011

注意：不支持八进制，数字字面值可以使用下划线来分割使数字常量更易读

表达方式

在Java平台数字是物理存储为JVM的原生类型，除非我们需要一个可空的引用（如Int？）或范型。范型情况下会把数字装箱

注意数字装箱不一定保留同一性，另一方面，它保留了相等性

fun main(){
    val a: Int = 100
    val boxedA: Int? =a
    val boxedB: Int? =a

    //同一性：同一个事物物体
    println(a === a) //输出true
    println(boxedA === boxedB) //输出false

    //相等性
    println(boxedA == boxedB)

显式转换

由于不同的表示方式，较小类型并不是较大类型的子类型。因此较小的类型不能隐式转换为较大的类型。这意味着在不进行显式转换的情况下我们不能把 Byte 型值赋值给一个 Int 变量。

每个数字类型支持如下的转换（显式转换）：

• toByte(): Byte
• toShort(): Short
• toInt(): Int
• toLong(): Long
• toFloat(): Float
• toDouble(): Double
• toChar(): Char

运算

位运算列表（只用于 Int 与 Long）：

• shl（bits）?—— 有符号左移
• shr（bits）—— 有符号右移
• ushr（bits）——无符号右移
• and（bits）——位与
• or（bits）——位或
• xor（bits）——位异或
• inv（）——位非

浮点数比较

• 相等性检测：a == b 与 a！=b
• 比较操作符：a < b、a > b、a <= b、a >= b
• 区间实例以及区间检测：a..b、x in a..b、x !in a..b

字符

? ? 字符用 Char 类型表示。他们不能直接当作数字，字符字面值用单引号括起来：‘1’。特殊字符可以用反斜杠转义。当需要可空引用时，像数字、字符会被装箱。装箱操作不会保留同一性

布尔

? ? 用 Boolean 类型表示，有 true 和 false 两个值，若需要可空引用布尔会被装箱。内置的布尔运算有：

• ||? ? ?——短路逻辑或
• &&? —— 短路逻辑与
• !? ? ? ——短路逻辑非

数组

? ? 数组使用 Array 类来表示，它定义了 get 与 set 函数以及 size 属性，我们可以使用库函数 arrayOf() 来创建一个数组并传递元素值给它，例如这样 arrayOf(1,2,3)创建了 array[1,2,3]；或者库函数 arrayOfNulls() 可以用于创建一个指定大小的、所有元素都为空的数组。kotlin中数组是invariant的，这意味着我们不能把 Array<String> 赋值给 Array<Any>

//创建一个 Array<String> 初始化为 ["0","1","4","9","16"]
val asc = Array(5)->{i -> (i*i).toString()}

Kotlin 中也有无装箱开箱的专门类来表示原生类型数组：ByteArray、ShortArray等，这些类与Array并没有继承关系，但是它们有同样的方法属性集

无符号整型

? Kotlin为无符号整数引入了以下类型

• kontlin.UByte：无符号8比特整数，范围是0到255
• kontlin.UShort：无符号16比特整数，范围是0到65535
• konlin.UInt：无符号32比特整数，范围是0到2^32-1
• konlin.ULong：无符号64比特整数，范围是0到2^64-1

无符号类型支持其对应有符号类型的大多数操作

与原生类型相同，每个无符号类型都有相应的为该类型特化的表示数组的类型，例如konlin.UByteArray、kotlin.UShortArray

为了使无符号整型更易于使用，Kotlin提供了用后缀标记整型字面值来表示指定无符号类型（类似于Float/Long），后缀u或U将字面值标记为无符号，确切类型会根据预期类型确定，如果没有提供预期的类型，会根据字面值大小选择 UInt 或 ULong

字符i串

用String类型表示，字符串是不可变的；字符串的元素——字符可以使用索引运算符访问：s[i]。

val str ="abcd"

//可以用 for 循环迭代字符串
for(c in str){
    println(c)
}

//可以用 + 操作符连接字符串，也适用于连接字符串
//与其它类型的值，只要表达式中的第一个元素是字符串
val s = "abc"+1

字符串模板：字符串字面值可以包含模版表达式，即一些小段代码，会求值并把结果合并到字符串中。模版表达式以美元符（$）开头

Break和Continue标签

在Kotlin中任何表达式都可以用标签（label）来标记。标签的格式为标识符后跟@符号，例如：abc@、fooBar@都是有效的标签。要为一个表达式加标签，我们只要在其前加标签即可

loop@ for ( i in 1..100){
    //....
    if(...) break@loop
}

标签限制的break跳转到刚好位于该标签指定的循环后面的执行点。continue继续标签指定的循环的下一次迭代