코틀린 기본기 정리

변수 선언

• val -> 불변(immutable, final과 유사)
• var -> 가변(mutable)

val name = "John" // 불변
var age = 20 // 변경 가능
age = 30
// name = "Jane" // 에러

널 안정성 (Nullable vs Non-nullable)

• 코틀린은 null을 허용하는 변수(? 사용)와 허용하지 않는 변수를 명확하게 구분한다.

var a: String = "abc"
a = null // 에러

var b: String? = "abc"
b = null // 가능

// 안전한 호출
println(b?.length) // b가 null이면 null 반환

문자열 템플릿

• 코틀린은 + 연산자 대신 문자열 보간(string interpolation) 사용 가능

val name = "John"
val age = 30

println("My name is $name and I am $age years old")
println("Next year I will be ${age + 1} years old")

클래스와 생성자

• 기본적으로 모든 클래스는 final (상속 불가)
• 상속하려면 open 키워드 필요
• 기본 생성자는 클래스 생성부에 작성

// 기본 생성자
class Person(val name: String, var age: Int) {}

// 인스턴스 생성
val person = Person("John", 30)
println(person.name) // John
println(person.age) // 30


// val은 getter만, var은 getter와 setter 모두 생성
persion.age = 31
println(person.age) // 31

• 필드 정의와 생성자를 한 번에 작성 가능
• Getter, Setter 자동 생성 (val은 getter만, var은 getter와 setter 모두 생성)

상속 open 필요

open class Animal(val name: String) {
    open fun makeSound() {
        println("Some sound")
    }
}

class Dog(name: String) : Animal(name) {
    override fun makeSound() {
        println("Bark")
    }
}

• 명확한 상속 구조 (open, override)
• 자바의 abstract class와 유사하지만 더 엄격함.

데이터 클래스

• DTO, VO 같은 객체를 만들 때 자동으로 toString(), equals(), hashCode() 제공

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

val user1 = User("John", 30)
val user2 = User("John", 30)

println(user1) // User(name=John, age=30)
println(user1 == user2) // true (equals() 자동 생성)

함수 선언

• fun 키워드 사용
• 반환 타입 명시 (추론 가능하면 생략 가능)
• 한 줄 함수는 = 사용

fun sum(a: Int, b: Int): Int {
    return a + b
}

// 한 줄 함수, 반환 타입 생략
fun sum(a: Int, b: Int) = a + b

• public이 기본값이므로 생략 가능
• 함수형 프로그래밍 스타일 지원 (= 표현 가능)

기본 인자값 & 네임드 파라미터

• 자바는 인자가 다를 경우, 오버로딩으로 여러 메서드를 만들어야 하지만 코틀린은 기본값을 제공 가능

fun greet(name: String, message: String = "Hello") {
    println("$message, $name!")
}

// 호출 방법
greet("Alice") // Hello, Alice!
greet("Alice", "Hi") // Hi, Alice!

• 메서드 오버로딩을 줄일 수 있음
• 가독성 개선

// 명시적 호출 가능
greet(message = "Hi", name = "Alice") // Hi, Alice!

• 파라미터 이름을 명시하면 순서 변경 가능

확장 함수

• 기존 클래스에 메서드를 추가할 수 있음 (클래스 수정 불필요)

fun String.hello() {
    println("Hello, $this")
}

"John".hello() // Hello, John

• 유틸리티 메서드를 선언할 때 유용

고차 함수 & 람다

• 함수를 변수처럼 다룰 수 있음.

fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int {
    return op(a, b)
}

val sum = operate(3, 4) { x, y -> x + y }
println(sum) // 7

• 콜백 함수, 함수형 스타일로 유연한 코드 작성 가능

when 표현식 (switch 대체)

switch 보다 강력한 when 표현식

fun getColor(color: String): String {
    return when (color) {
        "red" -> "빨강"
        "blue" -> "파랑"
        "green" -> "초록"
        else -> "알 수 없음"
    }
}

// 범위 검사
fun getScore(score: Int): String {
    return when (score) {
        in 90..100 -> "A"
        in 80..89 -> "B"
        in 70..79 -> "C"
        else -> "F"
    }
}

// 타입 검사
fun getColor(color: Any): String {
    return when (color) {
        is String -> "문자열"
        is Int -> "정수"
        else -> "알 수 없음"
    }
}

• 범위(in), 타입 검사 가능
• break 불필요, 안전함

싱글톤 (object 키워드)

• object 키워드 하나로 싱글톤 클래스 구현 가능

object Singleton {
    fun doSomething() {
        println("I'm a singleton!")
    }
}

Singleton.doSomething() // I'm a singleton!

자바의 static 키워드 대체 가능

코루틴 (Coroutine)

• 코루틴은 async/await 대신 suspend로 비동기 처리 지원

import kotlinx.coroutines.*

suspend fun fetchData(): String {
    delay(1000) // 비동기 대기
    return "Data loaded"
}

fun main() = runBlocking {
    println(fetchData())
}

• Spring @Async보다 가볍고 강력
• 스레드 블로킹 없이 비동기 처리 가능