Kotlin 类型转换 #

// Java：隐式转换
int a = 100;
long b = a;  // 自动转换

// Kotlin：需要显式转换
val a: Int = 100
// val b: Long = a  // 编译错误
val b: Long = a.toLong()  // 正确

val int = 100

int.toByte()
int.toShort()
int.toInt()
int.toLong()
int.toFloat()
int.toDouble()
int.toChar()

val a: Int = 100
val b: Long = a.toLong()
val c: Double = b.toDouble()
val d: Float = c.toFloat()
val e: Int = d.toInt()

val long: Long = 1000000000000L
val int: Int = long.toInt()  // 精度丢失

println(int)  // -727379968（溢出）

// 安全转换
val safeInt = long.coerceIn(Int.MIN_VALUE, Int.MAX_VALUE).toInt()

val a: Int = 10
val b: Long = 20L

val sum = a + b       // Long
val product = a * b   // Long

val c: Float = 1.5f
val d: Double = 2.5

val result = c + d    // Double

val obj: Any = "Hello"

if (obj is String) {
    println(obj.length)  // 智能转换为 String
}

// 否定形式
if (obj !is String) {
    println("Not a String")
}

fun process(obj: Any) {
    when (obj) {
        is Int -> println("Integer: $obj")
        is String -> println("String: ${obj.length}")
        is List<*> -> println("List: ${obj.size}")
        else -> println("Unknown type")
    }
}

// 不能检查泛型参数的具体类型
val list: List<String> = listOf("A", "B")

// 错误：泛型擦除
// if (list is List<String>) { }

// 正确：检查星投影
if (list is List<*>) {
    println("It's a List")
}

val obj: Any = "Hello"

if (obj is String) {
    // obj 自动转换为 String 类型
    println(obj.uppercase())
    println(obj.length)
}

// val 局部变量
val obj: Any = "Hello"
if (obj is String) {
    println(obj.length)  // 正确
}

// var 局部变量（编译器无法保证）
var obj2: Any = "Hello"
if (obj2 is String) {
    // 可能需要额外检查
    println(obj2.length)
}

// 类属性（val 且没有自定义 getter）
class Person(val name: Any) {
    fun print() {
        if (name is String) {
            println(name.length)  // 正确
        }
    }
}

// if 语句
if (obj is String) {
    println(obj.length)
}

// when 语句
when (obj) {
    is String -> println(obj.length)
    is Int -> println(obj * 2)
}

// while 循环
while (obj !is String) {
    // ...
}

// 逻辑表达式
if (obj is String && obj.length > 5) {
    println(obj.uppercase())
}

// 提前返回
if (obj !is String) return
println(obj.length)  // 智能转换

val obj: Any = "Hello"

val str: String = obj as String  // 成功

val num: Int = obj as Int  // ClassCastException

val obj: Any = "Hello"

val str: String? = obj as? String  // "Hello"
val num: Int? = obj as? Int        // null

fun process(obj: Any) {
    // 不安全转换
    try {
        val str = obj as String
        println(str.length)
    } catch (e: ClassCastException) {
        println("Not a String")
    }
    
    // 安全转换（推荐）
    val str = obj as? String
    println(str?.length ?: "Not a String")
}

val num = 123

num.toString()           // "123"

// 格式化
String.format("%d", num)      // "123"
String.format("%04d", num)    // "0123"
String.format("%x", num)      // "7b"（十六进制）

// 基本转换
"123".toInt()        // 123
"123".toLong()       // 123L
"3.14".toFloat()     // 3.14f
"3.14".toDouble()    // 3.14

// 进制转换
"FF".toInt(16)       // 255
"1010".toInt(2)      // 10

// 安全转换
"abc".toIntOrNull()       // null
"123".toIntOrNull()       // 123
"FF".toIntOrNull(16)      // 255

fun safeToInt(str: String): Int {
    return str.toIntOrNull() ?: 0
}

// 使用
val num = safeToInt("123")
val invalid = safeToInt("abc")  // 0

class Person(val name: String, val age: Int) {
    fun toUser(): User {
        return User(name, age)
    }
}

class User(val name: String, val age: Int)

val person = Person("Kotlin", 10)
val user = person.toUser()

fun String.toPerson(): Person {
    val parts = this.split(",")
    return Person(parts[0], parts[1].toInt())
}

val person = "Kotlin,10".toPerson()

class Dollar(val amount: Double) {
    operator fun plus(other: Euro): Dollar {
        return Dollar(amount + other.amount * 1.1)
    }
}

class Euro(val amount: Double)

val dollar = Dollar(100.0)
val euro = Euro(50.0)
val total = dollar + euro

typealias UserName = String
typealias UserId = Long

fun process(name: UserName, id: UserId) {
    // 编译时类型别名会被替换为原类型
    val str: String = name
    val long: Long = id
}

typealias StringList = List<String>

val list1: StringList = listOf("A", "B")
val list2: List<String> = list1  // 完全相同

// 类型检查
println(list1 is List<*>)  // true
println(list1 is StringList)  // 编译错误

fun <T> process(list: List<T>) {
    // 运行时不知道 T 的具体类型
    // if (list is List<String>) { }  // 编译错误
}

// 使用具体化类型参数
inline fun <reified T> isType(value: Any): Boolean {
    return value is T
}

println(isType<String>("Hello"))  // true
println(isType<Int>("Hello"))     // false

val list: List<*> = listOf("A", "B", "C")

if (list is List<*>) {
    println(list.size)
}

// 推荐
if (obj is String) {
    println(obj.length)
}

// 不推荐
if (obj is String) {
    println((obj as String).length)
}

// 推荐
val str = obj as? String ?: return

// 不推荐
try {
    val str = obj as String
} catch (e: ClassCastException) {
    // ...
}

fun process(obj: Any) {
    if (obj !is String) return
    
    // 后续代码可以安全使用 String 方法
    println(obj.length)
    println(obj.uppercase())
}

fun describe(obj: Any): String = when (obj) {
    is String -> "String of length ${obj.length}"
    is Int -> "Integer $obj"
    is Boolean -> if (obj) "True" else "False"
    is List<*> -> "List with ${obj.size} elements"
    else -> "Unknown type"
}