Kotlin基础语法

Kotlin文件以.kt为后缀

一、函数定义

函数定义使用关键字fun，参数格式为：参数：类型

fun sum(a: Int, b: Int): Int {   // Int 参数，返回值 Int
    return a + b
}

表达式作为函数体，返回类型自动推断：

fun sum(a: Int, b: Int) = a + b

public fun sum(a: Int, b: Int): Int = a + b   // public 方法则必须明确写出返回类型

无返回值的函数（类似Java中的void）

fun printSum(a: Int, b: Int): Unit { 
    print(a + b)
}


// 如果是返回 Unit类型，则可以省略(对于public方法也是这样)：
public fun printSum(a: Int, b: Int) { 
    print(a + b)
}

二、可变长参数函数

函数的变长参数可以用 vararg 关键字进行标识：

fun vars(vararg v:Int){
    for(vt in v){
        println(vt)
    }
}

// 测试
fun main(args: Array) {
    vars(1,2,3,4,5) 
}

测试结果

2019-06-17 11:47:41.990 28662-28662/com.example.kotlindemo I/System.out: 1
2019-06-17 11:47:41.997 28662-28662/com.example.kotlindemo I/System.out: 2
2019-06-17 11:47:42.002 28662-28662/com.example.kotlindemo I/System.out: 3
2019-06-17 11:47:42.006 28662-28662/com.example.kotlindemo I/System.out: 4
2019-06-17 11:47:42.011 28662-28662/com.example.kotlindemo I/System.out: 5
2019-06-17 11:47:42.015 28662-28662/com.example.kotlindemo I/System.out: 6

三、定义常量和变量

可变变量定义：var 关键字

var <标识符> : <类型> = <初始化值>

不可变变量定义：val 关键字，只能赋值一次的变量(类似Java中final修饰的变量)

val <标识符> : <类型> = <初始化值>

常量与变量都可以没有初始化值,但是在引用前必须初始化
编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。

val a: Int = 1
val b = 1       // 系统自动推断变量类型为Int
val c: Int      // 如果不在声明时初始化则必须提供变量类型
c = 1           // 明确赋值

var x = 5        // 系统自动推断变量类型为Int
x += 1           // 变量可修改

四、NULL检查机制

Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式，字段后加!!像Java一样抛出空异常，另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理。

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

当一个引用可能为 null 值时, 对应的类型声明必须明确地标记为可为 null。
当 str 中的字符串内容不是一个整数时, 返回 null:

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

以下实例演示如何使用一个返回值可为 null 的函数:

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)

    // 直接使用 `x * y` 会导致编译错误，因为他们可能为 null
    if (x != null && y != null) {
        // 在空检测后，x 与 y 会自动转换为非空值（non-nullable）
        println(x * y)
    }
    else {
        println("either '$arg1' or '$arg2' is not a number")
    }    
}

五、类型检测及自动类型转换

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

fun getStringLength(obj: Any): Int? {
 if (obj is String) {
   // 做过类型判断以后，obj会被系统自动转换为String类型
   return obj.length 
 }

 //在这里还有一种方法，与Java中instanceof不同，使用!is
 // if (obj !is String){
 //   // XXX
 // }

 // 这里的obj仍然是Any类型的引用
 return null
}

六、字符串模板

$表示一个变量名或者变量值
$varName 表示变量值
${varName.fun()} 表示变量的方法返回值:

var a = 1
// 模板中的简单名称：
val s1 = "a is $a" 

a = 2
// 模板中的任意表达式：
val s2 = "${s1.replace("is", "was")}, but now is $a"

七、使用for循环

val items = listOf("apple", "banana", "kiwifruit")
for (item in items) {
    println(item)
}
##或者
val items = listOf("apple", "banana", "kiwifruit")
for (index in items.indices) {
    println("item at $index is ${items[index]}")
}

八、使用区间

       //使用 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"+list.lastIndex)
        }
        if (list.size !in list.indices){
            println("list size is out of valid list indices range,too")
        }

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

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

        println()
        //downTo 表示倒序，step表示间隔，不写默认step1
        for (x in 9 downTo 0 step 2){
            println(x)
        }

       // 使用 until 函数排除结束元素
        for (i in 1 until 10) {   // i in [1, 10) 排除了 10
            println(i)
        }

输出结果

2019-06-17 15:20:36.360 15799-15799/? I/System.out: fits in range
2019-06-17 15:20:36.360 15799-15799/? I/System.out: -1 is out of range2
2019-06-17 15:20:36.360 15799-15799/? I/System.out: list size is out of valid list indices range,too
2019-06-17 15:20:36.361 15799-15799/? I/System.out: 1
2019-06-17 15:20:36.361 15799-15799/? I/System.out: 2
2019-06-17 15:20:36.361 15799-15799/? I/System.out: 3
2019-06-17 15:20:36.361 15799-15799/? I/System.out: 4
2019-06-17 15:20:36.361 15799-15799/? I/System.out: 5
2019-06-17 15:20:36.361 15799-15799/? I/System.out: 13579
2019-06-17 15:20:36.361 15799-15799/? I/System.out: 9
2019-06-17 15:20:36.361 15799-15799/? I/System.out: 7
2019-06-17 15:20:36.361 15799-15799/? I/System.out: 5
2019-06-17 15:20:36.361 15799-15799/? I/System.out: 3
2019-06-17 15:20:36.361 15799-15799/? I/System.out: 1