kotlin基本数据类型

包定义

package my.demo
import java.util.*

函数定义

    //有返回值函数,两个参数
    fun sum(a:Int,b :Int):Int{
        return a+b
    }
    //无返回值函数，其中unit可以省略
    fun sum2(a: Int,b: Int):Unit{
        print(sum of $a and $b is ${a + b})
    }
    //将表达式作为函数体、返回值类型自动推断的函数
    fun sum(a: Int, b: Int) = a + b
    //若为public方法，则必须明确写出返回类型
      public fun sum(a: Int, b: Int): Int = a + b

局部变量定义

//不可变变量定义，val 关键字，只能赋值一次的变量(类似Java中final修饰的变量)
    val a:Int=1 //直接赋值 等同于int a=1；
    val b:Int   //如果没有初始值类型不能省略 等同于 int b; b=2;
    b=2
    val c=3 //这样自动推断出 `Int` 类型，不用写类型
    println("a="+a)
    println("b="+b)
    println("c="+c)
//可变变量定义，变量可修改，用var关键字
    var x = 5 // 自动推断出 `Int` 类型
     x += 1
    println("x="+x)
输出结果：
a=1
b=2
c=3
x=6

不可变变量定义，val 关键字----可变变量定义,用var关键字

常量与变量都可以没有初始化值,但是在引用前必须初始化

如果没有初始值类型不能省略

编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。

注释

// 这是一个行注释

/* 这是一个多行的
   块注释。 */
与 Java 不同的是，Kotlin 的块注释可以嵌套。

字符串

$varName 表示变量值

${varName.fun()} 表示变量的方法返回值

    var a=1 //可变
    val s1="a is $a" //不可变
    a+=1
    val s2=s1.replace("is","was")
    val s3="$s2,now a is $a"
    println(s3)
输出结果
a was 1,now a is 2

if表达式

    var a=1 //可变
    var b=2
    var c:Int
    if (a>b)c=a else c=b
    print(c)
输出结果：
2

使用可空值及 null 检测

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

   var s:String?=null
    print(s)
结果：
null

但要是没有指定s可为null，是不用使用的

image.png

//类型后面加?表示可为空
    var age: String? = null
//抛出空指针异常
    //val ages = age!!.toInt()
//不做处理返回 null
    val ages1 = age?.toInt()
//age为空返回-1
    val ages2 = age?.toInt()?: -1
   // println(ages)
    println(ages1)
    println(ages2)
输出结果：
null
-1

类型检测及自动类型转换

我们可以使用 is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字)，和java不同的是可以 !is

fun getStringLength(obj: Any): Int? {
  if (obj !is String)
    return null  //类型还是any
  return obj.length  // obj` 的类型会被自动转换为 `String`
}

for循环

val items = listOf("apple", "banana", "kiwi")
for (item in items) {
    println(item)
}
输出结果：
apple
banana
kiwi

val items = listOf("apple", "banana", "kiwi")
for (index in items.indices) {
    println("item at $index is ${items[index]}")
}
输出结果：
item at 0 is apple
item at 1 is banana
item at 2 is kiwi

while循环

val items = listOf("apple", "banana", "kiwi")
var index = 0
while (index < items.size) {
    println("item at $index is ${items[index]}")
    index++
}
输出结果：
item at 0 is apple
item at 1 is banana
item at 2 is kiwi

使用 when 表达式

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

使用区间

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

val list = listOf("a", "b", "c")
if (-1 !in 0..list.lastIndex) {
//-1是否在0-2这个区间内
    println("-1 is out of range")
}
if (list.size !in list.indices) {
//list.size=3 是否在0-2这个区间
    println("list size is out of valid list indices range too")
}
输出结果：
-1 is out of range
list size is out of valid list indices range too

区间迭代

for (x in 1..5) {
    print(x)
}
输出：12345

数列迭代

for (x in 1..10 step 2) {
    print(x)//输出13579
}
for (x in 9 downTo 0 step 3) {
    print(x)//输出9630
}

// 使用 until 函数排除结束元素

for (i in 1 until 10) {   // i in [1, 10) 排除了 10
     println(i)  //123

返回和跳转

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

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

fun main(args: Array<String>) {
   for (i in 1..10) {
       if (i==3) continue  // i 为 3 时跳过当前循环，继续下一次循环
       println(i)
       if (i>5) break   // i 为 6 时 跳出循环
   }
}
result:
1
2
4
5
6