Kotlin 的基础语法

从这一篇文章开始正式进入 Kotlin 的语法介绍，旨在从整体上体会一下 Kotlin 的代码风格和基本的编程规范，其中会将 Kotlin 语法与 Java 语法做一个简单的对比，从而更快更好地了解 Kotlin。

1. 包的声明和导入

在 Kotlin 中定义包与 Java 有点不同，在 Kotlin 中目录与包结构无需匹配，Kotlin 的源码可以在磁盘上的任意位置。与 Java 不一样的是 Kotlin 的文件是以 .kt 为后缀，而 Java 的文件是以 .java 为后缀。

1.1 包的声明

源文件的通常是以包的声明的开头和 Java 一样，都是使用 package 关键字。

package com.imooc.hello.kotlin //package 关键字声明包

fun main(args: Array<String>) {
    println("Hello Kotlin")
}

1.2 包的导入

包的默认导入

在 Kotlin 中一些内置库的包是默认导入（或称隐式导入）的，比如以下这些库的包都是 Kotlin 默认导入:

kotlin.*
kotlin.annotation.*
kotlin.collections.*
kotlin.comparisons.*
kotlin.io.*
kotlin.ranges.*
kotlin.sequences.*
kotlin.text.*

举个例子说明下，比如在 Kotlin 中使用集合List或者MutableList时，并不需要显式的import kotlin.collections.* 声明，就能使用相关集合的 API。

package com.imooc.hello.kotlin 

fun main(args: Array<String>) {
    val languages: List<String> = listOf("Kotlin"， "Java"， "Dart")//声明了List，但是不需要显示导入kotlin.collections.*
    languages.forEach { language ->
       println(language)       
    }
}

包的显示导入

在 Kotlin 中的包显示导入是使用 import 关键字，这一点和 Java 是一样的。以 Android 中的MainActivity举例

  package com.imooc.hello.kotlin

  import android.os.Bundle // import关键字显示导入包和java是一样的
  import androidx.appcompat.app.AppCompatActivity
  import kotlinx.android.synthetic.main.activity_main.*

  class MainActivity : AppCompatActivity() {

      override fun onCreate(savedInstanceState: Bundle?) {
          super.onCreate(savedInstanceState)
          setContentView(R.layout.activity_main)
          tv_hello.text = "Hello Kotlin!"
      }
  }

2. 函数

2.1 函数的定义

函数的定义使用关键字fun，函数参数格式为: “参数:类型”，函数返回值类型 fun(...): Int。这种声明函数参数、函数返回值类型方式正好与 Java 是相反的。

//Kotlin定义
fun sum(a: Int, b: Int, c: Int): Int {
    return a + b + c
}

//Java定义
public int sum(int a, int b, int c) {
    return a + b + c;
}

2.2 函数类型推导

表达式作为函数体，返回值的类型可以省略，可以利用 Kotlin 的类型推导功能，推测出函数返回值的类型。

fun sum(a: Int, b: Int, c: Int): Int {
    return a + b + c
}

//可简写成以下形式
fun sum(a: Int, b: Int, c: Int) = a + b + c

2.3 无返回值的函数

在 Java 中定义无返回值类型的函数一般是使用void， 在 Kotlin 中则使用Unit， 或者省略Unit类型。

//Kotlin定义
fun output(userName: String): Unit {
    println("current user name is $userName")
}
//可简写成以下形式
fun output(userName: String) {
    println("current user name is $userName")
}

//Java定义
public void output(String userName) {//注意在Java中 void不能省略
    System.out.println("current user name is " + userName);
}

2.4 可变长参数函数

在 Kotlin 中可变长参数函数可以使用vararg关键字标识，这一点和Java中的可变长参数声明不一样。

//Kotlin定义
fun setDatas(vararg datas: Any) {
    for (dataItem in datas) {
        print(dataItem)
    }
}

//Java定义
public void setDatas(Object... datas) {
    for (dataItem in datas) {
        System.out.println(dataItem.toString());
    }
}

2.5 lambda(匿名函数)

val sumLambda: (Int, Int, Int) -> Int = { a, b, c -> a + b + c }

//调用
println("sum = ${sumLambda(1, 6, 7)}")

3. 常量和变量

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

3.1 可变变量的定义

可变变量的定义：var 关键字：

var <变量名>:<变量类型> = <初始值>

var sum: Int = 3
sum = 8

//由于编译支持类型推导可以省略Int类型
var sum = 3
sum = 8

3.2 只读变量的定义

只读变量的定义: val 关键字， 不能进行二次赋值，类似 Java 中的 final 类型

val <常量名>:<常量类型> = <初始值>

val sum: Int //没有赋值初始化之前必须指定类型
sum = 5

4. 字符串模板

模板中的简单的单值：

fun main(args: Array<String>) {
    var a = 1
    var s1 = "a is $a"
}

模板中的任意表达式的值：

fun main(args: Array<String>) {
    var a = 1
    a = 2
    val s2 = "${s1.replace("is"， "was")}， but now is $a"
}

5. 注释

Kotlin 支持单行和多行注释，和java中类似。

fun main(args: Array<String>) {
//    println("Hello Kotlin!") 单行注释
}

fun main(args: Array<String>) {
//多行注释 /* ... */
    /*println("Hello Kotlin!")
    println("Hello Kotlin!")
    println("Hello Kotlin!")*/
    println("Hello Kotlin!")
}

6. 条件表达式

Kotlin 使用 if-else 表达式替代了 Java 中的三目运算符， 因为在 Kotlin 中 if-else 表达式是带有返回值的。

fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

fun main(args: Array<String>) {
    println(maxOf(1, 5))
}

在 Kotlin 中 if 表达式是带有返回值的，所以可以简化成下面的形式：

fun maxOf(a: Int, b: Int) = if (a > b) a else b

fun main(args: Array<String>) {
    println(maxOf(1, 5))
}

7. 空安全

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 main(args: Array<String>) {
    if (args.size < 2) {
        println("Two Integers Expected")
        return
    }
    val x = parseInt(args[0])
    val y = parseInt(args[1])

    //println(x + y) 由于标识了可能为null,直接使用x + y在编译器看来是非法，需要去做非空判断
    if (x != null && y != null) {
        println(x + y)
    }
}

fun parseInt(s: String): Int? {//表示当前函数返回值可能为null,就必须在类型后面标识"?"
    return s.toInt()
}

8. 类型智能推导和自动类型转换

在 Kotlin 中可以使用 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
}

或者是这样的：

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
}

9. 区间 Range

在 Kotlin 中使用in运算符来检测某个数字是否在指定的区间内，区间表达式具有操作符形式"…"的rangeTo函数辅助in和!in组合而成。区间可以支持任何可以比较的类型，对于原生的整型，内部有一个优化的实现。

比如以下几种使用场景:

1. 检测某个数字是否在指定区间内：

val x = 10
val y = 9
if (x in 1..y + 1) {//表示x是否在1~y+1范围内。
    println("fits in range")
}

2. 检测某个数字是否在指定区间外：

val list = listOf("a"， "b"， "c")
if (-1 !in 0..list.lastIndex) {
    println("-1 is out of range")
}

if (list.size !in list.indices) {
    println("list size is out of valid list indices range too")
}

3. 区间迭代：

for(x in 1..10){//相当于 x >= 1 && x <= 10
    println(x)
}

//或者
fun printList(num: Int) {
    for (i in 1..num) {//相当于 i >= 1 && i <= num
        print(i)
    }
}

//或者使用until 函数排除结束元素
for (i in 1 until 10) {// i in [1, 10) 排除了 10,相当于 i >= 1 && i < 10
    println(i)
} 

4. 数列迭代 ：

for(x in 1..100 step 2){//递增数列迭代，每次间隔步长是2；1，3，5，7...
    println(x)
}

for(x in 9 downTo 0 step 3){//递减数列迭代，每次间隔步长是3；9，6，3，0
    println(x)
}  

10. 集合的使用

1. 对集合进行迭代：

fun main(args: Array<String>) {
    val items = list.of("java"， "kotlin"， "python")
    for (item in items) {
        println(item)
    }
}

2. 使用 in 运算符判断集合内是否包含某个实例：

when {
    "java" in items -> println("is good lang")
    "kotlin" in items -> println("is good good lang")
    else -> println("python is best lang")
}

3. 使用 lambda 表达式来过滤(filter)和映射(map)集合：

fun main(args: Array<String>) {
    val langs = listOf("C"， "C++"， "Java"， "Python"， "JavaScript")

    langs.filter { it.startsWith("C") }
            .sortedBy { it }
            .map { it.toUpperCase() }
            .forEach { println(it) }
}

11. 循环的使用

在 Kotlin 中的循环有两种方式分别是for，while，在for循环中使用"in"来遍历，并且有两个遍历方式。

1. for 循环：

val items = listOf("java"， "kotlin"， "android")
for (item in items) {//for遍历集合
    println("lang $item")
}

for (index in items.indices) {//类似于java中的数组的length-index的遍历
    println("The $index index is ${items[index]}")
}

2. while 循环：

val items = listOf("java"， "kotlin"， "android")
var index = 0
while (index < items.size) {//while 循环的遍历方式
    println("The $index lang is ${items[index++]}")
}

12. 条件if,when的使用

在 kotlin 中 if 的使用于 Java 相似但是在 kotin 中 if 是表达式有值的，而在 java 中是语句，可以使用kotlin 中的 if 表达式替代 Java 中的三目运算符在 kotlin 中的。when 与 switch 功能类似：

fun main(args: Array<String>) {
    println(descript("hello"))
}

fun descript(obj: Any): String = when (obj) {
    1 -> "one"
    "hello" -> "hello word"
    is Long -> "long type"
    !is String -> "is not String"
    else -> {
        "unknown type"
    }
}

13. 类和对象

类和对象的形式这里先简单了解，后续我们会有专门的章节进行讲解：

fun main(args: Array<String>) {
    val rectangle = Rectangle(100.0, 200.0)
    val triangle = Triangle(100.0, 100.0, 100.0)
    println("rectangle is ${rectangle.isSquare}， and perimeter is ${rectangle.perimeter}， and area is ${rectangle.calculateArea()}")
    println("triangle  perimeter is ${triangle.perimeter}， and area is ${triangle.calculateArea()}")
}

abstract class Shape(val sides: List<Double>) {
    val perimeter: Double get() = sides.sum()
    abstract fun calculateArea(): Double
}

interface RectangleProperity {
    val isSquare: Boolean
}

class Rectangle(var height: Double, var length: Double)
    : Shape(listOf(height, length, height, length))， RectangleProperity {
    override fun calculateArea(): Double = height * length
    override val isSquare: Boolean get() = height == length
}

class Triangle(var sideA: Double, var sideB: Double, var sideC: Double)
    : Shape(listOf(sideA, sideB, sideC)) {
    override fun calculateArea(): Double = sideA * sideB * sideC
}

14. 小结

到这里有关初探 Kotlin 语法就结束，这一篇仅仅为了整体上去体验下 Kotlin 编程风格和代码规范，下面将会深入每个语法细节进行深入展开。