Kotlin学习笔记之基本语法

学习kotlin准备工作:

  • 安装Android Studio3.0 开发工具(支持kotlin)
  • 了解kotlin:
    • 兼容性:与jdk6完全兼容,可保证能在较旧Android设备上运行
    • 性能:运行速度与java相当。支持内联函数,使用lambdas的代码通常比使用java编写的相同代码运行更快。
    • 互操作性:与java100%支持互操作,可直接使用现有Android库,包括注释处理
    • APK中占比:Kotlin运行时只添加了几百种方法,并且小于100K到.apk文件的大小
    • 编译时间:支持高效的增量编译,通常比java一样或更快。
  • 多查阅学习资料:

创建Kotlin项目

  • 使用最新Android Studio新建项目,在Create Android Project 步骤记住勾选(Include Kotlin support)

定义包名及导包

  • 语法基本和java类似,唯一区别,无需分号结束
  • 不需要匹配目录和包:源文件可以任意放在文件系统中。
1
2
3
4
package top.goluck.kotlin2017_7_16

import android.support.v7.app.AppCompatActivity
//...

注释

  • 与java无区别
    1
    2
    3
    4
    // 这是单行注释

    /* 这是多行
    注释 */

定义变量

  • var 可变变量
  • val 不可变变量
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    //可变变量
    var x:Int = 5
    x+=1

    //也可不指定类型,定义时系统根据赋值自动推断
    var x= 5//推断为Int类型
    x+=1

    //定义val 分配一次(只读)变量
    ~~~kotlin
    val a:Int = 1 // 立刻赋值
    val b = 2 // 不指定类型,由系统推断int类型
    val c: Int // 当没有提供初始化值,需要指定类型
    // 延期赋值
    c = 3
    int{
    c =3
    }

    //定义静态变量
    companion object {
    var d = 1
    val e = 1
    }

定义函数

  • 使用关键字 fun
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//以下函数代表a和b求和
fun sum(a: Int, b: Int): Int {
return a + b
}

//静态方法的a和b求和
companion object {
fun sum(a: Int, b: Int): Int {
return a + b
}
}
//使用等号推断函数返回类型
fun sum(a: Int, b: Int) = a + b
//函数无返回类型
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}")
}

在String中使用$符合

1
2
3
4
5
6
7
var a = 1
//直接使用变量a 即:$a
val s1 = "a is $a" //输出:s1 = "a is 1"

a = 2
// 使用任意表达式
val s2 = "${s1.replace("is", "was")}, but now is $a"//输出:s2 = "a was 1,but now is 1"

注意:$后面可以跟 变量名(或表达式)

使用条件表达式

  • if else 和 java基本一致
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    //简单if else
    fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
    return a
    } else {
    return b
    }
    }
    //上面也可简写为
    fun maxOf(a: Int, b: Int) = if (a > b) a else b

使用?表示可为null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//如String转换为Int
fun parseInt(str: String): Int? {
return str.toIntOrNull()
}
//使用的时候就需要判断是否为null
fun sum(a: String,b:String):Int{
var num1 = parseInt(a)
var num2 = parseInt(b)
if(num1!=null && num2!=null){
return num1 + num2;
}else{
return 0;
}
}

类型检查和自动转换

  • is 类型 (判断是否为某某类型)
  • Any 为 kotlin中所有类的超类 即:等同于java中的Object
  • as 将类型强制转换
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    //使用is判断类型
    fun getStringLength(obj: Any): Int? {
    if (obj is String) {
    // 注意:`obj` 在此已自动转换为String类型
    return obj.length
    }

    // 注意:`obj`在if外依旧是Any类型
    return null
    }

    //亦可使用 !is 判断不是某某类型
    fun getStringLength(obj: Any): Int? {
    if (obj !is String) return null
    // 注意:`obj` 在此自动转换为String类型
    return obj.length
    }
    //甚至
    fun getStringLength(obj: Any): Int? {
    // `obj` 在`&&` 被自动转换为String
    if (obj is String && obj.length > 0) {
    return obj.length
    }
    return null
    }
    //已知类型情况下,还可以使用as进行强制转换
    fun parseInt(){
    var a = "123133"
    var b:Int = a as Int
    }

循环语句

  • for 、while 基本类似java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    //for
    //打印集合数据
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
    println(item)
    }
    //或
    val items = listOf("apple", "banana", "kiwi")
    for (index in items.indices) {
    println("item 下标为 $index 值为 ${items[index]}")
    }

    //while
    val items = listOf("apple", "banana", "kiwi")
    var index = 0
    while (index < items.size) {
    println("item 下标为 $index 值为 ${items[index]}")
    index++
    }

when表达式

  • 类似java switch,但比它更强大
    1
    2
    3
    4
    5
    6
    7
    8
    9
    //看到强大在何处了么?
    fun describe(obj: Any): String =
    when (obj) {
    1 -> "One"
    "Hello" -> "Greeting"
    is Long -> "Long"
    !is String -> "Not a string"
    else -> "Unknown"
    }

in 关键字使用

  • in 特别用于判断数值是否属于某某范围区间
  • 同样 in 关键字前也可加!代表非
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    // 判断x 是否属于 1到(y+1)
    val x = 10
    val y = 9
    if (x in 1..y+1) {//该语句最终会打印下面输出
    println("满足在该范围内")
    }
    //!in 使用
    val list = listOf("a", "b", "c")

    if (-1 !in 0..list.lastIndex) {
    println("-1 超出范围")
    }
    if (list.size !in list.indices) {
    println("list.size 超出list的索引范围")
    }
    //正常纯数字范围写法
    for (x in 1..5) {
    print(x)
    }
    // step 代表间隔跳过
    for (x in 1..10 step 2) {//满足条件的值 1、3、5、7、9
    print(x)
    }
    // downTo 代表降序 以下表示 x 满足 9到0区间间隔跳过3个数的值
    for (x in 9 downTo 0 step 3) {//满足的值有 9、6、3、0
    print(x)
    }

集合操作

  • 以下示例包含:打印、判断、过滤、排序、转换、循环遍历
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    for (item in items) {
    println(item)
    }

    when {
    "orange" in items -> println("juicy")
    "apple" in items -> println("apple is fine too")
    }

    fruits
    .filter { it.startsWith("a") }
    .sortedBy { it }
    .map { it.toUpperCase() }
    .forEach { println(it) }