Skip to content

概念介绍

本文介绍Kotlin中的一些概念。例如包,程序入口,变量,输出,方法(函数)等等。

有些地方会和Java进行对比。方便理解。

包的定义和使用

包的定义应该写在文件的顶部。

package com.rustfisher.ktpractice.intro

import kotlin.text.*

// ...
Kotlin并不要求包名和文件存放位置严格对应。

程序入口

Kotlin应用的程序入口是main方法。

fun main() {
    // ..
}

另一个main方法带有参数。

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

标准输出

print方法将传入的变量打印到标准输入流。

print("Rust ")
print("Fisher")

println打印传入变量并且在最后添加一个换行。

println("an.rustfisher.com")
println(42)

方法

下面是一个接受2个Int参数,返回Int的方法。

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

方法主体可以是一个表达式。它的返回值可以被推断出来。

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

方法可以没有返回值,或者说是返回一个无意义的值(Unit)。

fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
}

Unit可以忽略不写。

fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
}

变量

只能读的变量需要用关键字val。它们只能被赋值1次。

val a: Int = 1 // 直接赋值
val b = 2      // 自动推测出是Int类型
val c: Int     // 当没有赋初始值时,需要声明类型Type required when no initializer is provided
c = 3          // 这里是推迟赋值

可以多次赋值的变量用关键字var

var x = 5 // 自动推测出是Int型
x += 1

可以在顶部声明变量

val PI = 3.14
var x = 0

fun incrementX() { 
    x += 1
}

创建类与实例

定义一个类,使用class关键字

class Fisher

类的属性可以放在定义中或者类里。比如下面这个类Rectangle,描述长方形。

class Rectangle(var height: Double, var length: Double) {
    var perimeter = (height + length) * 2
}

默认构造器中的变量可以直接使用。这里可以直接使用面积变量perimeter

val rectangle = Rectangle(5.0, 2.0)
println("The perimeter is ${rectangle.perimeter}")

对于kotlin v.1.4.30,类的继承用冒号:来表示。类默认都是final的,不可继承。为了继承,用open让这个类能被继承。

open class Shape
class Rectangle(var height: Double, var length: Double): Shape {
    var perimeter = (height + length) * 2
}

注释

和其他现代编程语言类似,用//或者/**/来注释

// 这里是注释 RustFisher
/**
 * 这是注释
 */
/* 这也是注释 */

字符串模版(String tempplates)

直接使用变量,用$

要使用表达式,需要用大括号${}

var a = 1
// 简单使用$
val s1 = "a is $a" 

a = 2
// 使用方法
val s2 = "${s1.replace("is", "was")}, but now is $a"

条件表达式

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

Kotlin中,if也可以写成一个表达式

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

for循环

使用in

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

使用下标

val items = listOf("apple", "banana", "kiwifruit")
for (index in items.indices) {
    println("item at $index is ${items[index]}")
}

for (i in 1..3) {
    println(i)
}
for (i in 6 downTo 0 step 2) {
    println(i)
}

while循环

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

when表达式

when看起来有点像Java里的witch,但这两个是不同的东西。

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

范围

检查一个数字是否在范围中,使用in操作

val x = 10
val y = 9
if (x in 1..y+1) {
    println("在范围内")
}

检查一个数是否超出了范围

val list = listOf("a", "b", "c")

if (-1 !in 0..list.lastIndex) {
    println("-1 超出了范围")
}
if (list.size !in list.indices) {
    println("list的size也超出了下标范围")
}

遍历一个范围

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

指定步进值

for (x in 1..10 step 2) {
    print(x)
}
println()
for (x in 9 downTo 0 step 3) {
    print(x)
}

集合

遍历一个集合

for (item in items) {
    println(item)
}

检查集合中是否包含某个对象,用in操作

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

用lambda表达式对集合进行filter和map操作

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

可为null的值和null检查

可以为null的变量,后面需要一个问号?

下面这个方法返回Int或者null

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

使用可能返回null的方法(上面那个方法)

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)

    // Using `x * y` yields error because they may hold nulls.
    if (x != null && y != null) {
        // x 和 y 经过null检测后自动变成了非null值
        println(x * y)
    }
    else {
        println("'$arg1' or '$arg2' 不是数字")
    }    
}

或者写做

// ...
if (x == null) {
    println("参数错误 arg1: '$arg1'")
    return
}
if (y == null) {
    println("参数错误 arg2: '$arg2'")
    return
}

// x 和 y 经过null检测后自动变成了非null值
println(x * y)

类型检查和自动转换

is来检查某个对象是不是某个类型。 如果确定某个不可变的变量的类型,那后面使用它的时候不用再显式转换

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // obj已经自动转换为String类型
        return obj.length
    }

    // 这里的obj仍然是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
}

作者: RustFisher
联系: rf.cs@foxmail.com
博客: rustfisher.com | RustFisher cnblog
示例: AndroidTutorial Gitee, Tutorial Github
链接: https://www.an.rustfisher.com/kotlin/basic/basic-syntax/
一家之言,仅当抛砖引玉。如有错漏,还请指出。