1. 基础类型和控制结构
字符串（可变与不可变）
// 不可变字符串
val immutableString = "Hello"
// immutableString = "World" // 错误，val 不可重新赋值
// 可变字符串
var mutableString = "Hello"
mutableString = "World" // 正确
// 字符串模板
val name = "Alice"
println("Hello, $name!") // 输出: Hello, Alice!
println("Your name has ${name.length} characters") // 输出: Your name has 5 characters
// 原始字符串
val multilineString = """
This is a multiline
string in Kotlin.
It preserves all indentation.
""".trimIndent()
println(multilineString)
数字类型
// 整数类型
val byte: Byte = 127
val short: Short = 32767
val int: Int = 2147483647
val long: Long = 9223372036854775807L
// 浮点类型
val float: Float = 3.14f
val double: Double = 3.141592653589793
// 数字转换
val stringNumber = "123"
val intNumber = stringNumber.toInt()
// 数字运算
println(1 + 2) // 3
println(2.5 * 4) // 10.0
println(5 / 2) // 2 (整数除法)
println(5 / 2.0) // 2.5
字典（Map）
// 不可变Map
val immutableMap = mapOf(
"name" to "Alice",
"age" to 25,
"city" to "New York"
)
println(immutableMap["name"]) // Alice
// 可变Map
val mutableMap = mutableMapOf(
"name" to "Bob",
"age" to 30
)
mutableMap["city"] = "London"
mutableMap.remove("age")
// 遍历Map
for ((key, value) in mutableMap) {
println("$key = $value")
}
数组
// 数组创建
val numbers = arrayOf(1, 2, 3, 4, 5)
val nulls = arrayOfNulls<Int>(5)
val squares = Array(5) { i -> (i * i).toString() }
// 基本类型数组（避免装箱开销）
val intArray = intArrayOf(1, 2, 3)
val charArray = charArrayOf('a', 'b', 'c')
// 数组访问和修改
println(numbers[0]) // 1
numbers[0] = 10
// 数组遍历
for (num in numbers) {
println(num)
}
numbers.forEach { println(it) }
循环结构
// for循环
for (i in 1..5) { // 1到5（包含5）
print("$i ")
}
println()
for (i in 1 until 5) { // 1到4（不包含5）
print("$i ")
}
println()
for (i in 5 downTo 1) { // 5到1
print("$i ")
}
println()
for (i in 1..10 step 2) { // 1,3,5,7,9
print("$i ")
}
println()
// while循环
var x = 5
while (x > 0) {
print("$x ")
x--
}
println()
// do-while循环
var y = 0
do {
print("$y ")
y++
} while (y < 5)
println()
when 表达式（类似 switch）
val grade = 'B'
val result = when (grade) {
'A' -> "Excellent"
'B' -> "Good"
'C' -> "Average"
'D' -> "Below Average"
'F' -> "Fail"
else -> "Invalid Grade"
}
println(result) // Good
// when 也可以用作表达式或语句
val number = 42
when {
number < 0 -> println("Negative")
number == 0 -> println("Zero")
else -> println("Positive")
}
// when 可以检查类型
val obj: Any = "Hello"
when (obj) {
is String -> println("String length: ${obj.length}")
is Int -> println("Int value: $obj")
else -> println("Unknown type")
}
if 表达式
val a = 10
val b = 20
// 传统用法
if (a > b) {
println("a is greater")
} else {
println("b is greater")
}
// 作为表达式（类似三元运算符）
val max = if (a > b) a else b
println("Max is $max")
// if-else if 链
val score = 85
val grade = if (score >= 90) {
"A"
} else if (score >= 80) {
"B"
} else if (score >= 70) {
"C"
} else {
"D"
}
println("Grade: $grade")
2. 枚举和常量
枚举
enum class Direction {
NORTH, SOUTH, EAST, WEST
}
// 带属性的枚举
enum class Color(val rgb: Int) {
RED(0xFF0000),
GREEN(0x00FF00),
BLUE(0x0000FF)
}
// 使用枚举
val currentDirection = Direction.NORTH
when (currentDirection) {
Direction.NORTH -> println("Heading North")
Direction.SOUTH -> println("Heading South")
Direction.EAST -> println("Heading East")
Direction.WEST -> println("Heading West")
}
println(Color.RED.rgb) // 输出: 16711680
常量（类似宏定义）
// 编译时常量
const val PI = 3.14159
const val MAX_USERS = 1000
// 顶层常量（非编译时常量）
val APP_NAME = "MyKotlinApp"
fun main() {
println("PI = $PI")
println("MAX_USERS = $MAX_USERS")
println("APP_NAME = $APP_NAME")
}
3. 类和面向对象
类定义
// 简单类
class Person {
// 属性
var name: String = ""
var age: Int = 0
// 方法
fun speak() {
println("$name is speaking")
}
}
// 使用
val person = Person()
person.name = "Alice"
person.age = 25
person.speak()
构造函数
// 主构造函数
class Person constructor(firstName: String) {
val name: String
init {
name = firstName.capitalize()
println("Person initialized with name: $name")
}
}
// 简化主构造函数
class Person(val name: String, var age: Int) {
init {
println("Person $name created, age $age")
}
}
// 次构造函数
class Person(val name: String) {
var age: Int = 0
var city: String = ""
constructor(name: String, age: Int) : this(name) {
this.age = age
}
constructor(name: String, age: Int, city: String) : this(name, age) {
this.city = city
}
}
// 使用
val p1 = Person("Alice")
val p2 = Person("Bob", 30)
val p3 = Person("Charlie", 25, "London")
类属性和方法
class Rectangle(val width: Double, val height: Double) {
// 计算属性
val area: Double
get() = width * height
// 可变属性
var scale: Double = 1.0
set(value) {
if (value > 0) {
field = value
}
}
// 实例方法
fun printDescription() {
println("Rectangle $width x $height, area = $area")
}
// 伴生对象（类似静态方法）
companion object {
fun createSquare(side: Double): Rectangle {
return Rectangle(side, side)
}
}
}
// 使用
val rect = Rectangle(10.0, 5.0)
println(rect.area) // 50.0
rect.scale = 2.0
rect.printDescription()
val square = Rectangle.createSquare(7.0)
square.printDescription()、
继承和多态
// 基类（默认是final的，必须用open才能被继承）
open class Animal(val name: String) {
open fun makeSound() {
println("$name makes a sound")
}
}
// 派生类
class Dog(name: String) : Animal(name) {
override fun makeSound() {
println("$name barks")
}
fun fetch() {
println("$name is fetching")
}
}
// 另一个派生类
class Cat(name: String) : Animal(name) {
override fun makeSound() {
println("$name meows")
}
}
// 使用多态
fun animalSounds(animals: List<Animal>) {
for (animal in animals) {
animal.makeSound()
}
}
val animals = listOf(
Dog("Rex"),
Cat("Whiskers"),
Animal("Generic Animal")
)
animalSounds(animals)
/*
输出:
Rex barks
Whiskers meows
Generic Animal makes a sound
*/
抽象类和接口
// 抽象类
abstract class Shape(val name: String) {
abstract fun area(): Double
fun printInfo() {
println("Shape: $name, Area: ${area()}")
}
}
// 接口
interface Drawable {
fun draw()
}
// 实现抽象类和接口
class Circle(name: String, val radius: Double) : Shape(name), Drawable {
override fun area(): Double {
return Math.PI * radius * radius
}
override fun draw() {
println("Drawing a circle with radius $radius")
}
}
// 使用
val circle = Circle("My Circle", 5.0)
circle.printInfo()
circle.draw()
数据类
// 数据类自动生成equals(), hashCode(), toString(), copy()等方法
data class User(val name: String, val age: Int, val email: String)
// 使用
val user1 = User("Alice", 25, "alice@example.com")
val user2 = User("Bob", 30, "bob@example.com")
val user3 = user1.copy(name = "Alice Smith")
println(user1) // 自动生成的toString()
println(user1 == user3) // false, 因为name不同
println(user1.hashCode())
// 解构声明
val (name, age, email) = user2
println("$name is $age years old, email: $email")
密封类
// 密封类用于表示受限的类层次结构
sealed class Result {
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()
object Loading : Result()
}
fun handleResult(result: Result) {
when (result) {
is Result.Success -> println("Success: ${result.data}")
is Result.Error -> println("Error: ${result.message}")
Result.Loading -> println("Loading...")
}
}
// 使用
handleResult(Result.Success("Data loaded"))
handleResult(Result.Error("Network error"))
handleResult(Result.Loading)
4. 其他特性
扩展函数
// 为String类添加扩展函数
fun String.addExclamation(): String {
return "$this!"
}
// 使用
val greeting = "Hello"
println(greeting.addExclamation()) // Hello!
// 扩展属性
val String.hasDigits: Boolean
get() = this.matches(".*\\d+.*".toRegex())
println("abc123".hasDigits) // true
println("abc".hasDigits) // false
空安全
// 可空类型
var nullableString: String? = null
// 安全调用
val length = nullableString?.length // 如果nullableString为null，length为null
// Elvis操作符
val safeLength = nullableString?.length ?: 0 // 如果为null，返回0
// 非空断言（慎用）
// val forcedLength = nullableString!!.length // 如果为null，抛出异常
// 安全转换
val number: Int? = "123".toIntOrNull()
泛型
// 泛型类
class Box<T>(val content: T) {
fun getContent(): T {
return content
}
}
// 使用
val intBox = Box(123)
val stringBox = Box("Hello")
// 泛型函数
fun <T> printItem(item: T) {
println("Item: $item")
}
printItem(42)
printItem("Kotlin")
