Kotlin语法总结

Kotlin语法总结

数据类型

kotlin中只有对象，没有Java中的基本数据类型。kotlin中数据类型和含义和java中的基本相同。

数据类型	含义
Byte	1字节，-128~127
Short	2字节，-32768~32767
Int	4个字节，-2,147,483,648 (-231)~2,147,483,647 (231 - 1)
Long	8个字节， -9,223,372,036,854,775,808 (-263)~9,223,372,036,854,775,807 (263 - 1)
Float	4个字节，浮点类型的数据，默认是Double类型，如果要想为Float类型，使用f或者F指定；如：100.78f
Double	8个字节
char	使用单引号括起来
String	字符串是不可变的
boolean	true或false
Number	其它数值类型的父类

kotlin中声明变量使用var和val关键字。
val:声明不可变的变量，和java中的final类似；
var:声明可变的变量；

kotlin中声明变量时，如果没有显示指定变量的类型，那么在声明时必须给变量赋值；除非在声明时指定了类型，才可以在后面进行赋值。

var a = 100
val b = 100

//var c  错误的声明方式

//正确的声明方式
var c:Int
c = 43

在kotlin中每个语句的结尾不需要添加";"号。

函数

kotlin中的函数使用fun关键字声明。kotlin中定义函数的规则如下：

fun methodName(param1:Int, Param2 : Int): Int {
	return 0
}

:号后面的类型是函数的返回值。param1和param2是参数的名称。这里面有个很重要的语法糖：当函数中只有一行代码时，kotlin允许我们不必编写函数体，可以直接将唯一的一行代码写在函数定义的尾部，中间用等号连接即可。

下面就是一个最简单的函数。

fun getScore() {
}

//省略了函数体
fun printName(name: String) = println(name)

逻辑控制语句

if语句

kotlin中的if语句用法和java中的if语句一样，但是kotlin中的if语句有返回值，返回值是if语句每一个条件中最后一行代码的返回值。
下面这个例子中，如果name变量的值和条件中的相等，那么就会返回对应的条件中的值。

fun main() {
    var name = ""
    val  value = if (name == "Tom") {
        86
    } else if (name == "Jim") {
        77
    } else if (name == "Jack") {
        95
    } else if (name == "Lily") {
        100
    } else {
        0
    }
    println("value:" + value)
}

when语句

kotlin中的when语句和java中的swicth类似，但是比switch更为强大。when语句支持的条件更多，而switch只支持整型或者短于整型的变量和字符串变量作为条件。

when语句允许传入一个任意类型的参数，然后可以在when的结构体中定义一系列的条件，格式如下

匹配值 -> {执行逻辑}

	var name = ""
    var score:Int
    score = when (name) {
        "Tom" -> 86
        "Jim" -> 77
        "Jack" -> 95
        "Lily" -> 100
        else -> 0
    }

如果不在when中传入参数，还可以这样写

fun getScore(name:String) = when {
        //精确匹配
        name.startsWith("Tom") -> 86
        name == "Jim" -> 77
        name == "Jack" -> 95
        name == "Lily" -> 100
        else -> 0
}

循环语句

kotlin中的while循环语句和java中的while循环语句使用方式相同，不同的是for循环语句。

两端闭区间使用…声明；
左闭右开区间使用until关键字声明；
降序区间使用downTo声明；
这里面可以使用step关键字表示步长，也就是类似java中的i++；

下面分别遍历使用这3种不同的区间：

fun main() {
    //..是创建两端闭区间的关键字
    val range = 0..10

    for (i in range) {
        println("i:" + i)
    }

    println("------------------------")

    //使用until创建左闭右开的区间
    val range1 = 0 until 10

    for (i in 0 until 10 step 2) {
        println("i: " + i)
    }

    println("--------------------------")

    //使用downTo可以创建一个降序的区间
    for (i in 10 downTo 1) {
        println("i:" + i)
    }
}

遍历结果如下：

类

kotlin中的类与java中的类的不同之处
kotlin中声明类的方式和Java中的一样，也是使用class关键字。
在kotlin中非抽象类默认都是不可以被继承的，如果想要让一个可以被继承，必须使用open关键字去修饰类。在kotlin中继承一个类使用：。

open class Person {

}


class Student : Person() {

}

与Java一样，在创建子类的时候首先要去调用父类的构造函数，这里面调用父类的构造函数就是通过()来指定的，这里面是调Person父类的无参构造函数，如果加上其它参数，那就是调用Person类的有参构造函数。

Kotlin中的构造函数有主构造函数和次构造函数之分。每个类都有一个默认的不带参数的主构造函数，当然，我们也可以加上参数；主构造函数是没有函数体的，主构造函数是类头的一部分，它跟在类名后。如果我们想要进行类似Java中的初始化操作，可以使用init关键字，在代码块中进行初始化操作。
另外，要注意的是，在主构造函数中声明为var或者val的参数将自动成为类的成员变量，所以

//跟在Person后的()内的就是主构造函数
open class Person() {

   var name = ""
   var age = 0
    
    init {
        //在这里进行初始化操作
    }

    fun eat() {
        println(name + " is eating . He is " + age + " years old.")
    }

}

一个类中只能有一个主构造函数，但是可以有多个次构造函数，次构造函数是有函数体的；次构造函数需要直接或间接调用主构造函数；次构造函数通过constructor关键字来定义。

//后面的name和age，实际上是传给父类的构造函数作为参数的
class Student(var sno: String, var grade : Int, name: String, age: Int) : Person(name,age){

    //通过this关键字调用主构造函数
    constructor(name: String, age: Int): this("", 0, name, age) {

    }

    constructor() : this("", 0) {

    }
    
    init {
        println("sno is " + sno)
        println("grade is " + grade)
    }
    
}

Kotlin和Java一样，类只能单继承，但是可以实现多个接口。kotlin中允许对接口中定义的函数进行默认实现。

集合

list

kotlin中也提供了集合，与java中的集合不一样的是,kotlin中的集合的使用更为方便。

这里使用listOf创建了一个不可变的集合。

    //这里创建的是一个不可变集合
    val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")

    for (fruit in list) {
        println("fruit:" + fruit)
    }

如果想创建一个可变集合，需要像下面这样：

    var list1 = mutableListOf("Apple", "Banana", "Orange", "Pear", "Grape");
    list1.add("Watermelon")

    for (fruit in list1) {
        println("fruiut:" + fruit)
    }

set

   var set1 = setOf("Apple", "Banana", "Orange", "Pear", "Grape");
    for (fruit in set1) {
        println("fruit:" + fruit)
    }

map

这里map添加元素的方式和java中的并不一样

    var map = HashMap<String, Int>()
    map["Apple"] = 1
    map["Banana"] = 2
    map["Orange"] = 3
    map["Pear"] = 4
    map["Grape"] = 5
    
	for (fruit in map) {
        println("fruit:" + fruit)
    }

    var map1 = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3, "Pear" to 4)
    for (fruit in map1) {
        println("fruit:" + fruit)
    }

这里只介绍了kotlin中集合的简单的使用，更多的API可以翻阅文档查看。

Lambda

Lambad在kotlin中的用法非常多，使用lambda可以简化绝大部分的代码。
Lambda表达式的语法如下：

{参数名1：参数类型，参数名2：参数类型2} -> 函数体 }

下面这3行代码，可以将其一步步简化。代码的功能是求出集合中长度最长的那个单词。

    val list = listOf("Apple", "Banana", "orange", "Pear", "Grape", "Watermelon")
    val lambda = {fruit: String -> fruit.length}
    val maxLengthFruit = list.maxBy(lambda)

Kotlin规定，当Lambda参数是函数的最后一个参数时，可以将Lambda表达式移到函数括号的外面；

val maxLengthFruit = list.maxBy({fruit:String -> fruit.length})

如果Lambda参数是函数的唯一一个参数的话，还可以将函数的括号省略；

val maxLengthFruit = list.maxBy { fruit:String -> fruit.length }

当Lambda表达式的参数列表中只有一个参数时，也不必声明参数名，而是可以使用it关键字来代替；

val maxLengthFruit = list.maxBy {fruit:String -> fruit.length}

参考

1. 第一行代码
2. Kotlin语言中文站