第一天学 Kotlin

痛定思痛。 2022-06-14 02:39 164阅读 0赞

基本类型  
kotlin 提供了如下的内置类型来表⽰数字（与 Java 很相近）：  
Type Bit width  
Double 64  
Float 32  
Long 64  
Int 32  
Short 16  
Byte 8

类型转换只能显示转换  
val i: Int = b.toInt() // OK: 显式拓宽  
但是进行运算会自动转换成更大的类型

字符：  
var c: Char = ‘a’

布尔：  
var b = false

数组：  
var array: Array = arrayOf(1, 2, 3)

字符串面值：  
val text = “””  
for (c in “foo”)  
print(c)  
“””  
println(text)

输出：  
for (c in “foo”)  
print(c)

字符串模板：  
val s = “abc”  
val str = “*s*.*l**e**n**g**t**h**i**s*\{s.length\}” // 求值结果为 “abc.length is 3”

控制流：

if表达式  
val max = if (a > b) a else b

val max = if (a > b) \{  
print(“Choose a”)  
a  
\} else \{  
print(“Choose b”)  
b  
\}

when表达式：  
when (x) \{  
1 -> print(“x == 1”)  
2 -> print(“x == 2”)  
else -> \{ // 注意这个块  
print(“x is neither 1 nor 2”)  
\}  
\}  
when 将它的参数和所有的分⽀条件顺序⽐较，直到某个分⽀满⾜条件。when 既可以被当做表达式使⽤也可以被当做语句使⽤。如果它被当做表达式，符合条件的分⽀的值就是整个表达式的值，如果当做语句使⽤，则忽略个别分⽀的值。（像 if ⼀样，每⼀个分⽀可以是⼀个代码块，它的值 是块中最后的表达式的值。）如果其他分⽀都不满⾜条件将会求值 else 分⽀。如果 when 作为⼀个表达式使⽤，则必须有 else 分⽀，除⾮编译器能够检测出所有的可能情况都已经覆盖了。如果很多分⽀需要⽤相同的⽅式处理，则可以把多个分⽀条件放在⼀起，⽤逗号分隔：  
when (x) \{  
0, 1 -> print(“x == 0 or x == 1”)  
else -> print(“otherwise”)  
\}  
when (x) \{  
parseInt(s) -> print(“s encodes x”)  
else -> print(“s does not encode x”)  
\}  
我们也可以检测⼀个值在（in）或者不在（!in）⼀个区间或者集合中：  
when (x) \{  
in 1..10 -> print(“x is in the range”)  
in validNumbers -> print(“x is valid”)  
!in 10..20 -> print(“x is outside the range”)  
else -> print(“none of the above”)  
\}  
另⼀种可能性是检测⼀个值是（is）或者不是（!is）⼀个特定类型的值。注意：由于智能转换，你可以访问该类型的⽅法和属性⽽⽆需 任何额外的检测。  
fun hasPrefix(x: Any) = when(x) \{  
is String -> x.startsWith(“prefix”)  
else -> false  
\}  
when 也可以⽤来取代 if-else if链。如果不提供参数，所有的分⽀条件都是简单的布尔表达式，⽽当⼀个分⽀的条件为真时则执⾏该分⽀：  
when \{  
x.isOdd() -> print(“x is odd”)  
x.isEven() -> print(“x is even”)  
else -> print(“x is funny”)  
\}

for循环：  
for 循环可以对任何提供迭代器（iterator）的对象进⾏遍历，语法如下:  
for (item in collection) print(item)  
循环体可以是⼀个代码块。  
for (item: Int in ints) \{  
// ……  
\}  
如上所述，for 可以循环遍历任何提供了迭代器的对象。即：  
有⼀个成员函数或者扩展函数 iterator() ，它的返回类型  
有⼀个成员函数或者扩展函数 next() ，并且  
有⼀个成员函数或者扩展函数 hasNext() 返回 Boolean 。  
这三个函数都需要标记为 operator 。  
对数组的 for 循环会被编译为并不创建迭代器的基于索引的循环。  
如果你想要通过索引遍历⼀个数组或者⼀个 list，你可以这么做：  
for (i in array.indices) \{  
print(array\[i\])  
\}  
注意这种“在区间上遍历”会编译成优化的实现⽽不会创建额外对象。  
或者你可以⽤库函数 withIndex ：  
For 循环  
—  
——  
for ((index, value) in array.withIndex()) \{  
println(“the element at *i**n**d**e**x**i**s*value”)  
\}

while 和 do while  
和Java差不多  
while (x > 0) \{  
x–  
\} do \{  
val y = retrieveData()  
\} while (y != null) // y 在此处可⻅

Kotlin 有三种结构化跳转表达式：

return。默认从最直接包围它的函数或者匿名函数返回。  
break。终⽌最直接包围它的循环。  
continue。继续下⼀次最直接包围它的循环。