Kotlin 基础语法 #

// 包声明（可选）
package com.example

// 导入语句（可选）
import java.util.*

// 顶层函数、类、对象等
fun main() {
    println("Hello, Kotlin!")
}

package com.example.demo

fun sayHello() {
    println("Hello!")
}

class Person {
    var name: String = ""
}

// 导入单个类
import java.util.ArrayList

// 导入整个包
import java.util.*

// 导入函数
import kotlin.math.sqrt

// 导入时重命名
import java.util.ArrayList as JArrayList

// 这是单行注释
val name = "Kotlin"  // 行尾注释

/*
 * 这是多行注释
 * 可以跨越多行
 * 用于详细说明
 */
fun calculate(a: Int, b: Int): Int {
    return a + b
}

/**
 * 计算两个数的和
 * 
 * @param a 第一个数
 * @param b 第二个数
 * @return 两数之和
 */
fun add(a: Int, b: Int): Int {
    return a + b
}

/**
 * 表示一个人的类
 * 
 * @property name 姓名
 * @property age 年龄
 * @constructor 创建一个 Person 实例
 */
class Person(val name: String, val age: Int) {
    /**
     * 打招呼
     * 
     * @return 问候语
     */
    fun greet(): String = "Hello, I'm $name"
}

/*
 * 外层注释开始
 * 
 * /*
 *  * 内层注释
 *  */
 * 
 * 外层注释结束
 */

// 合法标识符
val name = "Kotlin"
val _count = 10
val userName = "admin"
val UserAge = 25

// 非法标识符
// val 123abc = ""      // 错误：以数字开头
// val my-name = ""     // 错误：包含连字符
// val class = ""       // 错误：是关键字

// 使用关键字作为函数名
fun `is`() = true
fun `in`() = "inside"

// 使用空格等特殊字符
val `my variable` = 10

// 调用
`is`()
`in`()
println(`my variable`)

// file, where, by, get, set, field, property, etc.

// 作为标识符使用
val file = "test.txt"
val get = "getter"

// 访问修饰符
public    // 公开
private   // 私有
protected // 保护
internal  // 模块内可见

// 其他修饰符
open      // 可继承/可重写
final     // 不可继承/不可重写
abstract  // 抽象
override  // 重写
lateinit  // 延迟初始化
sealed    // 密封类
data      // 数据类
enum      // 枚举类
inline    // 内联函数
suspend   // 挂起函数

fun main() {
    // 函数体代码块
    val a = 10
    
    // 局部代码块
    {
        val b = 20
        println("a + b = ${a + b}")
    }
    
    // println(b)  // 错误：b 不可见
}

val globalVar = 100  // 全局变量

fun example() {
    val localVar = 200  // 局部变量
    
    if (true) {
        val blockVar = 300  // 块级变量
        println(globalVar)   // 可访问
        println(localVar)    // 可访问
        println(blockVar)    // 可访问
    }
    
    // println(blockVar)  // 错误：不可访问
}

val count = 100

fun test() {
    val count = 200  // 遮蔽外部变量
    println(count)   // 输出 200
    
    if (true) {
        val count = 300  // 遮蔽函数级变量
        println(count)   // 输出 300
    }
    
    println(count)   // 输出 200
}

// 字面量表达式
10
"Hello"
true

// 算术表达式
1 + 2
a * b

// 比较表达式
a > b
x == y

// 函数调用表达式
calculate(1, 2)
list.size

// Lambda 表达式
{ x: Int -> x * 2 }

// 赋值语句
val x = 10

// 表达式语句
println("Hello")

// 控制流语句
if (x > 0) { ... }
for (i in 1..10) { ... }

// 普通函数
fun add(a: Int, b: Int): Int {
    return a + b
}

// 表达式体函数
fun add(a: Int, b: Int) = a + b

// 不需要分号
val name = "Kotlin"
println(name)

// 可以加分号（不推荐）
val age = 10;
println(age);

val a = 10; val b = 20; println(a + b)

fun main() {
    if (true) {
        println("Hello")
    }
}

// 推荐
if (condition) {
    doSomething()
}

// 不推荐
if (condition)
{
    doSomething()
}

package com.example

import java.util.*

class Person {
    var name: String = ""
    var age: Int = 0
    
    fun greet(): String {
        return "Hello, $name"
    }
}

fun main() {
    val person = Person()
    person.name = "Kotlin"
    
    println(person.greet())
}

// 过长的行可以换行
val result = veryLongFunctionName(
    firstArgument,
    secondArgument,
    thirdArgument
)

// 链式调用换行
val filteredList = list
    .filter { it > 0 }
    .map { it * 2 }
    .sorted()

// 参数较少时单行
fun add(a: Int, b: Int): Int = a + b

// 参数较多时换行
fun createPerson(
    name: String,
    age: Int,
    address: String,
    phone: String
): Person {
    return Person(name, age, address, phone)
}

// 错误：变量声明后必须初始化
val name: String
name = "Kotlin"  // 错误

// 正确
val name: String = "Kotlin"

// 错误：类型不匹配
val age: Int = "25"  // 错误

// 正确
val age: Int = 25

// 错误：重复定义
val x = 10
val x = 20  // 错误