// Kotlin 1.3.11 编译器版本
// 无包声明

// 定义数据类 A1，类似 C 语言中的结构体
data class A1(
    // 长整型属性，类似 C 语言结构体中的成员
    var representation: Long
)

// 定义静态方法 DDD1，接收 Any 类型参数，类似 C 语言中的函数定义风格
fun DDD1(FFF1: Any) {
    if (FFF1 is String) { // 判断传入的参数 FFF1 是否为 String 类型
        println(FFF1.length) // 如果是，打印其长度
    }
}

fun main() {
    // 1. 集中声明变量，类型前置，符合 C 语言风格的变量声明习惯
    // 对象变量
    var GGG1: Any // 声明对象类型变量 GGG1
    var GGG2: Any // 声明对象类型变量 GGG2
    var GGG3: Any // 声明对象类型变量 GGG3
    var GGG4: Any // 声明对象类型变量 GGG4
    var GGG5: Any // 声明对象类型变量 GGG5
    var GGG6: Any // 声明对象类型变量 GGG6
    var GGG7: Any // 声明对象类型变量 GGG7
    var GGG8: Any? // 声明可空对象类型变量 GGG8
    var GGG9: Any // 声明对象类型变量 GGG9
    var GGG10: Any? // 声明可空对象类型变量 GGG10
    // 字符串变量
    var SSS2: String // 声明字符串类型变量 SSS2
    var SSS3: String // 声明字符串类型变量 SSS3
    var SSS4: String? // 声明可空字符串类型变量 SSS4
    var SSS5: String? // 声明可空字符串类型变量 SSS5
    // 整数变量（虽然初始类型为 Any，但后续会赋予整数值）
    var FFF1: Any // 声明整数类型变量 FFF1（初始类型为 Any）

    // 2. 变量赋值
    GGG1 = "Hello" // 给对象类型变量 GGG1 赋值为字符串 "Hello"
    GGG2 = 123 // 给对象类型变量 GGG2 赋值为整数 123
    GGG3 = "Kotlin" // 给对象类型变量 GGG3 赋值为字符串 "Kotlin"
    GGG4 = "Test" // 给对象类型变量 GGG4 赋值为字符串 "Test"
    GGG5 = "Sample" // 给对象类型变量 GGG5 赋值为字符串 "Sample"
    GGG6 = 456 // 给对象类型变量 GGG6 赋值为整数 456
    GGG7 = "Conversion" // 给对象类型变量 GGG7 赋值为字符串 "Conversion"
    GGG8 = null // 给可空对象类型变量 GGG8 赋值为 null
    GGG9 = "SafeCast" // 给对象类型变量 GGG9 赋值为字符串 "SafeCast"
    GGG10 = null // 给可空对象类型变量 GGG10 赋值为 null

    // 3. is 与!is 操作符示例
    if (GGG1 is String) { // 判断对象变量 GGG1 是否为 String 类型
        println(GGG1.length) // 如果是，打印其长度
    }
    if (GGG2!is String) { // 判断对象变量 GGG2 是否不是 String 类型
        println("Not a String") // 如果不是，打印 "Not a String"
    } else {
        println(GGG2.length) // 如果是，打印其长度（但这里 GGG2 是整数，实际不会执行到这里）
    }

    // 4. 智能转换示例
    FFF1 = 123 // 给整数变量 FFF1 赋值为 123
    DDD1(FFF1) // 调用静态方法 DDD1，并传入 FFF1 作为参数
    FFF1 = "World" // 给整数变量 FFF1 重新赋值为字符串 "World"
    DDD1(FFF1) // 再次调用静态方法 DDD1，并传入 FFF1 作为参数

    if (GGG3!is String) return // 如果对象变量 GGG3 不是 String 类型，结束 main 函数
    println(GGG3.length) // 如果是，打印其长度

    if (GGG4!is String || GGG4.length == 0) return // 如果对象变量 GGG4 不是 String 类型或者长度为 0，结束 main 函数
    println(GGG4.length) // 如果不是，打印其长度

    if (GGG5 is String && GGG5.length > 0) { // 如果对象变量 GGG5 是 String 类型且长度大于 0
        println(GGG5.length) // 打印其长度
    }

    when (GGG6) { // 根据对象变量 GGG6 的类型进行不同操作
        is Int -> println(GGG6 + 1) // 如果是 Int 类型，打印其值加 1 的结果
        is String -> println(GGG6.length + 1) // 如果是 String 类型，打印其长度加 1 的结果
        is IntArray -> println(GGG6.sum()) // 如果是 IntArray 类型，打印其元素之和
    }

    // 5. “不安全的”转换操作符示例
    try {
        SSS2 = GGG7 as String // 尝试将对象变量 GGG7 强制转换为 String 类型并赋值给 SSS2
        println(SSS2) // 打印转换后的字符串 SSS2
    } catch (e: ClassCastException) { // 捕获类型转换异常
        println("Unsafe cast failed: ${e.message}") // 打印异常信息
    }

    try {
        SSS3 = GGG8 as String // 尝试将可空对象变量 GGG8 强制转换为 String 类型并赋值给 SSS3
        println(SSS3) // 打印转换后的字符串 SSS3
    } catch (e: ClassCastException) { // 捕获类型转换异常
        println("Unsafe cast failed: ${e.message}") // 打印异常信息
    }

    // 6. “安全的”（可空）转换操作符示例
    SSS4 = GGG9 as? String // 尝试将对象变量 GGG9 安全转换为 String 类型并赋值给 SSS4（可空）
    println(SSS4) // 打印转换后的字符串 SSS4（可能为 null）

    SSS5 = GGG10 as? String // 尝试将可空对象变量 GGG10 安全转换为 String 类型并赋值给 SSS5（可空）
    println(SSS5) // 打印转换后的字符串 SSS5（可能为 null）
}