Kotlin学习（2）：基本语法

• 开发环境：IntelliJ IEDA
• 个人博客：http://blog.youkuaiyun.com/IInmy
• 项目源码：https://github.com/Rushro2m/KotlinForOfficial
• 官方文档中文版：https://www.kotlincn.net/docs/reference/basic-syntax.html

1、包

（1）定义包

包的声明应处于源文件顶部，源文件通常以包声明开头：

package basic_grammar

fun baz(){}
class Goo()

目录与包的结构无需匹配：源代码可以在系统的任意位置。源文件所有内容（无论是类还是函数）都包含在声明的包内。所以上例中baz()的全名是basic_grammar.baz、Goo的全名是basic_grammar.Goo。

如果没有指明包，该文件的内容属于无名字的默认包。

（2）默认导入

有多个包会默认导入到每个Kotlin文件中：

• kotlin.*
• kotlin.annotation.*
• kotlin.collections.*
• kotlin.comparisons.* （自 1.1 起）
• kotlin.io.*
• kotlin.ranges.*
• kotlin.sequences.*
• kotlin.text.*

根据目标平台还会导入额外的包：

• JVM

  • java.lang.*
  • kotlin.jvm.*

• JS

  • kotlin.js.*

（3）其他导入

除了默认导入之外，每个文件可以包含它自己的导入指令。
可以导入一个单独的名字，如：

import  foo.Bar //  现在  Bar 可以不用限定符访问

可以导入一个作用域下所有内容（包、类、对象等）：

improt foo.*//“foo”中的一切都可访问

如果出现名字冲出，可以使用as关键字在本地重命名冲突项来消歧义：

import  foo.Bar //  Bar 可访问 import  
bar.Bar as  bBar    //  bBar代表“bar.Bar”

2、定义函数

（1）函数有返回值

带有两个Int参数、返回Int的函数：

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

将表达式作为函数体、返回值类型自动推断的函数：

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

（2）函数返回无意义的值，即无返回值

//函数返回无意义的值，即无返回值的函数
fun printSum(a: Int, b: Int): Unit {
    print("sum of $a and $b is ${a + b}")
}

当然，Unit也可以省略

fun printSum(a: Int, b: Int) {
    print("$a add $b is ${a + b}")
}

3、定义变量

（1）局部变量

一次赋值的局部变量，也就是常量

val a: Int = 1//立即赋值
val b = 2//自动推断其类型
val c: Int//如果没有初始值类型不能省略
c = 3//明确赋值
print("a=$a,b=$b,c=$c")

（2）可变变量

可变变量，可以多次赋值，也就是变量

var x = 5
x += 1
print("x = $x")

（3）顶层变量

顶层变量，即将变量声明在最外层，也就是全局变量

val PI = 3.1415926
var z = 0
fun incrementX() {
    z += 1
}

fun main(args: Array<String>) {
    println("z = $z;PI = $PI")
    incrementX()
    println("incrementX()")
    println("z =$z,PI = $PI")
}

4、注释

（1）行注释

行注释通过“//”

（2）块注释

块注释通过“/* */”

5、字符串模板

使用字符串模版可以将变量插入到字符串中

fun main(args: Array<String>) {
    var a = 1
    //模板中的简单名称：
    val s1 = "a is $a"
    a = 2
    //模板中的任意表达式
    val s2 = "${s1.replace("is", "was")},but now is $a"
    print(s2)
}

6、条件表达式

使用条件表达式进行判断比较，返回两个数中较大的数

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

或者也可以这样写

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

7、空值及null检测

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

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

fun printProduct(x: String, y: String) {
    val a = parseInt(x)
    val b = parseInt(y)

    if (a != null && b != null) {
        println(a * b)
    }else{
        println("either '$x' or '$y' is not a number")
    }
}

fun main(args: Array<String>) {
    printProduct("6","7")
    printProduct("a",   "7")                
    printProduct("a",   "b")
}

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

fun getStringLength(obj: Any): Int? {
    return if (obj is String) {
        //obj在该分支自动转换为String
        obj.length
    } else {
        //离开类型检测分支后，obj仍然是Any类型
        null
    }
}

fun main(args: Array<String>) {
    fun printLength(obj: Any) {
        println("'$obj'	string length is ${getStringLength(obj) ?: "...err,not a string"}")
    }
    printLength("Incomprehensibilities")
    printLength(1000)
    printLength(listOf(Any()))
}

9、for循环

直接获取数组中的每一个值

val items = listOf("apple", "banana", "kiwi")
for (item in items) {
    println(item)
}

或者通过数组的下标获取每一个值

for (index in items.indices) {
    println("item at $index is ${items[index]}")
}

10、while循环

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

11、when表达式

根据不同的值返回不同的结果

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

12、区间（range）

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

（1）区间判断

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("lastIndex is ${list.lastIndex}")
    println("list size is out of valid list indices range too")
}

（2）区间迭代

if (x in 1..5) {
    print(x)
}

（3）数列迭代

for (x in 1..10 step 2) {
    print(x)
}

for (x in 9 downTo 0 step 3) {
    print(x)
}

13、集合

（1）遍历结合

val items = listOf("apple", "banana", "kiwi")
    //遍历集合
    for (item in items) {
        println(item)
    }

（2）判断集合中是否包含某实例

val items = listOf("apple", "banana", "kiwi")
when {
       "orange" in items -> println("orange")
       "apple" in items -> println("apple is fine too")
   }

（3）Lambda表达式对集合进行处理

//使用Lambda表达式来过滤（filter）和映射（map）集合：
val fruits = listOf("banana", "avocado", "apple", "kiwi")
fruits
            //过滤
            .filter { it.startsWith("a") }
            //排序
            .sortedBy { it }
            //字母转换为大写
            .map { it.toUpperCase() }
            //打印
            .forEach { println(it) }