Kotlin学习_基本语法

Kotlin

定义包名(Basic Syntax)

与Java定义包名一样,在源文件的开头定义包名:

1
2
3
4
5
package my.demo
import java.util.*
// ...

包名和文件夹路径可以不一致:源文件可以放在项目的任意位置。

定义函数(Defining functions)

与Java定义函数的区别在于:Kotlin在定义函数的时候要加个fun关键词,函数的返回值前后不同,Java的在前面,如

1
2
3
private int getResult(int a, int b) {
return a + b;
}

而Kotlin的话,要在后面写返回值,如

1
2
3
fun getResult(a: Int, b: Int): Int {
return a + b
}

如果一个函数只有一个并且是表达式函数体并且是返回类型自动推断的话,可以直接这样写

1
2
3
fun getResult(a: Int, b: Int) = a + b
// 这里的函数没有写返回值,以为Kotlin会自动判断返回值类型

如果函数返回一个无意义的值,相当于Java的void,则可以这样写

1
2
3
4
fun getResult(a: Int, b: Int): Unit {
print(a + b)
}

Uint 的返回类型可以省略

1
2
3
4
fun getResult(a: Int, b: Int) {
print(a + b)
}

定义局部变量(Defining local variables)

Kotlin声明变量与Java声明变量有些不一样,Java变量类型在前,变量名在后,而Kotlin则相反,变量名在前,变量类型在后,中间加:(冒号),并且Kotlin可以自动判断变量的类型。

声明局部常量(常量使用val关键字)

1
2
3
4
val a: Int = 1
val b = 1 // 自动判断出Int类型
val c: Int // 当没有初始化值的时候要声明类型,全局变量不能这样写
c = 1 // 赋值

声明变量(变量使用var关键字)

1
2
var x = 5 // 自动推断出Int类型
x += 1

注释(Comments)

Kotlin的注释与Java一样, 支持单行注释和块注释。

1
2
3
4
// 单行注释
/* 这是一个
块注释 */

使用字符串模版(Using string templates)

使用${变量},如变量为args: Array<String>,使用的时候可以这样写

1
2
3
4
5
fun main(args: Array<String>) {
if (args.size == 0) return
print("First argument: ${args[0]}")
}

而不用再去用加号加起来,gradle里面也是支持的

1
2
3
4
5
fun main(args: Array<String>) {
if (args.size == 0) return
print("First argument: " + args[0])
}

使用条件表达式(Using conditional expressions)

使用if表达式的时候这样写

1
2
3
4
5
6
7
fun max(a: Int, b: Int): Int {
if (a > b) {
return a
} else {
return b
}
}

前面说过,如果一个函数只有一个并且是表达式函数体并且是返回类型自动推断的话,可以直接这样写

1
2
fun getResult(a: Int, b: Int) = a + b

那么加上if表达式的话,可以这样写

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

使用可空变量和空置检查(Using nullable values and checking for null)

当一个变量、函数可能出现空值的时候,应该指出该引用可空,如

1
2
3
4
5
fun getResult(a: Int, b: Int): Int? { // 设置函数返回类型可空
print(a + b)
return null
}

使用类型检查和自动转换(Using type checks and automatic casts)

is运算符是检查一个表达式是否是某个类型的实例,如果为不可变局部变量或属性进行类型检查,则无需显式转换

1
2
3
4
5
6
7
8
9
fun getStringLength(obj: Any): Int? {
if (obj is String) {
// `obj`在这个分支中自动转换为`String`类型
return obj.length
}
// `obj`仍然是`Any`类型
return null
}

或者

1
2
3
4
5
6
fun getStringLength(obj: Any): Int? {
if (obj !is String) return null
// `obj`在这个分支中自动转换为`String`类型
return obj.length
}

也可以这样

1
2
3
4
5
6
7
8
fun getStringLength(obj: Any): Int? {
// `obj` 自动转换成`String`类型,并且在&&后面生效
if (obj is String && obj.length > 0) {
return obj.length
}
return null
}

使用for循环(Using a for loop)

与Java相比,Kotlin使用for循环要更加的简洁

1
2
3
4
5
fun main(args: Array<String>) {
for (arg in args) { // in操作符可以判断是否arg是否在args里面
print(arg)
}
}

或者这样写

1
2
3
for (i in args.indices) {
print(args[i])
}

使用while循环(Using a while loop)

while循环与Java一样

1
2
3
4
5
6
fun main(args: Array<String>) {
var i = 0
while (i < args.size) {
print(args[i++])
}
}

使用when表达式(Using when expression)

when表达式就相当于Java的switch表达式,省去了casebreak,并且支持各种类型。

1
2
3
4
5
6
7
8
9
fun cases(obj: Any) {
when (obj) {
1 -> print("One") //如果obj的值为1
"Hello" -> print("Greeting") // 如果obj的值为hello
is Long -> print("Long") // 如果obj的类型是Long类型
!is String -> print("Not a string") // 如果obj的类型不属于String类型
else -> print("Unknown") // 默认,相当于switch的default
}
}

使用ranges(Using ranges)

使用in运算符检查数字是否在范围内

1
2
3
4
5
6
7
8
if (x in 1..y-1) { //1..y-1表示1到y-1的范围
print("OK")
}
for (i in 1..100) { ... } // 1到100范围
for (i in 1 until 100) { ... } // 半开范围,不包括100,相当于[1,100)
for (x in 2..10 step 2) { ... } // 每次夸2,内容为2,4,6,8,10
for (x in 10 downTo 1) { ... } // 返序
if (x in 1..10) { ... }

使用!in运算符检查数值是否在范围外

1
2
3
if (x !in 0..array.lastIndex) {
print("Out")
}

使用集合(Using collections)

循环输出一个集合里面的值或者判断集合里面是否包含某个变量

1
2
3
for (name in names) { // 将会调用nemes.contains(name)方法
println(name)
}

使用lambda表达式过滤和映射集合

1
2
3
4
5
6
// it表示name
names
.filter { it.startsWith("A") }
.sortedBy { it }
.map { it.toUpperCase() }
.forEach { print(it) }

后话

基本语法就学到这里。