변수와 타입 시스템 — val, var, 그리고 코틀린이 타입을 다루는 방식

val name = "코틀린"   // 재할당 불가 (read-only)
var age = 5           // 재할당 가능 (mutable)

// name = "자바"      // 컴파일 에러!
age = 6               // OK

val numbers = mutableListOf(1, 2, 3)
// numbers = mutableListOf(4, 5)   // 컴파일 에러 — 참조 변경 불가
numbers.add(4)                      // OK — 내부 상태 변경은 가능
println(numbers)                    // [1, 2, 3, 4]

// 최상위 레벨 또는 object 내부에서만 사용 가능
const val MAX_RETRY = 3
const val APP_NAME = "MyApp"
// const val date = Date()  // 컴파일 에러 — 런타임 값은 불가

val message = "안녕하세요"     // String으로 추론
val count = 42                 // Int로 추론
val pi = 3.14                  // Double로 추론
val isKotlin = true            // Boolean으로 추론

val score: Int = 100           // 명시적 타입 선언
fun greet(name: String): String {   // 파라미터는 타입 필수
    return "안녕, $name"
}

val result: String             // 타입 명시 필수
result = computeSomething()

// val unknown                 // 컴파일 에러 — 타입을 알 수 없음

val a: Int = 42       // JVM에서 primitive int로 컴파일
val b: Int? = 42      // JVM에서 java.lang.Integer(boxing)로 컴파일

val x: Int = 1000
val y: Int = 1000
println(x == y)   // true — 값 비교(==)

val a: Int? = 1000
val b: Int? = 1000
println(a == b)    // true — 값 비교(==)는 같음
println(a === b)   // false — 참조 비교(===)는 다름 (서로 다른 Integer 객체)

val intVal: Int = 42
// val longVal: Long = intVal    // 컴파일 에러!
val longVal: Long = intVal.toLong()  // 명시적 변환 필요

val anything: Any = 42         // Int도 Any의 하위 타입
val text: Any = "문자열"

// Any에 정의된 메서드
anything.toString()
anything.hashCode()
anything.equals(text)

fun printMessage(msg: String): Unit {  // Unit 생략 가능
    println(msg)
}

// 제네릭에서의 활용
fun <T> execute(action: () -> T): T = action()
execute<Unit> { println("실행") }      // void 대신 Unit 사용 가능

fun fail(message: String): Nothing {
    throw IllegalArgumentException(message)
}

// Nothing은 모든 타입의 하위 타입이므로 이런 코드가 가능하다
val result: String = input ?: fail("값이 없습니다")

// Nothing?은 null만 담을 수 있는 타입
val nothing: Nothing? = null
// val impossible: Nothing = ???  // 값을 생성할 수 없음

fun describe(obj: Any): String {
    // is 검사를 통과하면 자동으로 해당 타입으로 캐스팅
    if (obj is String) {
        return "문자열 길이: ${obj.length}"  // obj가 String으로 자동 캐스팅
    }
    if (obj is Int) {
        return "정수의 제곱: ${obj * obj}"   // obj가 Int로 자동 캐스팅
    }
    return "알 수 없는 타입"
}

fun process(value: Any) {
    when (value) {
        is String -> println("길이: ${value.length}")      // 자동 캐스팅
        is List<*> -> println("리스트 크기: ${value.size}") // 자동 캐스팅
        is Int -> println("값: ${value + 1}")               // 자동 캐스팅
        else -> println("기타")
    }
}

class Example {
    var data: Any = "초기값"

    fun check() {
        if (data is String) {
            // println(data.length)  // 컴파일 에러!
            // var 프로퍼티는 다른 스레드에서 변경될 수 있으므로
            // 스마트 캐스트가 보장되지 않는다
        }

        // 해결 방법 1: 지역 변수에 복사
        val localData = data
        if (localData is String) {
            println(localData.length)  // OK
        }

        // 해결 방법 2: 명시적 캐스팅
        if (data is String) {
            println((data as String).length)  // OK (하지만 안전하지 않음)
        }
    }
}

val obj: Any = "코틀린"

// 안전하지 않은 캐스팅 — 실패하면 ClassCastException
val str: String = obj as String

// 안전한 캐스팅 — 실패하면 null 반환
val num: Int? = obj as? Int     // null (ClassCastException 대신)

         Any
        / | \
     Int String ...
        \ | /
        Nothing