Kotlin 기초 문법 완전 정리

Kotlin code

// val = immutable (재할당 불가)
val name: String = "Kotlin"
val pi = 3.14159   // 타입 추론

// var = mutable (재할당 가능)
var count = 0
count = 10         // OK
count += 5         // OK

// name = "Java"  // ❌ 컴파일 에러!

fun main() {
    // 블록 내 지연 초기화도 가능
    val result: String
    result = if (count > 10) "크다" else "작다"
    println("$name / $result")
}

Kotlin code

val age: Int       = 25
val salary: Long   = 50_000_000L   // _ 로 가독성 향상
val height: Float  = 175.5f
val weight: Double = 68.3
val isKotlin: Boolean = true
val grade: Char    = 'A'

// 타입 변환은 반드시 명시적으로
val x: Int = 100
val y: Long = x.toLong()    // ✅
val z: Double = x.toDouble()

// 다양한 진법 리터럴
val hex = 0xFF          // 255
val binary = 0b1010     // 10

fun main() {
    println("최대 Int: ${Int.MAX_VALUE}")
    println("최대 Long: ${Long.MAX_VALUE}")
}

Kotlin code

// Non-null 타입 (기본) — null 불가
var name: String = "Kotlin"
// name = null  // ❌ 컴파일 에러

// Nullable 타입 — ? 붙이기
var nickname: String? = "Dev"
nickname = null  // ✅

// Safe call (?.) — null이면 null 반환
val length = nickname?.length        // Int?

// Elvis operator (?:) — null이면 기본값
val len = nickname?.length ?: 0      // Int

// Non-null assertion (!!) — null이면 NPE
// 확실히 null이 아닐 때만 사용
val forced = nickname!!.length       // 위험!

// let으로 null 아닌 경우만 실행
nickname?.let { nick ->
    println("닉네임 길이: ${nick.length}")
}

// 안전한 타입 캐스팅
val obj: Any = "hello"
val str: String? = obj as? String    // 실패 시 null

Kotlin code

val lang = "Kotlin"
val version = 2
val score = 98.5

// 변수 직접 삽입
println("언어: $lang")

// 표현식 삽입 ${}
println("다음 버전: ${version + 1}")
println("대문자: ${lang.uppercase()}")
println("점수 등급: ${if (score >= 90) "A" else "B"}")

// 달러 기호 출력
println("가격: $100")
println("가격: ${'$'}100")  // 또는 이렇게

// Triple quote + 템플릿
val report = """
    |언어: $lang
    |버전: $version
    |점수: ${"%.1f".format(score)}점
""".trimMargin()
println(report)

Kotlin code

val score = 85

// if는 표현식 — 삼항연산자 불필요
val grade = if (score >= 90) "A"
            else if (score >= 80) "B"
            else if (score >= 70) "C"
            else "F"

// when — Java switch보다 강력
val msg = when (score) {
    100          -> "만점!"
    in 90..99    -> "우수"
    in 80..89    -> "양호"
    in 70..79    -> "보통"
    else         -> "노력 필요"
}

// when without argument (if-else chain 대체)
when {
    score > 95  -> println("탑 5%!")
    score > 80  -> println("상위권")
    else        -> println("분발하세요")
}

// when + 타입 체크
fun describe(obj: Any): String = when (obj) {
    is Int    -> "정수: $obj"
    is String -> "문자열 길이: ${obj.length}"
    is List<*>-> "리스트 크기: ${obj.size}"
    else      -> "알 수 없는 타입"
}

Kotlin code

// 닫힌 범위 1..5 (5 포함)
for (i in 1..5) print("$i ")          // 1 2 3 4 5

// 열린 범위 until (5 미포함)
for (i in 1 until 5) print("$i ")     // 1 2 3 4

// 역순
for (i in 5 downTo 1) print("$i ")   // 5 4 3 2 1

// 스텝
for (i in 0..10 step 2) print("$i ") // 0 2 4 6 8 10

// 컬렉션 순회
val fruits = listOf("🍎", "🍌", "🍇")
for (fruit in fruits) println(fruit)

// 인덱스와 값 동시에
for ((idx, fruit) in fruits.withIndex()) {
    println("$idx: $fruit")
}

// while
var n = 5
while (n > 0) { print("$n "); n-- }

// repeat
repeat(3) { i -> println("반복 $i") }

Kotlin code

// Pair, Triple
val pair = Pair("Kotlin", 2024)
val (lang, year) = pair
println("$lang $year")

// data class는 자동으로 componentN() 생성
data class Point(val x: Int, val y: Int)
val (x, y) = Point(10, 20)
println("x=$x, y=$y")

// 특정 항목 무시: _
data class User(val id: Int, val name: String, val email: String)
val (_, name, _) = User(1, "Alice", "a@test.com")
println(name)

// Map 순회에서 destructuring
val map = mapOf("a" to 1, "b" to 2)
for ((key, value) in map) {
    println("$key → $value")
}

// withIndex destructuring
listOf("x", "y", "z").forEachIndexed { idx, item ->
    println("$idx: $item")
}

Kotlin code

// lateinit — var에만 사용, non-null 보장 필요할 때
// (주로 DI, Android ViewModel, 테스트)
class UserService {
    lateinit var repository: UserRepository

    fun setup() {
        repository = UserRepository()
    }

    fun getUser() {
        // 초기화 전 접근 시 UninitializedPropertyAccessException
        if (::repository.isInitialized) {
            repository.find()
        }
    }
}

// lazy — val에 사용, 첫 접근 시 한 번만 초기화
// 기본적으로 thread-safe (LazyThreadSafetyMode.SYNCHRONIZED)
class Config {
    val heavyData: List<String> by lazy {
        println("처음 한 번만 실행")
        loadFromDisk()  // 비용이 큰 초기화
    }
}

fun loadFromDisk() = listOf("data1", "data2")

Kotlin code

<span class="cm">// Enum class 완전 활용 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("Enum class 완전 활용") }

Kotlin code

fun main() {
    val intVal: Int = 42
    val longVal: Long = intVal.toLong()
    val doubleVal: Double = intVal.toDouble()
    val stringVal: String = intVal.toString()

    // 문자열 → 숫자 (실패 시 null)
    val parsed: Int? = "123".toIntOrNull()
    val invalid: Int? = "abc".toIntOrNull() // null

    println("Long: $longVal, Double: $doubleVal")
    println("Parsed: $parsed, Invalid: $invalid")
}

Kotlin code

fun main() {
    // 닫힌 범위 (1~10 포함)
    for (i in 1..10) print("$i ")
    println()

    // 반개방 범위 (10 미포함)
    for (i in 0 until 10 step 2) print("$i ")
    println()

    // 역순 범위
    for (i in 10 downTo 1 step 3) print("$i ")
    println()

    // 범위 검사
    val score = 85
    println(score in 80..100) // true
}

Kotlin code

fun main() {
    val a = "Hello"
    val b = "Hello"
    val c = String("Hello".toCharArray())

    println(a == b)   // true (구조적 동등)
    println(a === b)  // true (문자열 풀)
    println(a == c)   // true (구조적 동등)
    println(a === c)  // false (다른 객체)

    // Comparable 구현
    data class Version(val major: Int, val minor: Int) : Comparable<Version> {
        override fun compareTo(other: Version) =
            compareValuesBy(this, other, { it.major }, { it.minor })
    }
    println(Version(2, 0) > Version(1, 9)) // true
}

Kotlin code

fun main() {
    val flags = 0b1010
    val mask  = 0b1100

    println(flags and mask)  // 0b1000 = 8
    println(flags or mask)   // 0b1110 = 14
    println(flags xor mask)  // 0b0110 = 6
    println(flags.inv())     // 비트 반전

    // 시프트 연산
    println(1 shl 4)   // 16 (왼쪽 시프트)
    println(32 shr 2)  // 8  (오른쪽 시프트)

    // 플래그 활용
    val READ = 1; val WRITE = 2; val EXEC = 4
    var perm = READ or WRITE
    println(perm and EXEC != 0)  // false
}

Kotlin code

data class Point(val x: Int, val y: Int)

fun getUser() = Triple("김철수", 25, "서울")

fun main() {
    // data class 분해
    val (x, y) = Point(10, 20)
    println("x=$x, y=$y")

    // Triple 분해
    val (name, age, city) = getUser()
    println("$name, $age, $city")

    // Map 순회 시 분해
    val scores = mapOf("국어" to 90, "수학" to 85)
    for ((subject, score) in scores) {
        println("$subject: $score")
    }

    // 람다 파라미터 분해
    scores.forEach { (k, v) -> println("$k=$v") }
}

Kotlin code

fun main() {
    val name = "Kotlin"       // String 추론
    val count = 42            // Int 추론
    val pi = 3.14             // Double 추론
    val isActive = true       // Boolean 추론
    val items = listOf(1, 2)  // List<Int> 추론

    // 제네릭 타입 추론
    val map = mutableMapOf(
        "a" to 1,
        "b" to 2
    )  // MutableMap<String, Int> 추론

    // 함수 반환 타입 추론
    fun double(x: Int) = x * 2  // Int 반환 추론

    println(name::class.simpleName) // String
}

Kotlin code

fun describe(obj: Any): String = when (obj) {
    is String -> "문자열 길이: ${obj.length}"
    is Int    -> "정수의 2배: ${obj * 2}"
    is List<*> -> "리스트 크기: ${obj.size}"
    else       -> "알 수 없는 타입"
}

fun safeCast(value: Any) {
    // as? 안전 캐스트 (실패 시 null)
    val str: String? = value as? String
    println(str?.uppercase() ?: "문자열 아님")

    // 스마트 캐스트 + 조건 결합
    if (value is String && value.length > 5) {
        println("긴 문자열: $value")
    }
}

fun main() {
    println(describe("Hello"))
    println(describe(42))
    safeCast("Kotlin")
}

Kotlin code

data class Address(val city: String?)
data class User(val name: String, val address: Address?)

fun process(user: User?) {
    // 안전 호출 체이닝
    val city = user?.address?.city ?: "알 수 없음"
    println("도시: $city")

    // let으로 null이 아닐 때만 실행
    user?.address?.city?.let { c ->
        println("확인된 도시: $c")
    }

    // also와 결합
    user?.also {
        println("사용자: ${it.name}")
    } ?: println("사용자 없음")
}

fun main() {
    process(User("김철수", Address("서울")))
    process(User("이영희", null))
    process(null)
}

Kotlin code

enum class Direction(val dx: Int, val dy: Int) {
    NORTH(0, -1),
    SOUTH(0, 1),
    EAST(1, 0),
    WEST(-1, 0);

    fun opposite(): Direction = when (this) {
        NORTH -> SOUTH
        SOUTH -> NORTH
        EAST  -> WEST
        WEST  -> EAST
    }
}

fun main() {
    val dir = Direction.EAST
    println("${dir.name}: dx=${dir.dx}, dy=${dir.dy}")
    println("반대: ${dir.opposite()}")

    // values()와 valueOf()
    Direction.entries.forEach { println(it) }
    val south = Direction.valueOf("SOUTH")
    println("ordinal: ${south.ordinal}")
}

Kotlin code

// Top-level 상수
const val MAX_RETRY = 3
const val API_URL = "https://api.example.com"

class Config {
    companion object {
        const val TIMEOUT = 5000L
        val SUPPORTED_TYPES = listOf("json", "xml")

        fun isValid(type: String) =
            type in SUPPORTED_TYPES
    }
}

fun main() {
    println("Max retry: $MAX_RETRY")
    println("Timeout: ${Config.TIMEOUT}")
    println("json valid: ${Config.isValid("json")}")
}

Kotlin code

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class Logged(val tag: String = "DEFAULT")

@Logged(tag = "SERVICE")
fun processOrder(id: Int): String {
    return "주문 $id 처리 완료"
}

fun main() {
    val func = ::processOrder
    val annotation = func.annotations
        .filterIsInstance<Logged>()
        .firstOrNull()

    annotation?.let {
        println("태그: ${it.tag}")
    }

    // @JvmStatic, @JvmOverloads 등 Java 연동
    println(processOrder(42))
}

Kotlin code

typealias StringMap = Map<String, String>
typealias Predicate<T> = (T) -> Boolean
typealias UserCallback = (name: String, age: Int) -> Unit
typealias NodeSet = Set<Network.Node>

class Network {
    class Node(val id: String)
}

fun filter(list: List<Int>, pred: Predicate<Int>): List<Int> =
    list.filter(pred)

fun main() {
    val headers: StringMap = mapOf("Content-Type" to "application/json")
    val isEven: Predicate<Int> = { it % 2 == 0 }

    println(filter(listOf(1, 2, 3, 4), isEven))
    println(headers)
}

Kotlin code

data class Vector(val x: Double, val y: Double) {
    operator fun plus(other: Vector) =
        Vector(x + other.x, y + other.y)
    operator fun times(scalar: Double) =
        Vector(x * scalar, y * scalar)
    operator fun unaryMinus() = Vector(-x, -y)
    operator fun get(index: Int) = when (index) {
        0 -> x; 1 -> y
        else -> throw IndexOutOfBoundsException()
    }
}

fun main() {
    val a = Vector(1.0, 2.0)
    val b = Vector(3.0, 4.0)

    println(a + b)       // Vector(4.0, 6.0)
    println(a * 2.5)     // Vector(2.5, 5.0)
    println(-a)          // Vector(-1.0, -2.0)
    println(a[0])        // 1.0
}

Kotlin code

// internal: 같은 모듈 내에서만 접근
internal class DatabaseConfig(
    private val host: String,
    private val port: Int
) {
    // protected: 하위 클래스에서 접근
    protected open fun connectionString() =
        "$host:$port"

    // public (기본): 어디서나 접근
    fun connect() {
        println("연결: ${connectionString()}")
    }
}

// Top-level private: 같은 파일 내에서만
private fun secretHelper() = "비밀 도우미"

// Top-level internal: 같은 모듈 내에서만
internal val sharedConfig = mapOf("env" to "prod")

fun main() {
    val db = DatabaseConfig("localhost", 5432)
    db.connect()
}

Kotlin code

import kotlin.properties.Delegates

class UserSettings {
    // lazy: 첫 접근 시 초기화
    val config: Map<String, String> by lazy {
        println("설정 로드 중...")
        mapOf("theme" to "dark", "lang" to "ko")
    }

    // observable: 변경 감지
    var fontSize: Int by Delegates.observable(14) { _, old, new ->
        println("폰트 크기: $old → $new")
    }

    // vetoable: 변경 거부 가능
    var volume: Int by Delegates.vetoable(50) { _, _, new ->
        new in 0..100  // 범위 밖이면 거부
    }
}

fun main() {
    val s = UserSettings()
    println(s.config["theme"])
    s.fontSize = 18
    s.volume = 200  // 거부됨
    println("Volume: ${s.volume}") // 50
}

Kotlin code

@JvmInline
value class Email(val value: String) {
    init {
        require(value.contains("@")) { "유효하지 않은 이메일" }
    }
    val domain: String get() = value.substringAfter("@")
}

@JvmInline
value class UserId(val id: Long)

fun sendMail(to: Email, from: Email) {
    println("${from.value} → ${to.value}")
}

fun main() {
    val email = Email("user@example.com")
    println("도메인: ${email.domain}")

    // 타입 안전: UserId와 Long을 혼동할 수 없음
    val userId = UserId(12345L)
    // sendMail(userId, email) // 컴파일 오류!
    sendMail(email, Email("admin@example.com"))
}

Kotlin code

// 로깅 컨텍스트
interface Logger {
    fun log(message: String)
}

// 트랜잭션 컨텍스트
interface Transaction {
    fun execute(sql: String)
}

class ConsoleLogger : Logger {
    override fun log(message: String) = println("[LOG] $message")
}

// context(Logger)를 사용하면 Logger 스코프에서만 호출 가능
// Kotlin 2.0+ 문법 (실험적)
fun Logger.saveUser(name: String) {
    log("사용자 저장: $name")
    println("DB에 $name 저장 완료")
}

fun main() {
    val logger = ConsoleLogger()
    with(logger) {
        saveUser("김철수")
    }
}

Kotlin code

import kotlin.contracts.*

@OptIn(ExperimentalContracts::class)
fun requireNotEmpty(value: String?): String {
    contract {
        returns() implies (value != null)
    }
    if (value.isNullOrEmpty()) {
        throw IllegalArgumentException("값이 비어있습니다")
    }
    return value
}

@OptIn(ExperimentalContracts::class)
inline fun <R> executeOnce(block: () -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

fun main() {
    val input: String? = "Hello"
    val result = requireNotEmpty(input)
    // 여기서 result는 non-null로 스마트 캐스트됨
    println(result.length)

    val value: Int
    executeOnce { value = 42 }
    println(value) // 초기화 보장됨
}

Kotlin code

// commonMain - 공통 코드
expect fun platformName(): String
expect class UUID {
    fun asString(): String
}

// 공통 비즈니스 로직
fun greet(): String {
    return "Hello from ${platformName()}!"
}

// jvmMain - JVM 구현
actual fun platformName(): String = "JVM"
actual class UUID(private val value: java.util.UUID) {
    actual fun asString(): String = value.toString()
}

// 사용 예시 (공통)
fun main() {
    println(greet())
    println("플랫폼: ${platformName()}")
}

Kotlin code

// 커스텀 어노테이션 정의
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.SOURCE)
annotation class AutoBuilder

// @AutoBuilder 적용
@AutoBuilder
data class UserDto(
    val name: String,
    val email: String,
    val age: Int = 0
)

// KSP가 생성할 빌더 (개념 예시)
// class UserDtoBuilder {
//     var name: String = ""
//     var email: String = ""
//     var age: Int = 0
//     fun build() = UserDto(name, email, age)
// }

fun main() {
    val user = UserDto(
        name = "김철수",
        email = "kim@example.com",
        age = 30
    )
    println(user)
}