Kotlin 基础语法
本章将介绍 Kotlin 的基础语法，包括变量、数据类型、运算符和函数等核心概念。
程序入口
Kotlin 程序的入口是 main 函数：
fun main() {
println("Hello, Kotlin!")
}
main 函数的几种形式
// 无参形式（最常用）
fun main() {
println("Hello!")
}
// 接受命令行参数
fun main(args: Array<String>) {
println("Hello, ${args[0]}!")
}
// 简化形式（单表达式函数）
fun main() = println("Hello!")
变量声明
Kotlin 使用 val 和 var 声明变量：
val - 只读变量
fun main() {
// 声明不可变变量（类似 Java final）
val name: String = "Kotlin"
val age = 10 // 类型自动推断
// val 变量不能重新赋值
// name = "Java" // 编译错误！
println("Name: $name, Age: $age")
}
var - 可变变量
fun main() {
// 声明可变变量
var count = 0
println(count) // 0
count = 5
println(count) // 5
// 可以修改变量值，但不能改变类型
// count = "five" // 编译错误！
}
val vs var 对比
| 特性 | val | var |
|---|---|---|
| 可重新赋值 | ❌ | ✅ |
| 类型推断 | ✅ | ✅ |
| 可空类型 | ✅ | ✅ |
| 推荐使用 | ✅（优先） | 仅在必要时 |
最佳实践：优先使用 val，只有确实需要修改变量时才使用 var。
基本数据类型
Kotlin 的基本数据类型包括：
整数类型
fun main() {
// 有符号整数
val byte: Byte = 127 // 8位: -128 ~ 127
val short: Short = 32767 // 16位: -32768 ~ 32767
val int: Int = 2147483647 // 32位（默认）
val long: Long = 9223372036854775807 // 64位
// 无符号整数（Kotlin 1.3+）
val uByte: UByte = 255u // 0 ~ 255
val uShort: UShort = 65535u // 0 ~ 65535
val uInt: UInt = 4294967295u // 0 ~ 4294967295
val uLong: ULong = 18446744073709551615u // 最大值
// 数字字面量
val decimal = 100 // 十进制
val hex = 0xFF // 十六进制
val binary = 0b1010 // 二进制
val longNum = 100_000_000 // 下划线分隔（提高可读性）
println("Byte: $byte, Int: $int, Long: $long")
}
浮点类型
fun main() {
// 浮点数
val float: Float = 3.14f // 32位，需要 f 或 F 后缀
val double: Double = 3.14 // 64位（默认）
// 科学计数法
val scientific = 1.5e10
// 特殊值
val infinity = Double.POSITIVE_INFINITY
val negativeInfinity = Double.NEGATIVE_INFINITY
val notANumber = Double.NaN
println("Float: $float, Double: $double")
}
字符类型
fun main() {
val char: Char = 'A'
val chinese: Char = '中'
val unicode: Char = '\u0041' // Unicode
// 字符可以是转义序列
val newline = '\n'
val tab = '\t'
println("Char: $char, Chinese: $chinese")
}
布尔类型
fun main() {
val isKotlin: Boolean = true
val isJava: Boolean = false
// 布尔运算
val andResult = isKotlin && isJava // false
val orResult = isKotlin || isJava // true
val notResult = !isKotlin // false
println("AND: $andResult, OR: $orResult")
}
字符串类型
fun main() {
// 普通字符串
val str: String = "Hello, Kotlin"
// 原始字符串（多行）
val rawString = """
这是第一行
这是第二行
不会有转义
""".trimIndent()
// 字符串模板
val name = "Kotlin"
val greeting = "Hello, $name" // 简单变量
val length = "Length: ${name.length}" // 表达式
println(greeting)
println(length)
}
类型推断
Kotlin 具有强大的类型推断能力：
fun main() {
// 自动推断为 Int
val a = 10
// 自动推断为 String
val b = "Hello"
// 显式声明类型
val c: Int = 20
// 如果变量未初始化，必须显式声明类型
val d: Int // 只有声明没有初始化
d = 30
println("a: ${a::class.simpleName}, b: ${b::class.simpleName}")
}
运算符
算术运算符
fun main() {
val a = 10
val b = 3
println("a + b = ${a + b}") // 13
println("a - b = ${a - b}") // 7
println("a * b = ${a * b}") // 30
println("a / b = ${a / b}") // 3 (整数除法)
println("a % b = ${a % b}") // 1 (余数)
// 浮点除法
println("a.toDouble() / b = ${a.toDouble() / b}") // 3.333...
}
赋值运算符
fun main() {
var x = 10
x += 5 // x = x + 5
x -= 3 // x = x - 3
x *= 2 // x = x * 2
x /= 4 // x = x / 4
x %= 3 // x = x % 3
println("x = $x")
}
比较运算符
fun main() {
val a = 10
val b = 20
println("a == b: ${a == b}") // false
println("a != b: ${a != b}") // true
println("a > b: ${a > b}") // false
println("a < b: ${a < b}") // true
println("a >= b: ${a >= b}") // false
println("a <= b: ${a <= b}") // true
}
逻辑运算符
fun main() {
val x = 10
val y = 20
// && - 短路与
println(x > 0 && y > 0) // true
// || - 短路或
println(x > 0 || y < 0) // true
// ! - 取反
val flag = true
println(!flag) // false
}
in / !in 运算符
检查元素是否在区间或集合中：
fun main() {
val x = 5
val range = 1..10
println(x in range) // true
println(x !in range) // false
// 区间
println(x in 1..10) // true
// 字符串
val str = "Kotlin"
println("Kot" in str) // true
}
is / !is 运算符
类型检查（智能转换）：
fun main() {
val obj: Any = "Hello"
// 类型检查
println(obj is String) // true
println(obj !is Int) // true
// 智能转换
if (obj is String) {
// 在这个分支，obj 自动转换为 String
println(obj.length) // 5
}
}
注释
Kotlin 的注释与 Java 相同：
// 这是单行注释
/*
* 这是
* 多行注释
*/
/**
* 这是文档注释
* 用于生成 API 文档
* @param name 参数说明
* @return 返回值说明
*/
fun greet(name: String): String {
return "Hello, $name"
}
注意：Kotlin 的块注释可以嵌套，而 Java 不可以。
代码风格
语句结束
Kotlin 中每条语句不需要分号结尾（但加也不会报错）：
fun main() {
// 不需要分号
val a = 10
val b = 20
// 单行可以写多条语句（不推荐）
val c = 30; val d = 40
}
大括号
Kotlin 要求使用大括号，即使是单行语句：
// 正确
if (a > b) {
println("a > b")
}
// 错误（编译不过）
// if (a > b)
// println("a > b")
命名规范
- 包名：全小写，如
com.example.myapp - 类名：首字母大写，驼峰命名，如
MyClass - 函数名：首字母小写，驼峰命名，如
myFunction - 常量：全大写，下划线分隔，如
MAX_VALUE - 变量：首字母小写，驼峰命名，如
myVariable
类型转换
Kotlin 不会自动进行类型转换，需要显式调用转换函数：
fun main() {
val intNum: Int = 100
val longNum: Long = intNum.toLong() // 显式转换
val doubleNum: Double = intNum.toDouble()
val string: String = intNum.toString()
// 字符串转数字
val str = "123"
val num = str.toInt()
// 安全转换（失败返回 null）
val safeNum: Int? = str.toIntOrNull()
println("Converted: $longNum, $doubleNum, $string")
}
数字类型转换
fun main() {
// Int 转其他类型
val i: Int = 10
val l: Long = i.toLong()
val d: Double = i.toDouble()
val f: Float = i.toFloat()
val b: Byte = i.toByte()
val s: Short = i.toShort()
// 强制转换（可能丢失精度）
val bigNum = 1000L
val smallInt = bigNum.toInt() // 安全转换
// 截断行为
val pi = 3.99
println(pi.toInt()) // 3，小数部分被截断
}
可空类型
Kotlin 在类型系统层面支持可空类型：
fun main() {
// 非空类型
var name: String = "Kotlin"
// name = null // 编译错误！
// 可空类型（? 表示可以为空）
var nullableName: String? = "Kotlin"
nullableName = null // 正确
// 安全调用（?.）
val length = nullableName?.length // null
// Elvis 操作符（?:）
val len = nullableName?.length ?: 0 // 0
// 非空断言（!!）
// val len2 = nullableName.length // 编译错误
val len2 = nullableName!!.length // 可能抛出异常
println("Length: $length, $len")
}
小结
本章我们学习了：
- 程序入口：
main函数是 Kotlin 程序的起点 - 变量声明：
val（只读）和var（可变） - 基本数据类型：整数、浮点、字符、布尔、字符串
- 类型推断：Kotlin 自动推断变量类型
- 运算符：算术、比较、逻辑、in/is 等
- 注释：单行、多行、文档注释
- 类型转换：需要显式调用转换函数
- 可空类型：通过
?支持空值
练习
- 声明一个
val变量存储你的名字，一个var变量存储你的年龄 - 计算并打印 1 到 100 的总和
- 判断一个数是奇数还是偶数
- 使用字符串模板打印 "Hello, [名字]!"
- 创建一个可能为空的变量，并使用安全调用获取其长度