包的定义和导入

在源文件的最上方定义包。包和目录的对应不是必须的。但是开发中还是写成对应的好，即包名和目录一样。

package com.mingyu.demo
import kotlin.text.*

程序入口

Kotlin程序的入口是main函数。

fun main() {
    println("你好，Kotlin！")
}

可以接收多个字符串参数的main函数。

fun main(args: Array<String>) {
    println(args.contentToString())
}

打印到标准输入设备（如输入到控制台）

fun main() {
    print("这就是打印文字")
}

打印后换行。

fun main() {
    print("第一行文字")
    print("第二行文字")
}

函数

定义规则：fun 函数名(参数):返回类型{函数内的处理代码}

有两个整型参数的，并返回整型的函数。

fun reduce(a: Int, b: Int): Int {
    return a - b
}
fun main() {
    print("10-5=")
    print(reduce(10, 5))
}

函数体可以是一个表达式，返回类型可以自动推断。

fun reduce(a: Int, b: Int) = a - b
fun main() {
    print("20-5=${reduce(20, 5)}")
}

不需要返回任何值时使用Unit。

fun reduce(a: Int, b: Int): Unit {
    print("${a}-${b}=${a - b}")
}
fun main() {
    reduce(30, 23)
}

Unit可以省略不用。

fun reduce(a: Int, b: Int) {
    print("${a}-${b}=${a - b}")
}

变量

只读变量使用关键字val定义，只能赋值一次。

fun main() {
    val a: Int = 1 // 整型变量，立即赋值
    val b = 2 // 类型自动推导的整型变量
    val c: Int // 不需要初始化时可以先定义
    c = 3   // 然后再赋值
    println("a = $a, b = $b, c = $c")
}

用var来定义可以修改值的变量。

fun main() {
    var a = 0
    a = 1
    print("a=$a")
}

变量可以定义在最顶层（全局的）。

val a = 110
var b = 12
fun main() {
    println("a=$a,b=$b")
    b += 1
    println("a=$a,b=$b")
}

创建类和实例

使用class关键字定义类

class A

属性的定义

class A(var a: Int, var b: Int) {
    var c: Int = a * b
    //a,b,c都是A类的属性
}

创建实例

fun main() {
    val a = A(10, 20)
    println("a=${a.a},b=${a.b},c=${a.c}")
}

被open标记的类才能被继承

open class A(var a: Int, var b: Int) {
    var c: Int = a * b
}
class B : A(0, 0) {
    val d: Int = 2
}
fun main() {
    val a = A(10, 20)
    val b = B()
    b.a = 12
    b.b = 13
    println("a.a=${a.a},a.b=${a.b},a.c=${a.c}")
    println("b.a=${b.a},b.b=${b.b},b.c=${b.c},b.d=${b.d}")
}

注释

单行注释

//这是单行注释

多行注释

/*这个可以是多行的注释
这个可以是多行的注释
*/

字符串模板

前面的例子中已经多次使用了。在字符串中使用$加变量的方式，可以将变量的值加入到字符串中。如果是复杂的表达式等内容，需要增加{}

fun main() {
    val a = 123
    val b = "a=$a,a+1=${a + 1}"
    println(b)
}

for循环

fun main() {
    val a = arrayOf("a", "b", "c", "d")
    for (item in a) {
        println(item)
    }
}

带元素位置的循环

fun main() {
    val a = arrayOf("a", "b", "c", "d")
    for (index in a.indices) {
        println("第${index}位置的元素值为${a[index]}")
    }
}

while循环

fun main() {
    val a = arrayOf("a", "b", "c", "d")
    var index = 0
    while (index<a.size){
        println("第${index}位置的元素值为${a[index]}")
        index++
    }
}

用when表达式进行分支控制

fun mySwitch(obj: Any): String = when (obj) {
    1 -> "数字1"
    "123" -> "字符串123"
    is Long -> "这是一个长整型"
    else -> "其它情况"
}

fun main() {
    println(mySwitch(1))
    println(mySwitch("123"))
    println(mySwitch(1234L))
    println(mySwitch("这是个啥？"))
}

Ranges范围

检查某数字是否在某范围内

fun main() {
    val a = 1
    val b = 9
    if (a in 1..b) {
        println("a在1到${b}的范围内")
    }
}

检查某数字是否不在某范围内

fun main() {
    val a = 11
    val b = 9
    if (a !in 1..b) {
        println("a不在1到${b}的范围内")
    }
}

在某个范围内循环

fun main() {
    for (i in 1..5){
        print(i)
    }
}

步进式循环

fun main() {
    for (i in 1..10 step 2) {
        println(i)
    }
}

倒序循环

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

集合

循环集合

fun main() {
    val items = listOf("第一个", "第二个", "第三个")
    for (item in items) {
        println(item)
    }
}

检查某对象是否在集合中

fun main() {
    val items = setOf("第一个", "第二个", "第三个")
    when {
        "第四个" in items -> println("第四个")
        "第二个" in items -> println("第二个")
    }
}

使用lambda表达式操作集合

fun main() {
    val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
    fruits
        .filter { it.startsWith("a") }
        .sortedBy { it }
        .map { it.uppercase() }
        .forEach { println(it) }
}

可空的值和空检查

在类型后面加问号（?）即表明它可以是空的null

var a:Int?=null

使用可以返回值为空的函数

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}
fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)
    if (x != null && y != null) {
        println(x * y)
    }
    else {
        println("'$arg1' 或 '$arg2' 不是数字")
    }
}
fun main() {
    printProduct("6", "7")
    printProduct("a", "7")
    printProduct("a", "b")
}

类型检查和自动转换

使用is操作符来检查类型。判断为真时，类型会自动转换。

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        //自动将转为String
        return obj.length
    }
    //此处obj仍然是Any类型的
    return null
}
fun main() {
    fun printLength(obj: Any) {
        println("获取${obj}的长度。 ${getStringLength(obj) ?: "不是一个字符串"} ")
    }
    printLength("这是一个字符串")
    printLength(110)
    printLength(listOf(Any()))
}