개발 일기

Java와 다른 Kotlin의 인터페이스

Hui._. — Fri, 9 Jan 2026 13:42:02 +0900

서론: 자바 개발자가 코틀린을 공부하면서

코틀린을 공부하면서 자바와는 다른 방식으로 인터페이스를 활용하는 점이 상당히 생소하게 느껴졌습니다. 자바의 인터페이스는 주로 구현해야 할 메서드를 정의하는 추상적인 설계도, 즉 규격의 역할을 담당합니다.

예를 들어 Spring AOP를 적용할 때 특정 인터페이스 기준으로 Aspect를 설정하고, 해당 인터페이스를 구현한 클래스들에만 선택적으로 공통 로직을 적용하는 용도로 활용할 수 있습니다. 이 경우 인터페이스는 구조를 식별하기 위한 경계로 사용됩니다.

반면 코틀린의 인터페이스는 이러한 규격의 역할에 머무르지 않습니다. 자바의 인터페이스는 "무엇을 구현해야 하는가"에 초점을 맞췄다면 코틀린의 인터페이스는 어떤 행위를 조합할 수 있는 가에 초첨을 두어 한 단계 확장되었습니다.

특히 OAuth2를 구현 함에 있어 코틀린의 인터페이스를 적극적으로 활용할 수 있습니다.

자바 방식

자바에서 OAuth2를 구현하면 다음과 같은 흐름일 것입니다.

1. `OAuth2UserInfo` 인터페이스를 만든다.

2. `OAuth2UserInfo`를 implements한 `GoogleUserInfo`, `NaverUserInfo` 클래스를 만든다.

3. 각 클래스에서 `getEmail()`, `getName()`등 직접 구현한다.

위 방식의 단점은 중복입니다. 구글이나 네이버의 데이터를 가져와서 정제하는 로직이 비슷해도, 각각 클래스 안에 중복해서 코드를 짜야 합니다. 아니면 중복을 피하기 위해 `Provider` 클래스를 생각할 수 있습니다. 그러나 해당 클래스에 각 서비스 별 메서드를 선언해야 한다는 점은 피할 수 없습니다.

코틀린 방식

코틀린의 핵심은 `by` 키워드를 이용한 위임입니다. 만약 OAuth2의 JSON 응답을 파싱하는 로직이 담긴 `Map` 기반의 구현체가 있다고 가정해 봅시다.

// 공통 규격 선언
interface OAuth2UserInfo {
    val attributes: Map<String, Any>
    fun getEmail(): String
    fun getName(): String
}

// 공통 로직을 담은 구현체
class DefaultOAuth2UserInfo(
	override val attributes: Map<String, Any>
) : OAuth2UserInfo {
    override fun getEmail() = attributes["email"] as? String ?: ""
    override fun getName() = attributes["name"] as? String ?: ""
}

// 실제 서비스별 구현 (직접 구현하지 않고 위임)
class GoogleUserInfo(
    attributes: Map<String, Any>
) : OAuth2UserInfo by DefaultOAuth2UserInfo(attributes) {
    // 추가로 구글에만 특화된 로직이 필요할 때만 override
    override fun getName() = TODO(...)
}

이 방식을 사용하면 `GoogleUserInfo`는 `getEmail()`을 직접 구현하지 않아도 외부에서 이를 호출할 수 있습니다. 상속의 제약(단일 상속)에서 벗어나 여러 개의 구현체를 내 것처럼 조립할 수 있게 되었습니다.

조립의 의미

코틀린의 인터페이스는 로직(Default Method)를 가질 수 있으며, 추상 프로퍼티를 정의할 수 있습니다. 이는 마치 필요한 기능을 블록처럼 클래스에 붙이는 경험을 제공합니다.

interface Validatable {
    fun validateEmail(email: String) = email.contains("@")
}

interface Loggable {
    val logTag: String
    fun log(msg: String) = println("log[$logTag]: $msg")
}

// 여러 개의 인터페이스를 조립해서 기능을 확장
class OAuth2Service : Validatable, Loggable {
    override val logTag = "OAuth2Service"
    
    fun process(email: String) {
        if (validateEmail(email) { // Validatable에서 가져온 기능
            log("processing $email") // Loggable에서 가져온 기능
        }
    }
}

자바에서도 위처럼 다중 구현이 가능하지만 인터페이스의 상태에 가까운 프로퍼티를 정의하거나 위임을 사용하는 것이 훨씬 번거롭기 때문에 보통 `Service` 클래스에 모든 로직을 구현하거나, `Util`을 호출하는 방식을 사용했습니다.

하지만 코틀린은 인터페이스로 기능을 쪼개서 조립하는 방식을 권장합니다.

결론: 자바와 코틀린 관점 차이

자바를 주로 사용했던 개발자 입장에서 코틀린의 프로젝트의 인터페이스의 사용은 어색할 수 있습니다. 하지만 상속보다는 조립이라는 현대적인 객체지향 철학이 담겨있습니다.

자바에서 공통 로직의 중복을 피하기 위해 추상 클래스를 설계하거나 별도의 클래스로 로직을 빼서 관리했다면, 코틀린은 인터페이스 위임을 통해 모든 과정을 더 유연하게 구현할 수 있습니다. 인터페이스를 단순한 껍데기로 보는 것이 아닌 클래스에 강력한 기능을 부여하는 도구로 봐야 합니다.

구분	자바 인터페이스	코틀린 인터페이스
주요 역할	강제된 규격, 구조 식별 (AOP)	기능의 위임 및 조립
중복 해결	추상 클래스 상속 또는 별도 Provider	`by` 키워드를 통한 위임
상태/로직	상수만 가능, default 메서드 활용	추상 프로퍼티, 풍부한 기본 구현
설계 철학	추상적인 설계도	장착, 조합

[Kotlin in action 2/e] 코틀린 타입 시스템

Hui._. — Wed, 7 Jan 2026 10:13:02 +0900

Kotlin in Action 2/e 서적을 읽으면서 정리하고자 쓴 글입니다.

kotlin logo

널 가능성

코틀린을 비롯한 최신 언어는 `null`에 대한 문제를 런타임 시점에서 컴파일 시점으로 옮겼습니다. 널이 될 수 있는지 확인하는 타입 시스템을 추가함으로써 컴파일러가 여러 가지 오류를 컴파일 시 미리 감지하여 런타임에 발생할 수 있는 예외 가능성을 줄일 수 있습니다.

안전한 호출 연산자(Safe Call Operator): ?.

`?.`는 `null` 검사와 메서드 호출을 한 번의 연산으로 수행합니다. 왼쪽 값이 `null`이면 즉시 `null`을 반환하고, `null`이 아닐 때만 오른쪽을 실행합니다.

s?.toUpperCase() // s 문자열 대문자 변환 (아래와 동일하게 동작한다.)
if (s != null) s.toUpperCase() else null

class Address(val country: String)
class Company(val address: Address?)
class Person(val company: Company?)

fun Person.countryName(): String =
    this.company?.address?.country ?: "Unknown"

fun main() {
    val person = Person(null)
    println(person.countryName())  // Unknown
}

`company` 또는 `address`가 `null`이면 전체 표현식은 `null` 임으로 "Unknown"이 출력됩니다. 이처럼 `?.` 연산자를 통해 다른 추가 검사 없이 `Person`의 회사 주소의 `country` 프로퍼티를 단 한 줄로 가져올 수 있습니다.

엘비스 연산자(Elvis Operator): ?:

코틀린은 `null` 대신 사용할 디폴트 값을 지정할 때 편리하게 사용할 수 있는 연산자를 제공합니다.

val result = value ?: "default" // 왼쪽 값이 null이면 오른쪽 "default" 반환

코틀린은 `return`, `throw`도 식이기 때문에 엘비스 연산자 우항에 사용할 수 있습니다.

val address = person.company?.address
    ?: throw IllegalArgumentException("No address")

class Address(
    val streetAddress: String,
    val zipCode: Int,
    val city: String,
    val country: String
)

class Company(val address: Address?)
class Person(val company: Company?)

fun printShippingLabel(person: Person) {
    val address = person.company?.address
        ?: throw IllegalArgumentException("No address")

    with(address) {
        println(streetAddress) // this.streetAddress (this 생략)
        println("$zipCode $city, $country")
    }
}

위 예제를 보면 `company` 또는 `address`가 `null`이면 `IllegalArgumentException` 발생되고, `null`이 아니면 정상 출력됩니다.

안전한 캐스트 (Safe Cast) as?

`as?`는 값을 지정한 타입으로 변환을 시도하고, 변환할 수 없으면 예외 대신 `null`을 반환하는 연산자입니다.

val person = obj as? Person // 캐스트 성공 시 Person 타입, 실패 시 null

class Person(
    val firstName: String,
    val lastName: String
) {
    override fun equals(other: Any?): Boolean {
        val otherPerson = other as? Person ?: return false
        return otherPerson.firstName == firstName &&
               otherPerson.lastName == lastName
    }

    override fun hashCode(): Int =
        firstName.hashCode() * 37 + lastName.hashCode()
}

fun main() {
    println(p1 == p2) // true
    println(p1.equals(42)) // false
}

널 아님 단언(Not-null Assertion): !!

`!!`는 nullable 타입을 강제로 non-null 타입으로 변환하는 연산자입니다.

val sNotNull: String = s!! // 값이 not null이면 정상 동작, null이면 NPE 발생

fun ignoreNulls(s: String?) {
    val sNotNull: String = s!!
    println(sNotNull.length) // s가 null이면 NPE 발생
}

`!!`는 컴파일러의 `null` 안정성을 우회합니다. 즉, 개발자가 "여기서는 절대 null이 아니다."라고 강제 단언하는 것이기 때문에 사용에 있어 주의가 필요합니다.

또한 아래와 같이 여러 개의 `!!`를 한 줄에 사용하는 경우, 어디서 NPE가 발생했는지 파악하기 어렵고, 유지보수 시 위험성이 커지기 때문에 권장하지 않습니다.

person.company!!.address!!.country  // 권장하지 않음

let 함수

`let`은 객체를 람다의 인자로 전달하여 블록을 실행하는 범위 함수입니다. 특히 nullable 타입과 함께 사용할 때 많이 쓰입니다.

email?.let { sendEmailTo(it) }

`email`이 `not-null`이면 블록을 실행하고, `null`이면 아무것도 실행되지 않습니다.

fun sendEmailTo(email: String) {
    println("Sending email to $email")
}

fun main() {
    var email: String? = "yole@example.com"

    email?.let { sendEmailTo(it) } // 실행됨

    email = null
    email?.let { sendEmailTo(it) } // 실행되지 않음
}

`?.` 연산자와 함께 사용하면 `null` 체크와 값 사용을 한 번에 처리할 수 있습니다.

만약 여러 값을 동시에 `null` 검사가 필요한 경우 `let` 중첩으로 사용하면 가독성이 떨어질 수 있습니다. 이러한 경우는 일반적인 `if`문을 사용하는 것이 더 명확합니다.

a?.let { aa ->
    b?.let { bb ->
        // 복잡해짐
    }
}

if (a != null && b != null) {
    // 처리
}

나중에 초기화할 프로퍼티 lateinit

코틀린은 기본적으로 모든 `non-null` 프로퍼티를 생성자에서 초기화해야 합니다.

class Example(val name: String)

테스트 코드나 DI 환경에서는 생성자가 아니라 별도의 메서드에서 초기화해야 하는 경우가 있습니다.

class MyTest {

    private var myService: MyService? = null

    @Before
    fun setUp() {
        myService = MyService()
    }

    @Test
    fun testAction() {
        myService!!.performAction() // !! 필요
    }
}

위처럼 nullable 타입을 사용해야 하고, 매번 `!!` 또는 `?.` 연산자가 사용해야 하는 문제가 생기게 됩니다. 이를 해결하기 위한 방법으로 `lateinit`를 사용하면 초기화를 나중에 미루면서도 `non-null` 타입을 유지할 수 있습니다.

class MyTest {

    private lateinit var myService: MyService // lateinit 추가

    @Before
    fun setUp() {
        myService = MyService()
    }

    @Test
    fun testAction() {
        myService.performAction()  // null 검사 불필요
    }
}

이제 `null`이 될 수 없는 타입이라 해도 더 이상 생성자 안에서 초기화할 필요가 없어졌습니다.

코틀린의 원시 타입

코틀린은 자바와 달리 원시 타입(primitive)과 래퍼 타입(wrapper)을 구분하지 않습니다.

// Java: 원시/래퍼 타입으로 나뉨
int a = 10; <-> Integer a = 10;

// Kotlin: 항상 동일한 타입 사용
val a: Int = 10

코틀린은 실행 시점에서 가능한 한 가장 효율적인 방식으로 컴파일됩니다. 즉, nullable 여부에 따라 원시 타입을 쓸지 래퍼 타입을 쓸지 결정됩니다.

nullable이 아닌 `Int` → `int`
nullable인 `Int?` → `Integer`

코틀린은 원시 타입도 메서드를 가질 수 있습니다.

fun showProgress(progress: Int) {
    val percent = progress.coerceIn(0, 100)
    println("We're ${percent}% done!")
}

자바의 `int`는 메서드를 가질 수 없지만 코틀린의 `Int`는 확장 함수 및 멤버 함수를 사용할 수 있습니다.

숫자 변환

코틀린은 숫자 타입을 자동으로 변환하지 않습니다. 자바는 작은 타입에서 큰 타입으로 자동 캐스팅이 가능하지만 코틀린은 명시적 변환이 필요합니다.

// Java
int i = 1;
long l = i; // 자동 변환

// Kotlin
val i = 1
val l: Long = i // 컴파일 오류
val l2: Long = i.toLong() // 정상

Kotlin은 모든 원시 타입에 대해 명시적인 타입 변환 함수를 제공합니다. 변환 함수는 toXxx() 형태로 정의되어 있으며, toByte(), toShort(), toInt(), toLong(), ... 등과 같이 앞에 to를 붙이고 대상 타입명을 사용하는 규칙을 따릅니다.

코틀린은 왜 자동 변환을 허용하지 않을까?

코틀린은 명확성과 타입 안정성을 우선합니다. 자동 변환이 허용되면 예상치 못한 타입 변환이 발생할 수 있으므로 모든 숫자 변환은 명시적으로 수행하도록 설계되었습니다.

Any, Any? 최상위 타입

자바에서 `Object`는 클래스 계층의 최상위 타입이듯 코틀린은 `Any`가 모든 타입의 최상위 타입입니다.

val value: Any = "hello"
val number: Any = 42

val value2: Any? = null
val number2 Any? = null

코틀린은 `Int` 같은 숫자 타입도 `Any`의 하위 타입입니다.

Unit 타입: 코틀린의 void

`Unit`은 자바의 `void`와 같은 역할을 수행합니다. 즉, 의미 있는 값을 반환하지 않는 함수의 반환 타입입니다.

fun printMessage(): Unit {
    println("Hello")
}

// 반환 타입 Unit을 생략할 수도 있다.
fun printMessage() {
    println("Hello")
}

코틀린의 Unit이 자바 void와 다른 점은 무엇일까?

자바의 `void`는 상태이고, 코틀린의 `Unit`은 타입으로 사용됩니다. 즉 `Unit`은 타입 인자로 사용할 수 있으며, 제네릭을 사용할 때 의미가 분명해집니다.

interface Processor<T> {
    fun process(): T
}

// 반환값이 없는 경우에도 Unit 타입을 인자로 넘길 수 있음
class NoResultProcessor : Processor<Unit> {
    override fun process() {
        // logic...
        // 명시적인 return Unit이 없어도 컴파일러가 자동으로 처리합니다.
    }
}

`process()`는 `Unit`을 반환하기 때문에 별도의 `return`이 필요하지 않습니다. 자바의 `void`로는 이런 제네릭 인터페이스를 표현할 수 없습니다.

자바에서도 제네릭에 대응하기 위해 `void`의 래퍼 클래스인 `Void`를 사용할 수 있습니다. 하지만 코틀린의 `Unit`과 사용성 면에 차이점이 있습니다.

	코틀린의 `Unit`	자바의 `Void`
성격	객체가 하나뿐인 싱글톤 타입	인스턴스화할 수 없는 참조 타입
값의 존재	`Unit` 객체가 실재	항상 `null`만 가짐
반환 코드	return 생략 가능	return null; 필수

Nothing 타입: 이 함수는 결코 정상적으로 끝나지 않는다.

코틀린은 결코 성공적으로 값을 돌려주는 일이 없으므로 반환 값이라는 개념 자체가 의미 없는 함수가 존재합니다.

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

val address = company.address ?: fail("No address")
println(address.city)

`Nothing`은 아무 값도 포함하지 않습니다. 따라서 컴파일러는 `Nothing`이 반환 타입인 함수가 결코 정상 종료가 되지 않음을 알고 그 함수를 호출하는 코드를 분석할 때 사용합니다.

컬렉션과 배열

컬렉션과 널 가능성

컬렉션에서도 원소가 `null`이 될 수 있는지 여부는 매우 중요합니다.

fun addValidNumbers(numbers: List<Int?>) {
    var sum = 0
    var invalid = 0

    for (number in numbers) {
        if (number != null) sum += number
        else invalid++
    }

    println("Sum: $sum")
    println("Invalid count: $invalid")
}

`List<Int?>`의 원소를 꺼내면 타입은 `Int?`이므로 사용 전 반드시 `null` 체크가 필요합니다.

코틀린의 표준 라이브러리는 `null` 제거를 위한 `fillterNotNull()`을 제공합니다.

fun addValidNumbers(numbers: List<Int?>) {
    val valid = numbers.filterNotNull() // not-null 값만 할당
    println("Sum: ${valid.sum()}")
    println("Invalid count: ${numbers.size - valid.size}")
}

`null` 제거 후 `Int` 타입으로 안전하게 사용할 수 있게 됐습니다.

읽기 전용 컬렉션 vs 변경 가능 컬렉션

코틀린은 읽기 전용 인터페이스와 변경 가능 인터페이스를 분리합니다.

읽기 전용: `Collection`, `List`, `Set`, `Map`
변경 가능: `MutableCollection`, `MutableList`, `MutableSet`, `MutableMap`

val list: List<String> = listOf("a", "b")
val mutableList: MutableList<String> = mutableListOf("a", "b")

fun main() {
    list.add("c") // 읽기 전용 컬렉션 컴파일 오류 발생
    mutableList.add("c") // 변경 가능 컬렉션 추가 가능
}

코틀린 ↔ 자바 상호운용 시 주의점

사실 모든 코틀린의 컬렉션은 자바 컬렉션입니다. 따라서 코틀린에서 읽기 전용 `List`를 선언해도 자바 코드는 수정이 가능합니다.

// Java
public static List<String> uppercaseAll(List<String> items) {
    for (int i = 0; i < items.size(); i++) {
        items.set(i, items.get(i).toUpperCase());
    }
    return items;
}

// Kotlin
fun printInUppercase(list: List<String>) {
    println(CollectionUtils.uppercaseAll(list))
    println(list.first())  // 이미 변경됨
}

코틀린의 읽기 전용은 컴파일러 수준의 제약이지 진짜 불변을 의미하지는 않습니다.

객체의 배열과 원시 타입의 배열

코틀린의 배열은 제네릭 클래스입니다. 또한 코틀린은 배열을 사용하기 보다 컬렉션을 사용하는 것을 권장합니다.

val arr: Array<String>

val arr = arrayOf("a", "b", "c")

val arr = arrayOfNulls<String>(5) // nullable 타입일 때만 사용 가능

val letters = Array(26) { i ->
    ('a' + i).toString() // 람다를 통해 각 요소 초기화 가능
}

요약

코틀린의 널이 될 수 있는 타입을 지원해 NPE를 컴파일 시점에 감지할 수 있다.
코틀린의 `?.`, `?:`, `!!`, `let` 함수 등을 사용하면 널이 될 수 있는 타입을 간결하게 다룰 수 있다.
`as?`를 사용하면 널이 아닌 경우 다른 타입으로 취급할 수 있다.
코틀린은 원시/래퍼 타입을 구분하지 않는다. JVM 상황에 맞게 원시/래퍼 타입을 쓸지 정해준다.
`Any`는 코틀린의 모든 타입의 조상 타입이며, 자바의 `Object`에 해당한다. 또한 `Unit`은 `void`와 비슷하다.
정상적으로 끝나지 않는 함수의 반환 타입을 지정할 때 `Nothing` 타입을 사용한다.
코틀린의 컬렉션은 자바 컬렉션을 확장해서 사용하며, 읽기 전용, 변경 전용 컬렉션으로 구별하여 제공한다.
플랫폼 타입을 확장하는 경우 널 가능성과 변경 가능성에 대해 깊이 생각해야 한다. (플랫폼 타입은 널 인지 아닌지 컴파일러가 체크하지 않기 때문)
코틀린의 배열은 Array 제네릭 클래스를 사용한다. 또한 컴파일 시 자바 배열로 컴파일된다.

[Kotlin in action 2/e] 람다로 프로그래밍

Hui._. — Wed, 31 Dec 2025 11:13:35 +0900

Kotlin in Action 2/e 서적을 읽으면서 정리하고자 쓴 글입니다.

kotlin logo

람다 식과 멤버 참조

람다와 컬렉션

코틀린은 람다를 보다 직관적으로 사용할 수 있으며, 간결한 코드를 작성할 수 있습니다.

fun findTheOldest(peoples: List<Person>) {
    var maxAge = 0
    for (person in peoples) {
        if (person.age > maxAge) {
            maxAge = person.age
        }
    }
    return maxAge
}
fun main() {
    val peoples = listOf(Person("A", 10), Person("B", 15))
    println(findTheOlest(peoples)) // 15
}

fun main() {
    val peoples = listOf(Person("A", 10), Person("B", 15))
    println(peoples.maxByOrNull {it.age}) // 15
}

현재 영역에 있는 변수에 접근

자바에서 익명 내부 클래스를 사용할 때, 외부 메서드의 로컬 변수가 `final`이 아니면 사용할 수 없습니다. 그러나 코틀린은 `final`이 아닌 변수에도 접근할 수 있으며, 그 값을 바꿀 수도 있습니다.

fun printProblemCouns(response: Collection<String>) {
    var clientErrors = 0 // final이 아닌 변수 var
    var serverErrors = 0
    response.forEach {
    	if (it.startsWith("4") {
        	clientErrors++ // 람다 내에서 외부 변수 수정 가능
        } else if (it.startsWith("5") {
        	serverErrors++
        }
    }
    println("$clientErrors client errors, $serverErrors server errors") 
}

어떻게 그런 동작이 가능한 것일까?

코틀린 컴파일러는 `var` 변수를 람다 안에 수정하려고 할 때 래퍼(Wrapper)라는 기법을 사용하게 됩니다.

`val`: 변수 값을 람다 코드에 함께 저장합니다. (자바와 유사)
`var`: 변수를 직접 저장하는 대신, 그 변수를 담고 있는 특별한 객체를 만듭니다. 람다는 이 객체를 참조하며 람다 안에서도 외부 변수를 수정할 수 있는 것처럼 보이게 됩니다.

다만, 주의할 점이 있습니다. 변수를 공유할 수 있다고 해서 항상 최신 값을 얻을 수 있는 것은 아닙니다. 특히 비동기 코드나 이벤트 핸들러에서 문제가 발생합니다.

fun tryToCountButtonClicks(button: Button): Int {
    var clicks = 0
    button.onClick { clicks++ } // 버튼이 클릭될 때 실행될 '약속'만 하고 함수는 바로 아래로 진행됨
    return clicks // 버튼이 클릭되기도 전에 0을 반환해버림!
}

`onClick` 핸들러는 호출될 때마다 `clicks`의 값을 증가시키지만 그 값의 변경을 관찰할 수는 없습니다. 핸들러는 `tryToCountButtonClicks`가 `clicks`를 반환한 다음에 호출되기 때문입니다.

컬렉션 함수형 API

필수적인 함수: filter와 map

`filter` 함수는 컬렉션에서 조건에 맞지 않는 원소를 걸러내는 역할을 합니다. 즉, 원소의 개수를 줄일 수 있지만 각 소 자체를 변경하지 않습니다. 반면, 원소를 다른 형태로 변환해야 할 경우 `map` 함수를 사용합니다. `map` 함수는 주어진 람다를 컬렉션의 각 원소에 적용하고, 그 결과를 모아 새로운 컬렉션을 생성합니다.

fun main() {
    val people = listOf(Person("Alice", 10), Person("Bob", 31))
    
    val adults = people.filter { it.age > 30 })
    println(adults) // [Person(name=Bob, age=31)]
    
    val names = people.map { it.name }
    println(names) // [Alice, Bob]
    
    val numbers = mapOf(0 to "zero", 1 to "one")
    val upperNumbers = numbers.mapValues { it.value.uppercase() }
    println(upperNumbers) // {0=ZERO, 1=ONE}
}

컬렉션에 술어 적용: all, any, count, find

컬렉션에 대해 자주 수행하는 연산으로 컬렉션의 모든 원소가 어떤 조건에 만족하는지 판단하는 연산이 있습니다.

// Person을 받아 Boolean을 반환 (27세 이하)
val canBeIn27: (Person) -> Boolean = { person -> person.age <= 27 }

fun main() {
    val people = listOf(Person("Alice", 27), Person("Bob", 31))
    
    val all = people.all(canBeIn27) // 모든 사람이 canBeIn27 조건에 만족해야 true
    println(all) // false 
    
    val any = people.any(canBeIn27) // 하나라도 만족하면 true
    println(any) // true
    
    val count = people.count(canBeIn27) // 조건을 만족하는 원소의 개수
    println(count) // 1
    
    val find = people.find(canBeIn27) // 조건을 만족하는 첫번째 원소
    println(find) // Person(name=Alice, age=27)
}

함수	반환 타입	의미
`all`	Boolean	모두 만족하는가
`any`	Boolean	하나라도 만족하는가
`count`	Int	몇 개가 만족하는가
`find`	T?	처음으로 만족하는 원소

중첩된 컬렉션 안의 원소 처리: flatMap과 flatten

중첩된 컬렉션을 다룰 때 자주 필요한 작업은 안쪽 컬렉션의 원소를 한 번에 처리하는 것입니다. 코틀린은 이를 위해 `flatMap`과 `flatten` 함수를 제공합니다.

`flatMap` 함수는 컬렉션의 각 원소에 주어진 람다를 적용해 또 다른 컬렉션을 생성한 뒤, 그 결과로 만들어진 여러 개의 컬렉션을 하나의 컬렉션으로 평탄화합니다. 즉, `flatMap`은 `map`과 `flatten`을 결합한 연산입니다.

fun main() {
    val strings = listOf("abc", "def")
    
    // 각 문자열을 List<Char>로 변환한 뒤 하나의 리스트로 합침
    println(strings.flatMap { it.toList() }) // [a, b, c, d, e, f]
}

각 문자열을 리스트로 변환(`map`)하고, 그 결과를 생성된 중첩 리스트에 하나의 리스트로 합칩니다(`flatten`).

`flatMap`은 객체 내부에 컬렉션을 포함하는 구조에서도 유용하게 사용할 수 있습니다.

data class Book(val title: String, val authors: List<String>)
fun main() {
    val books = listOf(
        Book("Thursday Next", listOf("Jasper Fforde")),
        Book("Mort", listOf("Terry Pratchett")),
        Book("Good Omens", listOf("Terry Pratchett", "Neil Gaiman"))
    )
    
    // 각 책의 저자 목록을 하나의 컬렉션으로 합친뒤 중복 제거
    val result = books.flatMap { it.authors }.toSet()
    println(result) // [Jasper Fforde, Terry Pratchett, Neil Gaiman]
}

반면 `flatten` 함수는 이미 중첩된 컬렉션이 있을 때, 별도의 변환 없이 이를 하나의 컬렉션으로 펼치는 역할만 수행합니다.

지연 연산(lazy) 컬렉션 연산

일반적으로 `List`, `Set` 등에서 `map`이나 `filter`를 연결하면 즉시 계산 방식이 적용됩니다. 즉, 수평적 처리를 의미하며 각 단계마다 연산 결과를 담는 임시 컬렉션이 생성됩니다.

val list = listOf(1, 2, 3, 4)
val result = list
    .map { it * it } // 1단계: [1, 4, 9, 16] 생성
    .filter { it % 2 == 0 } // 2단계: [4, 16] 생성

1단계에서 모든 원소를 순회하며 제곱한 뒤, 새로운 리스트 `[1, 4, 9, 16]`을 생성합니다. 이후 2단계에서 만들어진 리스트를 다시 순회하며 조건에 맞는 원소만 골라 또 다른 리스트 `[4, 16]`을 만듭니다.

시퀀스 연산 실행: 중간 연산과 최종 연산

이와 달리 지연 연산(lazy) 은 시퀀스를 기반으로 하며, 중간 결과 컬렉션을 생성하지 않고 각 원소를 단위로 연산 체인을 끝까지 처리하는 수직적 방식으로 동작합니다.

val list = listOf(1, 2, 3, 4)
val result = list.asSequence() // 
    .map { it * it }
    .filter { it % 2 == 0 }
    .toList() // 최종 연산 (이때 모든 계산이 시작)

원소 1부터 순서대로 `map` → `filter` 적용하여 탈락(1은 탈락), 원소 2 `map` → `filter` 적용(4는 합격),... 이러한 방식으로 원소 하나하나 끝까지 통과한 뒤 다음 원소로 넘어가는 구조입니다.

시퀀스 연산은 크게 2가지 종류로 나뉩니다.

중간 연산: `map`, `filter` 등 다른 시퀀스를 반환하며, 실제 계산은 수행하지 않고 어떻게 계산할지에 대한 설계도만 가집니다.
최종 연산: `toList()`, `find()`, `sum()`, `forEach()` 등 시퀀스를 다시 컬렉션으로 바꾸거나 구체적인 값을 얻는 연산으로 호출되는 순간에만 모든 계산이 시작됩니다.

왜 시퀀스를 다시 컬렉션으로 되돌려야 할까?

시퀀스는 데이터를 직접 저장하지 않는 계산 설계도와 같으므로, 인덱스 접근이나 데이터 재사용, 그리고 기존 리스트 기반 API와의 호환성을 위해 실제 데이터 저장소인 컬렉션으로 변환하여 사용합니다.

일반 컬렉션과 지연 연산 어떻게 사용해야 할까?

일반 컬렉션은 소규모 데이터에서 빠른 속도를 보장하지만 중간 결과물로 인한 메모리 부담이 큰 반면, 시퀀스는 대규모 데이터나 복잡한 연산에서 임시 컬렉션 없이 메모리를 아끼고 최적화된 처리가 가능하므로 데이터의 양과 연산 단계에 맞춰 선택하는 것이 좋습니다.

구분	일반 컬렉션 (Eager)	시퀀스 (Lazy)
연산 방식	모든 원소에 대해 단계별 수행 (수평)	각 원소 하나씩 전체 체인 통과 (수직)
중간 결과물	매 단계마다 새로운 컬렉션 생성	생성 안함 (메모리 효율적)
적합한 상황	데이터 양이 적고, 속도가 중요할 때	데이터 양이 아주 많거나 무한할 때
최종 연산	필요 없음 (즉시 실행)	반드시 필요 (최종 연산 시점에 실행)

자바 스트림(Java Stream)과의 비교
코틀린의 시퀀스는 자바 8의 스트림과 거의 유사합니다. 하지만 결정적인 차이가 있습니다. 병렬 처리: 자바 스트림은 parallelStream()을 통해 여러 CPU 코어를 활용한 병렬 연산이 가능하지만, 코틀린 시퀀스는 현재 직렬(Sequential) 처리만 지원합니다. 병렬 처리가 필요하다면 자바 스트림을 사용하거나 코루틴을 활용해야 합니다.

자바 함수형 인터페이스 활용

자바 메서드에 람다를 인자로 전달

함수형 인터페이스를 인자로 받는 자바 메서드에 코틀린 람다를 전달할 수 있습니다. 이때 객체 식을 사용하는 것과 람다를 사용하는 것에는 성능 상 차이가 있습니다.

객체 식 `object : ..`: 메서드를 호출할 때마다 새로운 객체가 생성
람다: 정의된 함수의 변수에 접근하지 않는 람다는 메서드 호출 시마다 대응하는 무명 객체를 반복 사용

// 객체 식: 호출 시마다 매번 새로운 인스턴스 생성
postponeComputation(1000, object : Runnable {
    override fun run() { println(42) }
})

// 람다: 변수를 포획하지 않으므로 프로그램 전체에서 인스턴스가 단 하나만 생성
postponeComputation(1000) { println(42) }

변수 포획 시의 동작

람다가 주변 영역의 변수를 포획한다면 매 호출마다 같은 인스턴스를 사용할 수 없습니다. 이 경우 컴파일러는 주변 변수를 포획한 새로운 인스턴스를 매번 생성하여 전달합니다.

fun handlerComputation(id: String) {
    // id를 포획하므로 호출할 때마다 새로운 Runnable 인스턴스가 생성
    postponeComputation(1000) { println(id) }
}

객체 식과 람다 그래서 결론은?

코틀린의 람다는 내부적으로 무명 클래스로 컴파일되는데, 외부 변수를 포획하지 않을 때는 단 하나의 싱글톤 인스턴스만 생성하여 재사용함으로써 효율을 높이지만, 변수를 포획할 경우 상태 저장을 위한 필드가 추가된 객체를 매번 새로 생성하는 비용이 발생합니다. 다만, `inline` 함수에 전달되는 람다는 무명 클래스 생성 없이 본문 코드가 호출 지점에 직접 삽입되므로, 객체 생성 오버헤드 없이 가장 최적화된 성능을 제공합니다.

함수 앞에 `inline` 키워드를 붙이게 되면 컴파일러는 함수 호출 지점에 함수의 본문과 람다의 본문을 그대로 붙여 넣습니다. 실제 바이트 코드를 뜯어보면 함수 호출이 사라집니다. 즉, 객체 생성 비용이 없습니다.

// inline 키워드 추가
inline fun flow(action: () -> Unit) {
    println("작업 시작")
    action()
    println("작업 끝")
}
fun main() {
    flow { println("Hello!") }
}

// inline 사용 시 main 함수의 바이트 코드 추정
fun main() {
    println("작업 시작")
    println("Hello!") // 전달한 람다가 삽입되어 action 함수 호출 비용 X
    println("작업 끝")
}

`inline` 함수는 다음에 정리할 고차 함수에서 구체적으로 다룹니다.

SAM 생성자: 람다를 함수형 인터페이스 명시적으로 변경

SAM(Single Abstract Method) 생성자는 컴파일러가 람다를 함수형 인터페이스로 자동 변환하지 못하는 상황(반환 값으로 사용하거나 변수에 할당할 때 등)에서, 람다를 특정 인터페이스의 인스턴스로 명시적으로 변환하기 위해 컴파일러가 제공하는 특수한 함수입니다.

// SAM 생성자 사용 예시
fun createAllDoneRunnable(): Runnable {
    // Runnable이라는 이름을 직접 명시하여 람다를 Runnable 객체로 만듦
    return Runnable { println("All done!") } 
}

SAM 생성자는 람다를 변수에 담아두고 여러 곳에서 재사용할 때 유용합니다.

// 람다를 SAM 생성자로 감싸 변수에 저장
val handler = View.OnClickListener { view ->
    println("버튼 클릭됨: ${view.id}")
}

// 여러 버튼에 동일한 리스너 인스턴스 적용
button1.setOnClickListener(handler)
button2.setOnClickListener(handler)

수신 객체 지정 람다: with & apply

자바 람다와 차별화되는 코틀린만의 특징 중 하나는 수신 객체 지정 람다입니다. 람다 블록 내부에 특정 객체의 메서드를 마치 자신의 것처럼 호출할 수 있게 해 주어, 코드의 가독성을 높이고 DSL(도메인 특화 언어) 작성을 용이하게 만듭니다.

with: 객체를 인자로 전달하여 조작하기

`with` 함수는 첫 번째 인자로 받은 객체를 두 번째 인자인 람다의 수신 색채로 만듭니다. 람다 내부에서는 `this`를 통해 객체에 접근할 수 있으며, `this`를 생략하고 곧바로 멤버 함수를 호출할 수도 있습니다.

// ❌ 일반적인 구조
fun alphabet(): String {
    val sb = StringBuilder()
    for (letter in 'A'..'Z') {
        sb.append(letter)
    }
    sb.append("\nNow I know the alphabet!")
    return sb.toString()
}

// ✅ with 함수를 사용하여 중복 제거한 경우
fun alphabet(): String = with(StringBuilder()) {
    for (letter in 'A'..'Z') {
        append(letter) // this.append에서 this 생략 가능
    }
    append("\nNow I know the alphabet!")
    toString() // 람다의 마지막 식의 결과를 반환
}

apply: 수신 객체를 그대로 반환하기

`with` 함수는 람다의 결괏값이 필요할 때 유용하지만, 가끔은 연산을 수행한 후 객체 자신이 다시 필요한 경우가 있습니다. 이때 `apply`를 사용합니다.

// ✅ apply를 사용하여 StringBuilder 객체 자체를 반환받는 경우
fun alphabet() = StringBuilder().apply {
    for (letter in 'A'..'Z') {
        append(letter)
    }
    append("\nNow I Know the alphabet!")
}.toString() // apply는 StringBuilder를 반환하므로, 마지막에 toString() 호출 가능

코틀린 표준 라이브러리는 `StringBuilder`를 이용한 문자열 생성을 좀 더 구체적이고 우아한 함수인 `buildString`을 제공합니다.

fun alphabet() = buildString {
    for (letter in 'A'..'Z') {
        append(letter) // 수신 객체인 StringBuilder의 append 호출
    }
    append("\nNow I know the alphabet!")
    // 명시적인 toString() 호출이 필요 없음
}

함수	수신 객체 전달 방식	반환값	주요 용도
`with`	함수의 인자로 전달	람다의 마지막 식	객체를 이용해 결과를 만들고 싶을 때
`apply`	확장 함수 형태로 호출	수신 객체 자신	객체의 속성을 설정(초기화)할 때

요약

람다를 사용하면 코드 조각을 다른 함수에게 인자로 넘길 수 있다.
코틀린은 람다가 함수 인자인 경우 괄호 밖으로 빼낼 수 있고, 람다의 인자가 단 하나뿐인 경우 인자 이름을 지정하지 않고 `it`이라는 디폴트 이름을 사용할 수 있다.
자바와 다르게 람다 안에 있는 코드는 그 람다가 들어있는 바깥 함수의 변수를 읽거나 쓸 수 있다.
`filter`, `map`, `all`, `any` 등의 함수를 활용하면 컬렉션에 대한 대부분의 연산을 직접 원소를 이터레이션 하지 않고 수행할 수 있다.
시퀀스를 사용하면 중간 결과를 담는 컬렉션을 생성하지 않고도 컬렉션에 대한 여러 연산을 조합할 수 있다.
함수형 인터페이스(추상 메서드가 단 하나뿐인 SAM 인터페이스)를 인자로 받는 자바 함수를 호출할 경우 람다를 함수형 인터페이스 인자 대신 넘길 수 있다.
수신 객체 지정 람다를 사용하면 람다 안에서 미리 정해둔 수신 객체의 메서드를 직접 호출할 수 있다.
표준 라이브러리 `with` 함수를 사용하면 어떤 객체에 대한 참조를 반복해서 언급하지 않고 그 객체의 메서드를 호출할 수 있다. `apply`를 사용하면 어떤 객체라도 빌더 스타일의 API를 사용해 생성하고 초기화할 수 있다.

[Kotlin in Action 2/e] 클래스, 객체, 인터페이스

Hui._. — Tue, 30 Dec 2025 13:49:29 +0900

Kotlin in Action 2/e 서적을 읽으면서 정리하고자 쓴 글입니다.

kotlin logo

코틀린의 클래스와 인터페이스는 설계 단계부터 안정성과 간결함을 중시하도록 설계되었습니다. 인터페이스 내에 프로퍼티 선언이 가능해 구현체에 특정 상태를 강제할 수 있으며, 자바와 달리 모든 선언이 기본적으로 `public`이면서 동시에 상속이 제한된 `final` 상태라 의도치 않은 확장을 방지합니다. 또한 중첩 클래스는 별도의 키워드 없이 선언할 경우 외부 클래스에 대한 참조를 갖지 않아 메모리 누수 위험을 줄여줍니다.

클래스를 data 즉, `data class`로 선언하면 컴파일러가 일부 표준 함수를 생성해 주며, `by` 키워드를 활용한 위임 기능을 제공함으로써 개발자가 반복적이고 번거로운 준비 코드를 직접 작성할 필요 없이 핵심 로직에만 집중할 수 있도록 해줍니다.

클래스 계층 정의

1) 코틀린 인터페이스

코틀린 인터페이스는 자 8 인터페이스와 유사하며, 추상 메서드 뿐만 아니라 구현을 포함한 메서드도 정의할 수 있습니다. 이는 자바의 `default` 메서드와 같은 개념입니다.

코틀린은 자바의 `extends`와 `implements` 키워드 대신 콜론 (`:`) 하나로 클래스 확장과 인터페이스 구현을 모두 처리합니다. 자바와 동일하게 클래스는 오직 하나의 클래스만 확장할 수 있으며, 인터페이스는 개수 제한이 없습니다.

interface Clickable {
    fun click() // 추상 메소드
    fun showOff() = println("I'm clickable!") // 디폴트 구현
}

class Button : Clickable {
    override fun click() = println("I was clicked")
}

1-1) 다중 인터페이스 상속 관계에서 동일한 함수가 구현되어 있다면?

이름이 동일한 `showOff` 함수가 있는 `Focusable` 인터페이스를 추가 생성해 봅시다. 그리고 `Button`에 상속한다면 코틀린은 중복된 상위 함수가 있음을 감지하고 반드시 하위 클래스에 구현되어야 한다는 컴파일 오류가 발생하게 됩니다.

interface Focusable {
    fun setFocus(b: Boolean) =
        println("I ${if (b) "got" else "lost"} focus.")

    fun showOff() = println("I'm focusable!")
}

class Button : Clickable, Focusable { // showOff 함수를 가진 2개의 인터페이스 상속
    override fun click() = println("I was clicked")
}

1-2) 자바에서 코틀린의 메서드가 있는 인터페이스 구현

코틀린은 구버전인 자바 6도 호환되도록 설계되었습니다. 자바 6는 인터페이스의 `default` 메서드를 지원하지 않기 때문에 코틀린 컴파일러는 이를 해결하기 위해 독특한 방식을 사용합니다.

인터페이스: 메서드 선언부만 포함합니다.
정적 보조 클래스: 인터페이스와 함께 생성되며, `default` 메서드의 실제 구현 본문을 정적(static) 메서드로 담고 있습니다.

이러한 구조로 자바 클래스에서 코틀린 인터페이스를 상속받아 구현할 때 코틀린의 `default` 메서드 구현에 의존할 수 없습니다. 즉, 자바에서는 코틀린에 이미 구현된 본문이 있더라도 직접 `override`하여 본문을 작성해야 합니다.

2) open, final, abstract 변경자

코틀린은 설계 시 상속을 엄격하게 관리합니다. 이는 취약한 기반 클래스 문제를 방지하고 더 안전한 코드를 작성하기 위함입니다.

2-1) 왜 코틀린은 기본적으로 `final`인가?

자바에서 상속을 명시적으로 금지하지 않는 한 모든 클래스를 상속할 수 있습니다. 하지만 이는 기반 클래스가 변경될 때 하위 클래스의 동작이 예기치 않게 깨지는 위험을 초래합니다.

이펙티브 자바에서 "상속을 위한 설계와 문서를 갖추거나, 그럴 수 없다면 상속을 금지하라"에 따라, 코틀린은 모든 클래스와 메서드를 기본적으로 `final`로 설정하였습니다. 상속이나 `override`를 허용하려면 개발자가 명시적으로 `open`을 붙여야 합니다.

2-2) `open`과 `override` 사용법

어떤 클래스의 상속을 허용하려면 클래스 앞에 `open`을 붙여야 하며, 메서드나 프로퍼티 역시 `open`이 붙어 있어야만 `override`가 가능합니다.

open class RichButton : Clickable { 
    fun disable() {} // final: 하위 클래스에서 오버라이드 불가
    open fun animate() {} // open: 하위 클래스에서 오버라이드 가능
    override fun click() {} // 오버라이드한 메소드는 기본적으로 open 상태
}

만약 `override` 중인 메서드를 더 이상 하위 클래스에 재정의하지 못하게 막고 싶다면, 앞에 `final`을 명시해야 합니다.

open class RichButton : Clickable {
    final override fun click() {} // 앞에 final을 붙여 오버라이드 금지
}

열린 클래스와 스마트 캐스트
클래스와 프로퍼티가 기본적으로 final이기 때문에 얻는 큰 이점 중 하나는 스마트 캐스트입니다. 스마트 캐스트는 타입 검사 후 변수가 변하지 않는다는 보장이 있어야만 작동합니다. 코틀린 프로퍼티는 기본적으로 final이므로, 다른 클래스가 상속받아 커스텀 접근자를 정의하거나 값을 바꿀 위험이 적어 대부분의 프로퍼티를 고민 없이 스마트 캐스트에 활용할 수 있습니다.

2-3) 추상 클래스와 인터페이스

자바처럼 코틀린에서도 `abstract` 클래스를 선언할 수 있습니다.

추상 클래스: 인스턴스화할 수 없으며, `abstract` 멤버는 구현이 없으므로 항상 `open` 상태입니다.
인터페이스: 멤버 앞에 `final`, `open`, `abstract`를 붙이지 않습니다. 인터페이스 멤버는 항상 열려있으며, 본문이 없으면 자동으로 `abstract`가 됩니다.

abstract class Animated {
    abstract fun animate() // 반드시 오버라이드 해야 함
    open fun stopAnimating() {} // 비추상 함수지만 오버라이드 허용
    fun animateTwice() {} // 기본적으로 final
}

2-4) 스프링 프레임워크와 같이 사용하면 클래스와 메서드는 `open`으로 열어두어야 한다.

프록시 기반의 기능 확장 (AOP)
스프링은 `@Transactional`, `@Cacheable` 같은 기능을 제공할 때, 내가 작성한 클래스를 직접 사용하는 대신 이를 상속받은 가짜 객체(프록시)를 만들어 실행합니다. 코틀린의 기본값인 `final` 상태로는 상속이 불가능하여 이런 부가 기능을 덧붙일 수 없습니다.

빈(Bean) 관리와 싱글톤 보장
`@Configuration`이 붙은 설정 클래스 역시 스프링이 내부적으로 상속을 통해 관리합니다. 클래스가 열려 있어야만 스프링이 객체 생성 과정을 제어하고 싱글톤 패턴을 유지할 수 있습니다.

JPA 지연 로딩 (Lazy Loading)
JPA(Hibernate)는 데이터가 실제로 필요할 때까지 로딩을 미루기 위해 엔티티를 상속받은 프록시 객체를 생성합니다. 엔티티 클래스가 `final`이면 이 기능을 사용할 수 없어 성능 최적화가 어려워집니다.

all-open 플러그인 실무에서는 매번 open을 붙이는 번거로움을 피하기 위해 kotlin-spring 플러그인을 사용합니다. 이 플러그인은 스프링 주요 애노테이션이 붙은 클래스들을 컴파일 시점에 자동으로 open으로 만들어 줍니다.

변경자	해당 멤버	설명
`final`	오버라이드 불가	클래스 멤버의 기본 상태입니다.
`open`	오버라이드 가능	명시적으로 선언해야만 상속 및 재정의가 가능합니다.
`abstract`	반드시 오버라이드 필요	추상 클래스 내에서만 사용하며, 구현체가 없습니다.
`override`	상위 멤버 재정의	오버라이드 중인 멤버는 기본적으로 `open`입니다.

3) 내부 클래스와 중첩된 클래스

코틀린은 자바처럼 클래스 안에 클래스를 선언할 수 있습니다. 하지만 자바와 코틀린은 이 기능을 다루는 기본 방식이 반대로 되어있습니다. 이 차이를 모르면 예상치 못한 메모리 누수나 직렬화 오류를 겪을 수 있습니다.

3-1) 자바에서의 실수: `NotSerializableException` 발생 원인

View의 상태를 저장하는 간단한 예시를 살펴봅시다. 자바에서 `Button` 클래스 내부에 상태 정보를 담는 `ButtonState`를 선언하면 다음과 같은 형태가 됩니다.

public class Button implements View {
    @Override
    public State getCurrentState() {
        return new ButtonState();
    }
    // Button 클래스 안에 ButtonState 클래스
    public class ButtonState implements State { ... }
}

이 상황에 `ButtonState`를 직렬화하려고 하면 `java.io.NotSerializableException: Button` 예외가 발생됩니다. 자바는 중첩 클래스를 그냥 선언하면 내부 클래스(Inner Class)가 되며 자신을 둘러싼 바깥쪽 클래스(`Button`)에 대한 묵시적인 참조를 포함합니다. 이로 인해 `ButtonState`를 직렬화하면 `Button` 객체까지 함께 직렬화해야 하는데, `Button`은 직렬화가 불가능하여 예외가 발생하게 됩니다.

자바는 이를 해결하기 위해선 클래스 앞에 `static` 키워드를 붙여야 합니다.

3-2) 코틀린은 기본 값이 반대

코틀린은 이러한 자바의 번거로움과 실수를 방지하기 위해 기본 설정을 반대로 뒤집었습니다.

코틀린은 클래스 내부에 선언된 클래스는 명시적으로 요청하지 않은 한 바깥쪽 클래스에 대한 참조가 없습니다. 즉, 자바의 `static class`와 같은 상태가 기본 값으로 사용됩니다.

class Button : View {
    override fun getCurrentState(): State = ButtonState()

    // 아무 수식어가 없으면 자바의 static 중첩 클래스와 동일함
    class ButtonState : State { ... }
}

이 `ButtonState`는 바깥쪽 `Button`을 참조하지 않으며, 직렬화 시에도 문제가 발생하지 않습니다.

3-3) 바깥쪽 클래스의 참조가 필요하다면? `inner` 키워드 사용

inner 클래스: 바깥쪽 클래스에 대한 참조를 가집니다.
바깥쪽 참조 방법: 내부 클래스 안에서 바깥쪽 클래스의 인스턴스를 가리키려면 `this@OuterClassName` 문법을 사용합니다.

class Outer {
    val outerValue = "Outer String"
    inner class Inner {
        fun getOuterReference(): Outer {
            // 바깥쪽 클래스의 멤버에 접근하거나 인스턴스 참조
            println(outerValue)
            return this@Outer 
        }
    }
}

클래스 안의 클래스	자바	코틀린
바깥쪽 참조 없는 클래스	`static class A`	`class A` (기본값)
바깥쪽 참조 있는 클래스	`class A` (기본값)	`inner class A`

4) 봉인된 클래스 `sealed` 키워드

상위 클래스인 `Expr`에는 숫자를 표현하는 `Num`과 덧셈 연산을 표현하는 `Sum`이라는 두 하위 클래스가 있습니다. `when` 식을 통해 이 모든 하위 클래스를 처리하면 다음과 같이 사용할 수 있습니다.

interface Expr
class Num(val value: Int) : Expr
class Sum(val left: Expr, val right: Expr) : Expr

fun eval(e: Expr): Int =
    when (e) {
        is Num -> e.value
        is Sum -> eval(e.right) + eval(e.left)
        else -> // "else" 분기가 꼭 있어야 한다. 
            throw IllegalArgumentException("Unknown expression")
    }

그러나 위와 같이 `when` 식을 사용할 경우 `Num` 또는 `Sum` 클래스가 아니라면 반드시 `else` 분기를 추가해야 합니다. 또한 새로운 하위 클래스가 추가되더라도 컴파일러는 누락된 분기를 감지해주지 못합니다. 만약 특정 하위 클래스에 대한 처리를 실수로 빠뜨릴 경우 의도하지 않게 `else` 분기가 실행되며 이는 런타임 시점에 발견되기 어려운 치명적인 버그로 이어질 수 있습니다.

코틀린은 해당 문제를 `sealed` 키워드를 통해 해결할 수 있습니다. 상위 클래스에 `sealed`를 붙이면 그 상위 클래스를 상속한 하위 클래스 정의를 제한할 수 있습니다. 덕분에 `sealed` 클래스의 하위 클래스를 정의할 때는 반드시 상위 클래스 안에 중첩시켜야 합니다.

sealed class Expr { // sealed 사용
    class Num(val value: Int) : Expr()
    class Sum(val left: Expr, val right: Expr) : Expr()
}

fun eval(e: Expr): Int =
    when (e) {
        is Expr.Num -> e.value
        is Expr.Sum -> eval(e.right) + eval(e.left)
        // sealed 덕분에 else 분기를 생성할 필요가 없다.
    }

https://livebook.manning.com/book/kotlin-in-action/chapter-4

sealed 클래스
`sealed` 클래스는 강력한 타입 안전성을 제공하지만, 초기에는 제약이 다소 많았습니다. 예를 들어 모든 하위 클래스가 반드시 중첩 클래스여야 했고, `data class`로 `sealed` 클래스를 상속하는 것도 불가능했습니다.

그러나 Kotlin 1.1부터 이러한 제약이 완화되었습니다. 이제는 같은 파일 내라면 위치와 관계없이 `sealed` 클래스를 상속한 하위 클래스를 정의할 수 있으며, `data class` 또한 하위 클래스로 선언할 수 있습니다. 이로 인해 `sealed` 클래스는 여전히 컴파일 타임 안전성을 유지하면서도, 실무에서 훨씬 유연하게 활용할 수 있게 되었습니다.

뻔하지 않는 생성자와 프로퍼티를 갖는 클래스 선언

코틀린은 클래스를 선언하는 동시에 생성자를 정의하는 매우 간결한 문법을 제공합니다. 하지만 자바와의 호환성이나 다양한 초기화 상황을 대응하기 위해 주 생성자와 부 생성자를 구분하여 사용합니다.

1) 클래스 초기화: 주 생성자와 초기화 블록

주 생성자는 생성자 파라미터를 지정하고 그 생성자 파라미터에 의해 초기화되는 프로퍼티를 정의하는 2가지 목적으로 쓰입니다.

class User constructor(_nickname: String) { 
    val nickName: String

    // 주 생성자는 코드를 가질 수 없으므로, 초기화 로직이 필요할 때 init 블록을 사용합니다.
    init { 
        nickName = _nickname
        println("유저가 초기화되었습니다: $nickName")
    }
}

`init {}` 초기화 블록은 주 생성자와 함께 사용됩니다. 주 생성자는 제한적이기 때문에 별도의 코드를 포함할 수 없으므로 초기화 블록이 필요합니다.

2) 부 생성자: 상위 클래스를 다른 방식으로 초기화

코틀린은 자바와 달리 디폴트 파라미터를 지원하므로 생성자를 여러 개 만들 일이 적습니다. 하지만 다음과 같은 경우에는 부 생성자가 필요합니다.

자바 상호운용성: 여러 생성자를 가진 자바 라이브러리 클래스를 상속받아 확장할 때
다양한 인자 조합: 인스턴스를 생성하는 방법이 여러 가지인 경우

open class View {
    // 부 생성자 1
    constructor(ctx: Context) { /* ... */ }

    // 부 생성자 2
    constructor(ctx: Context, attr: AttributeSet) { /* ... */ }
}

class MyButton : View {
    // 상위 클래스의 특정 생성자를 호출해야 할 때
    constructor(ctx: Context) : super(ctx)
    constructor(ctx: Context, attr: AttributeSet) : super(ctx, attr)
}

3) 인터페이스에 선언된 프로퍼티 구현

코틀린은 자바와 달리 인터페이스에 프로퍼티를 선언할 수 있습니다. 하지만 인터페이스는 본래 상태를 가질 수 없기 때문에 선언된 프로퍼티를 하위 클래스에서 어떻게 구현하느냐에 따라 동적 방식이 달라집니다.

interface User {
    val nickName: String
}

class PrivateUser(override val nickname: String) : User // 주 생성자에 있는 프로퍼티

class SubscribingUser(val email: String) : User {
    override val nickname: String // 커스텀 게터
        get() = email.substringBefore('@')
}

class FacebookUser(val accountId: Int) : User {
    override val nickname = getFacebookName(accountId) // 프로퍼티 초기화 식
}

인터페이스에 `val nickname: String`이라고 선언하는 것은, 하위 클래스에 "값을 얻을 수 있는 방법을 제공하라"고 강제하는 것과 같습니다.

주 생성자 활용 (`PrivateUser`): 주 생성자 안에서 직접 오버라이드하여 필드에 값을 저장합니다.
커스텀 게터 활용 (`SubscribingUser`): 별도의 필드를 만들지 않고, 프로퍼티에 접근할 때마다 로직을 실행하여 결과를 계산합니다.
초기화 식 활용 (`FacebookUser`): 객체가 생성되는 시점에 단 한 번 함수를 호출하여 그 결괏값을 필드에 저장해 둡니다.

인터페이스 안에도 직접 게터(` get() `)를 가진 프로퍼티를 정의할 수 있습니다. 단, 인터페이스는 상태를 가질 수 없으므로 뒷받침하는 필드(field)를 가질 수는 없습니다.

interface User {
    val email: String
    val nickName: String
        get() = email.substringBefore('@') // 매번 호출 시점에 계산
}

`email`: 추상 프로퍼티이므로 하위 클래스에서 반드시 구현해야 합니다.
`nickName`: 인터페이스에 이미 게터 로직이 정의되어 있으므로, 하위 클래스에서 따로 구현하지 않고 그대로 상속받아 사용할 수 있습니다.

3) `get`과 `set`에서 뒷받침하는 필드에 접근

값을 저장하는 동시에 로직을 실행할 수 있게 하기 위해서는 접근자 안에서 프로퍼티를 뒷받침하는 필드에 접근할 수 있어야 합니다. 프로퍼티에 저장된 값의 변경 이력을 로그에 남기고 싶은 경우 다음과 같이 사용할 수 있습니다.

class User(val name: String) {
    var address: String = "unspecified"
        set(value: String) {
            // field는 프로퍼티의 실제 저장된 값을 가리킵니다.
            println("""
                Address was changed for $name:
                "$field" -> "$value".""".trimIndent())
            
            // 값을 업데이트합니다. 
            // 주의: 여기서 'address = value'라고 쓰면 다시 세터를 호출하여 무한 루프가 걸린다.
            field = value 
        }
}

>>> val u = User("alice")
>>> u.address = "city 11-12"
Address was changed for alice:
"unspecified" -> "city 11-12"

4) 접근자의 가시성 변경

때로는 프로퍼티의 값을 읽는 것은 자유롭게 허용하되, 수정은 클래스 내부에서만 하고 싶을 때가 있습니다. 이때 `private set`을 활용하면 아주 깔끔하게 캡슐화를 구현할 수 있습니다.

class LengthCounter {
    var counter: Int = 0
        private set // 외부에서는 수정 불가 (읽기 전용처럼 보임)

    fun addWord(word: String) {
        counter += word.length // 내부에서는 수정 가능
    }
}

외부에서는 `counter`를 조회할 수만 있고, 값의 조작은 반드시 `addWord`라는 검증된 메서드를 통해서만 이루어지도록 강제할 수 있습니다.

코틀린은 초기화 시점을 유연하게 관리할 수 있는 기능들도 제공합니다.

- lateinit: 널이 될 수 없는(non-null) 프로퍼티를 생성자에서 초기화하지 않고 나중에(예: Dependency Injection, Setup 메서드) 초기화하겠다고 선언할 때 사용합니다.

- 지연 초기화(by lazy): 프로퍼티가 처음 사용되는 시점에 딱 한 번 초기화 로직을 실행합니다. 이는 더 넓은 개념인 위임 프로퍼티(Delegated Property)의 한 종류입니다.

- 자바 호환성: @JvmField, @JvmStatic 등의 애노테이션을 사용하여 코틀린 프로퍼티가 자바에서 일반 필드처럼 보이게 에뮬레이션 할 수 있습니다.

컴파일러가 생성한 메서드: 데이터 클래스와 클래스 위임

자바에서는 객체의 비교나 출력을 위해 `equals`, `hashCode`, `toString` 같은 메서드를 매번 구현해야 했습니다. 코틀린은 이러한 '보일러플레이트(반복적이고 번거로운 코드)'를 컴파일러가 대신 생성해 주는 강력한 기능을 제공합니다.

1) 데이터 클래스 (`Data Class`)

코틀린은 클래스 앞에 `data` 변경자를 붙이면 컴파일러가 `equals`, `hashCode`, `toString` 메서드를 자동으로 만들어줍니다.

data class Client(val name: String, val postalCode: Int)

fun main() {
    val c1 = Client("alice", 100)
    val c2 = Client("bella", 100)

    println(c1.name == c2.name) // false (String 비교)
    println(c1.hashCode() == c2.hashCode()) // false (hashCode)
    println(c1.toString()) // Client(name=alice, postalCode=100)
}

2) 불변성과 `copy()` 메서드

코틀린은 데이터 클래스의 프로퍼티를 `val`로 선언하여 불변(Immutable) 객체로 만드는 것을 권장합니다. 특히 객체를 `HashMap`의 키로 쓸 때 데이터가 변하면 데이터 무결성이 깨지기 때문입니다.

이때 불변 객체의 내용을 일부만 바꿔서 새로 만들고 싶다면 `copy()` 메서드를 활용합니다.

val bob = Client("Bob", 110)
// name은 유지하고 postalCode만 바꾼 복사본 생성
val olderBob = bob.copy(postalCode = 220)

원본 객체는 그대로 유지되므로 프로그램의 다른 부분에 영향을 주지 않아 안전합니다.

3) 클래스 위임(Class Delegation): `by` 키워드의 마법

상속을 허용하지 않는(final) 클래스에 새로운 기능을 추가하고 싶을 때 보통 데코레이터(Decorator) 패턴을 사용합니다. 하지만 이 패턴은 기존 클래스의 모든 기능을 다시 작성해야 하는 번거로운 준비 코드가 필요합니다.

// 수동으로 기능을 전달하는 방식
class DelegatingCollection<T>(
    private val innerList: Collection<T> = arrayListOf<T>()
) : Collection<T> {
    
    // 단순 연결임에도 불구하고 모든 추상 멤버를 직접 작성해야 함 (보일러플레이트)
    override val size: Int get() = innerList.size
    override fun isEmpty(): Boolean = innerList.isEmpty()
    override fun contains(element: T): Boolean = innerList.contains(element)
    override fun iterator(): Iterator<T> = innerList.iterator()
    override fun containsAll(elements: Collection<T>): Boolean = innerList.containsAll(elements)
}

fun main() {
    val list = listOf("Kotlin", "Java")
    val delegating = DelegatingCollection(list)
    
    println("Size: ${delegating.size}") // 결과: Size: 2
}

코틀린은 `by` 키워드를 통해 이 위임 로직을 단 한 줄로 해결합니다.

// 클래스 위임(by)을 활용한 기능 확장
class CountingSet<T>(
    private val innerSet: MutableCollection<T> = HashSet<T>()
) : MutableCollection<T> by innerSet { // MutableCollection의 모든 메서드 구현을 innerSet에 맡김

    var objectsAdded = 0 // 새롭게 추가된 요소의 총 개수를 저장하는 상태

    // 요소 하나를 추가할 때 카운트 증가 로직만 재정의(Override)
    override fun add(element: T): Boolean {
        objectsAdded++
        return innerSet.add(element)
    }

    // 여러 요소를 한꺼번에 추가할 때 카운트 증가 로직만 재정의
    override fun addAll(c: Collection<T>): Boolean {
        objectsAdded += c.size
        return innerSet.addAll(c)
    }
    
    // 나머지 size, isEmpty, remove, contains 등의 메서드는 작성하지 않아도 
    // 자동으로 innerSet의 기능을 그대로 사용함
}

fun main() {
    val cset = CountingSet<Int>()
    
    cset.add(1)
    cset.addAll(listOf(2, 3, 4))
    
    println("${cset.objectsAdded} objects were added, ${cset.size} remain in the set.")
    // 출력 결과: 4 objects were added, 4 remain in the set.
    
    // 위임된 메서드(remove)를 사용해봄
    cset.remove(1)
    println("After removal - Size: ${cset.size}, Total Added: ${cset.objectsAdded}")
    // 출력 결과: After removal - Size: 3, Total Added: 4
}

`MutableCollection` 인터페이스의 수많은 메서드들(`size`, `isEmpty`, `contains` 등)을 직접 구현할 필요가 없습니다. `by innerSet`이라고 명시하면, 컴파일러가 나머지 모든 메서드를 `innerSet`의 메서드를 호출하도록 자동으로 연결해 줍니다.

즉, 상속의 위험성(기반 클래스 변경에 따른 취약점)은 피하면서, 필요한 기능만 깔끔하게 확장할 수 있습니다.

`object` 키워드: 클래스 선언과 인스턴스 생성

코틀린에서 `object` 키워드는 "클래스를 정의하면서 동시에 단 하나의 인스턴스(객체)를 생성"할 때 사용합니다. 자바의 싱글턴 패턴, 정적(static) 메서드, 익명 클래스를 코틀린만의 방식으로 해결합니다.

1) 객체 선언(Object Declaration): 완벽한 싱글톤

자바에서는 보통 클래스의 생성자를 `priavte`으로 제한하고 정적인 필드에 그 클래스의 유일한 객체를 저장하는 싱글톤 패턴을 통해 이를 구현합니다. 반면에 코틀린은 `object` 키워드를 통해 싱글톤 객체를 생성할 수 있습니다.

object DatabaseConfig {
    val url = "jdbc:mysql://localhost:3306/db"
    fun connect() = println("$url 에 연결합니다.")
}

// 사용 시점: 클래스 이름처럼 접근하면 이미 생성된 단일 객체를 참조함
fun main() {
    DatabaseConfig.connect() 
}

특정 클래스 내부에만 밀접하게 연관된 싱글톤 객체가 필요하다면 클래스 안에 선언할 수도 있습니다. 이 경우에도 해당 객체의 인스턴스는 단 하나뿐입니다.

data class Person(val name: String) {
    // Person 클래스 내부에 이름 비교를 위한 전용 컴퍼레이터 선언
    object NameComparator : Comparator<Person> {
        override fun compare(p1: Person, p2: Person): Int =
            p1.name.compareTo(p2.name)
    }
}

fun main() {
    val persons = listOf(Person("Bob"), Person("Alice"))
    println(persons.sortedWith(Person.NameComparator)) // '클래스명.객체명'으로 접근
}

2) 동반 객체: 팩토리 메서드와 정적 멤버가 들어갈 장소

코틀린을 처음 접하면 당황스러운 점 중 하나가 클래스 내부에 `static` 키워드가 없다는 것입니다. 코틀린은 전역적인 상태를 지양하기 위해 자바의 `static`을 없앴지만, 그 역할을 더 안전하고 구조적으로 대체하기 위해 동반 객체(Companion Object)를 도입했습니다.

2-1) 동반 객체란 무엇인가?

클래스 내부에 정의된 객체 앞에 `companion`이라는 키워드를 붙이면 해당 클래스의 동반 객체가 됩니다. 이 객체의 프로퍼티나 메서드는 클래스 인스턴스 생성 없이 클래스 이름을 통해 직접 접근할 수 있어, 자바의 정적 멤버와 유사하게 동작합니다.

class A {
    companion object {
        fun bar() {
            println("Companion object called")
        }
    }
}

fun main() {
    A.bar() // 클래스 A의 인스턴스를 만들지 않고도 호출 가능
}

2-2) 왜 동반 객체를 사용하는가? (팩토리 메서드)

동반 객체의 가장 강력한 용도는 팩토리 메서드(Factory Method)를 만드는 것입니다.

class User private constructor(val nickname: String) { // 주 생성자를 private으로 보호
    companion object {
        // 이메일을 통해 유저를 생성하는 팩토리 메소드
        fun newSubscribingUser(email: String) =
            User(email.substringBefore('@'))

        // 페이스북 ID를 통해 유저를 생성하는 팩토리 메소드
        fun newFacebookUser(accountId: Int) =
            User(getFacebookName(accountId))
    }
}

fun main() {
    // 생성자 대신 목적이 분명한 메소드 이름을 사용하므로 가독성이 높아짐
    val subscribingUser = User.newSubscribingUser("bob@gmail.com")
    val facebookUser = User.newFacebookUser(4)
}

2-3) 자바 `static`과의 결정적 차이

자바의 `static` 멤버는 클래스에 속한 정적인 데이터일 뿐이지만, 코틀린의 동반 객체는 실제 객체입니다. 따라서 다음과 같은 차별화된 기능을 가집니다.

인터페이스 구현: 동반 객체도 인터페이스를 상속받아 구현할 수 있습니다.
확장 함수: 클래스 외부에서 동반 객체에 대한 확장 함수를 정의하여 기능을 덧붙일 수 있습니다.

3) 동반 객체를 일반 객체처럼 사용

동반 객체는 클래스 내부에 정의되는 일반 객체이므로, 이름을 붙일 수 있고 인터페이스를 구현할 수 있으며, 그 안에 확장 함수와 프로퍼티를 정의할 수도 있습니다.

class Person(val name: String) {
    companion object Parser { // "Parser" 동반 객체 이름
        fun fromJSON(jsonText: String) : Person = ...
    }
}

fun main() {
    val p1 = Person.Parser.fromJSON("{name: 'bella'}")
    val p2 = Person.fromJSON("{name: 'alice'}") // 생략도 가능
    println(p1.name) // bella
    println(p2.name) // alice
}

다른 객체 선언과 마찬가지로 동반 객체로 인터페이스를 구현할 수도 있습니다.

interface JsonFactory<T> {
    fun fromJson(jsonText: String): T
}
class Person(val name: String) {
    companion object : JsonFactory<Person> {
        // 동반 객체의 인터페이스 구현
        override fun fromJson(jsonText: String): Person { ... }
    }
}

위처럼 JSON으로부터 각 원소를 다시 만들어내는 추상 팩토리가 있다면 `Person` 객체를 해당 팩토리에 넘길 수 있습니다.

코틀린 동반 객체와 정적 멤버
코틀린에서 클래스와 동반 객체는 컴파일 시 클래스에 포함된 정적 필드로 변환되며, 일반 객체와 유사한 방식으로 취급됩니다. 동반 객체에 이름을 붙이지 않은 경우, 자바 코드에서는 `Companion`이라는 이름을 통해 해당 객체를 접근할 수 있습니다.

4) 객체 식: 무명 내부 클래스를 다른 방식으로 작성

무명 객체(anonymous object)를 정의할 때도 `object` 키워드를 씁니다. 자바의 익명 내부 클래스와 유사하지만, 코틀린의 무명 객체는 훨씬 더 자유롭고 강력한 기능을 제공합니다.

4-1) 무명 객체란?

이름이 없는 객체를 선언과 동시에 생성하는 방식입니다. 주로 인터페이스의 구현체나 특정 클래스를 확장한 객체가 일회성으로 필요할 때 사용합니다.

// MouseAdapter를 상속하는 무명 객체를 생성하여 전달
window.addMouseListener(
    object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) { ... }
        override fun mouseEntered(e: MouseEvent) { ... }
    }
)

만약 생성한 무명 객체를 재사용하고 싶다면 변수에 담아 사용할 수 있습니다.

val listener = object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) { ... }
    override fun mouseEntered(e: MouseEvent) { ... }
}

window.addMouseListener(listener) // 무명 객체 인자로 전달

4-2) 코틀린 무명 객체의 차별점

자바의 익명 클래스는 단 하나의 클래스를 상속하거나 하나의 인터페이스만 구현할 수 있습니다. 하지만 코틀린의 무명 객체를 여러 개의 인터페이스를 동시에 구현하거나, 클래스 상속과 인터페이스 구현을 한 번에 처리할 수 있습니다.

// 클래스 상속과 인터페이스 구현을 동시에 하는 무명 객체
val complexObject = object : MyBaseClass(), Runnable, Serializable {
    override fun run() {
        println("다중 구현된 무명 객체가 실행 중입니다.")
    }
}

자바에서 익명 클래스 외부의 변수를 사용하려면 그 변수가 `final`이어야만 했습니다. 그러나 코틀린의 객체 식 안에서는 `final`이 아닌 변수도 자유롭게 접근하고 수정할 수 있습니다.

fun countClicks(window: Window) {
    var clickCount = 0 // final이 아님

    window.addMouseListener(object : MouseAdapter() {
        override fun mouseClicked(e: MouseEvent) {
            clickCount++ // 외부 변수의 값을 직접 수정 가능!
        }
        override fun mouseEntered(e: MouseEvent) { ... }
    })
}

무명 객체는 람다(Lamda)와 혼동될 수 있습니다. 만약 구현해야 할 메서드가 단 하나뿐인 인터페이스(SAM)라면 무명 객체 대신 람다를 쓰는 것이 훨씬 간결해집니다. 하지만 위 예제처럼 여러 메서드를 오버라이드해야 한다면 반드시 `object` 식을 사용해야 합니다.

구분	형태	주요 특징
객체 선언	`object Name { ... }`	클래스 전체에서 단 하나의 싱글톤
동반 객체	`companion object { ... }`	클래스 당 하나, 정적 멤버/팩토리 역할
무명 객체	`object : Type { ... }`	일회성 인스턴스, 다중 구현 가능

요약

코틀린의 인터페이스는 자바 인터페이스와 유사하지만, 자바와 달리 프로퍼티 선언을 포함할 수 있다.
코틀린의 선언은 기본적으로 `final`이며 `public`이다.
선언이 `final`이 되지 않으려면(상속과 오버라이딩이 가능) 앞에 `open`을 붙여야 한다.
코틀린의 중첩 클래스는 기본적으로 내부 클래스가 아니다. 바깥쪽 클래스에 대해 참조를 중첩 클래스 안에 포함시키려면 `inner` 키워드를 중첩 클래스 선언 앞에 붙여야 내부 클래스가 된다.
`sealed class`를 상속하는 클래스를 정의하려면 반드시 부모 클래스 정의 안에 중첩(또는 내부) 클래스로 정의되어야 한다. (코틀린 1.1부터 같은 파일에만 있으면 되도록 개선되었다.)
초기화 블록(`init {}`)과 부 생성자를 활용해 인스턴스를 더 유연하게 초기화할 수 있다.
`data class`를 사용하면 `equals`, `hashCode`, `toString`, `copy` 등 메서드를 자동으로 생성해 준다.
클래스 위임(`by`)을 사용하면 객체 위임 기반 설계를 구현할 때 불필요한 준비 코드를 크게 줄일 수 있다.
객체 선언(`object`)을 사용하면 싱글톤 클래스를 쉽게 구현할 수 있다.
동반 객체(`comanion object`)는 자바의 정적 메서드와 필드 정의를 대신한다.
동반 객체도 다른 객체와 마찬가지로 인터페이스를 구현할 수 있다. 외부에서 동반 객체에 대한 확장 함수와 프로퍼티를 정의할 수 있다.
코틀린의 객체 식은 자바의 무명 내부 클래스를 대신한다. 또한 여러 인스턴스를 구현하거나 객체가 포함된 영역(scope)에 있는 변수의 값을 변경할 수 있는 등 자바 무명 클래스보다 더 많은 기능을 제공한다.

[Kotlin in Action 2/e] 함수 정의와 호출

Hui._. — Tue, 30 Dec 2025 00:40:25 +0900

Kotlin in Action 2/e 서적을 읽으면서 정리하고자 쓴 글입니다.

kotlin logo

코틀린에서 컬렉션 만들기

코틀린은 다음과 같이 컬렉션을 생성하는 함수를 제공합니다.

또한 코틀린은 표준 자바 컬렉션 클래스를 사용하기 때문에 자바 코드와 상호작용하기가 훨씬 더 쉽습니다.

즉, 자바 → 코틀린 또는 코틀린 → 자바 함수를 호출할 때 컬렉션을 서로 변환할 필요가 없습니다.

fun main() {
    val set = setOf(1, 7, 10)
    val list = listOf(1, 10, 100)
    val map = mapOf(1 to "one", 7 to "seven", 10 to "ten") // ex) key=1, value="one"
    
    println(set.javaClass) // class java.util.LinkedHashSet
    println(list.javaClass) // class java.util.Arrays$ArrayList
    println(map.javaClass) // class java.util.LinkedHashMap
}

1) 이름 붙인 인자

아래 함수를 보면 인자로 전달하는 값이 어떤 역할을 하는지 구분하기 어렵습니다.

joinToString(collection, " ", " ", =".")

코틀린은 이를 해결하기 위해 인자의 이름을 명시할 수 있는 기능을 제공합니다.

심지어 인자 순서를 변경할 수도 있습니다.

joinToString(
    prefix = " ",
    postfic = ".",
    separator = " ", 
    collection = collection
)

2) 디폴트 파라미터 값

자바의 경우 여러 파라미터를 받기 위해서는 `overloaing`한 메서드가 많아진다는 문제를 가지고 있습니다.
그러나 코틀린은 함수 선언 시 파라미터의 디폴트 값을 지정할 수 있습니다.

fun <T> joinToString(
    collection: Collection<T>,
    separator: String = ",",
    prefix: String = "",
    postfix: String = ""
): String { ... }

fun main() {
    val list = listOf("A", "B", "C")
    joinToString(list) // 이외 다른 파라미터를 받지 않아도 디폴트 파라미터 사용
}

3) 정적인 유틸리티 클래스 없애기: 최상위 함수와 프로퍼티

코틀린은 특정 클래스에 속하지 않는 공통 로직을 처리하기 위해 자바처럼 무의미한 클래스를 만들 필요가 없습니다.

최상위 수준에 함수와 프로퍼티를 직접 선언합니다.

구분	설명	비고
최상위 함수	클래스 밖에 최상위에 선언된 함수	자바의 `static` 메서드로 컴파일
최상위 프로퍼티	클래스 밖 최상위에 선언된 변수	자바의 `static` 필드로 컴파일
`const` 상수	`const val`로 선언하며, 컴파일 타임 상수	원시 타입과 `String`만 사용 가능

파일의 최상위 수준에서 선언한다면 다음과 같습니다.

package com.example.utils

// 최상위 프로퍼티: 상수 선언
const val UNIX_LINE_SEPARATOR = "\n"

// 최상위 프로퍼티: 일반 변수 (게터가 생성됨)
var opCount = 0

// 최상위 함수: 유틸리티 함수
fun joinToString(items: List<String>): String {
    opCount++
    return items.joinToString(separator = UNIX_LINE_SEPARATOR)
}

각각 코틀린 및 자바에서 사용 예시입니다.

// Kotlin
fun main() {
    val list = listOf("Kotlin", "Java")
    println(joinToString(list)) // 클래스 이름 없이 직접 호출합니다.
}

// Java
class Main {
    public static void main(String[] args) {
    	List<String> list = List.of("Kotlin", "Java");
    	String result = StringUtilsKt.joinToString(list);
    }
}

코틀린은 다음과 같은 특징을 가집니다.

가독성 향상: 불필요한 클래스 선언(ex: `class StringUtils { private ...() }`)가 사라져 코드가 훨씬 간결해집니다.
컴파일 구조: 코틀린 파일은 내부적으로 자바 클래스로 변환되므로 자바와의 상호 운용성이 완벽하게 유지됩니다.
상수 선언의 적절성: 실행 시점에 결정되는 값은 `val`을 사용하고, 컴파일 시점 완전히 고정되는 값은 `const val`을 사용하여 인라인 최적화를 유도해야 합니다.

메서드를 다른 클래스에 추가: 확장 함수와 프로퍼티

코틀린의 확장은 기존 크래스의 소스코드를 수정하지 않고도 새로운 메서드나 프로퍼티를 추가할 수 있게 해주는 매우 강력한 기능입니다. 이는 자바의 외부 라이브러리나 표준 API를 코틀린 스타일로 확장할 때 핵심적인 역할을 합니다.

1) 확장 함수 (Extension Functions)

확장 함수는 어떤 클래스의 멤버 메서드인 것처럼 호출할 수 있지만 클래스 밖에 선언된 함수를 말합니다.

// String: 수신 객체 타입 (Receiver Type)
// this: 수신 객체 (Receiver Object)
fun String.lastChar(): Char = this.get(this.length - 1)

println("Kotlin".lastChar()) // n (String 클래스를 건들지 않고 확장할 수 있다.)

수신 객체 타입: 확장이 정의될 클래스의 이름입니다.
수신 객체: 확장 함수가 호출되는 실제 객체 인스턴스입니다. 함수 내부에서 `this` 키워드를 통해 접근할 수 있으며, `this`를 생략하고 멤버에 접근하는 것도 가능합니다.

확장 함수는 클래스 내부에서 선언된 것이 아니므로, 클래스의 `private`이나 `protected` 멤버에는 접근할 수 없습니다. 또한 확장 함수를 사용하기 위해 반드시 `import`를 해야합니다. 이름이 충돌할 경우 as 키워드를 사용하여 이름을 변경할 수 있습니다.

import strings.lastChar as last // last로 이름 변경
val c = "Kotlin".last()

2) 자바에서 확장 함수 호출

내부적으로 확장 함수는 수신 객체를 첫 번째 인자로 받는 정적 메서드로 컴파일됩니다.

비용 없음: 실행 시점에 부가적인 객체 생성이나 오버헤드가 발생하지 않습니다.
자바에서 호출: 자바에서는 해당 확장 함수가 포함된 파일 이름 뒤 `Kt`가 붙은 클래스를 통해 정적 메서드로 호출합니다.

// Java 코드
char c = StringUtilsKt.lastChar("Java");

3) 확장 함수로 유틸리티 함수 정의

fun <T> Collection<T>.joinToString( // Collection<T>에 대한 확장 함수 선언
    separator: String = ", ",
    prefix: String = "",
    postfix: String = ""
): String {
	val result = StringBuilder(prefix)

    // this는 수신 객체. 여기서는 T 타입의 원소로 이루어진 Collection
    for ((index, element) in this.withIndex()) {
        if (index > 0) result.append(separator)
        result.append(element)
    }

    result.append(postfix)
    return result.toString()
}

fun main(args: Array<String>) {
    val list = arrayListOf(1, 2, 3)
    println(list.joinToString(" "))
}

원소로 이뤄진 컬렉션에 대한 확장 함수를 만들고, 모든 인자에 대한 디폴트 값을 지정하였습니다. `joinToString`을 마치 클래스의 멤버인 것처럼 호출할 수 있습니다.

4) 확장 함수는 오버라이드할 수 없습니다.

확장 함수는 클래스의 멤버가 아니며, 정적(Static) 메서드와 동일한 방식으로 동작합니다.

따라서 일반적인 객체지향의 다형성이 적용되지 않습니다.

구분	멤버 메서드 (`Override` 가능)	확장 함수 (`Override` 불가)
결정 시점	실행 시점 (Runtime)	컴파일 시점 (Compile-time)
호출 기준	객체의 실제 인스턴스 타입	변수에 선언된 타입

확장 함수는 변수의 정적 타입(컴파일 시점의 타입)에 의해 호출될 함수가 결정됩니다.

객체의 실제 동적 타입(런타임 타입)에 의해 결정되지 않음을 유의해야 합니다.

5) 확장 프로퍼티

기존 클래스에 프로퍼티 문법(점 표기법)으로 접근할 수 있는 기능을 추가할 수 있습니다.

val String.lastChar: Char
    get() = get(length - 1) // backing field가 없으므로 게터 정의 필수

확장 프로퍼티는 실제로 필드를 가질 수 없으므로, 상태를 저장할 방법이 없습니다. 즉, 초기화 코드(`init { ... }`)를 쓸 수 없으며 오직 `getter`나 `setter`만 정의할 수 있습니다.

컬렉션 처리: 가변 인자, 중위 함수 호출, 구조 분해 선언

코틀린은 자바의 컬렉션 API를 그대로 사용하면서도, 확장 함수를 통해 훨씬 편리한 사용성을 제공합니다.

1) 가변 인자 함수: `varage` 키워드

메서드를 호출할 때 인자의 개수를 자유롭게 조절할 수 있다면 `vararg` 변경자를 사용할 수 있습니다.

선언 방식: 자바의 타입 뒤 `...` 대신, 코틀린은 파라미터 앞에 `vararg`를 붙입니다.
스프레드 연산자 (`*`): 이미 존재하는 배열을 가변 인자로 넘길 때는 배열 앞에 별표(`*`)를 붙여야 합니다. 이를 통해 배열의 각 원소가 인자로 하나씩 펼쳐져서 전달됩니다.

// args = {"two", "eight"}
fun main(args: Array<String>) {
    val list = listOf("one", "two", "eight") // 가변 인자를 받는 listOf 함수
    val combinedList = listOf("one", *args) // 배열 앞에 *를 붙여 스프레드(펼침) 처리
    
    println(list) // ["one", "two", "eight"]
    println(combinedList) // ["one", "two", "eight"]
}

2) 중위 호출(Infix call) 및 구조 분해 선언

인자가 하나뿐인 메서드는 `infix` 변경자를 붙여 중위 호출 방식으로 사용할 수 있습니다. 수신 객체와 인자 사이에 메서드 이름을 넣어 가독성을 높입니다.

class Person(val name: String) {
    // infix 키워드를 붙여 중위 함수로 정의
    infix fun likes(other: Person) {
        println("${this.name}은(는) ${other.name}을(를) 좋아합니다.")
    }
}

fun main() {
    val alice = Person("Alice")
    val bob = Person("Bob")

    // 일반적인 호출 방식
    alice.likes(bob)

    // 중위 호출 방식 (마치 문장처럼 읽힘)
    alice likes bob 
}

`to` 함수는 두 원소로 이뤄어진 순서쌍 `Pair` 객체를 반환합니다. 코틀린은 `Pair`와 같은 객체의 내용을 여러 변수에 나누어 담는 구조 분해 선언을 지원합니다.

1.to("one") // 일반적인 호출 방식
1 to "one" // 중위 호출 방식 (객체 이름 인자 순서로 공백을 두어 작성)

// Pair의 내용을 즉시 두 변수에 나누어 담습니다.
val (number, name) = 1 to "one"

println(number) // 1
println(name) // "one"

`to` 함수는 확장 함수로 `to`를 사용하면 타입과 관계없이 임의의 순서쌍을 만들 수 있습니다. 이는 `to`의 수신 객체가 제네릭하기 때문입니다.

코드 다듬기: 로컬 함수와 확장

많은 개발자들은 좋은 코드의 중요한 특징 중 하나로 중복이 없는 코드를 꼽으며, 이를 DRY(Don't Repeat Yourself) 원칙이라 부릅니다. 하지만 자바에서 이 원칙을 지키기란 쉽지 않습니다. 보통 긴 메서드를 분리하기 위해 메서드 추출 리팩토링을 적용하지만, 그 결과 클래스 안에 작은 메서드가 늘어나면서 코드 흐름을 파악하기 어려워지는 문제가 생길 수 있습니다. 리팩토링을 진행하여 추출한 메서드를 별도 내부 클래스에 넣으면 코드를 깔금하게 조작할 수 있지만, 그에 따른 불필요한 코드가 늘어나게 됩니다.

코틀린은 함수에 추출한 함수를 원 함수 내부에 중첩시킬 수 있습니다.

다음 예제는 사용자를 저장하기 전 검증 로직입니다.

fun saveUser(user: User) {
    if (user.name.isEmpty()) {
        throw IllegalArgumentException(
            "Can't save user ${user.id}: empty Name")
    }
    if (user.address.isEmpty()) {
        throw IllegalArgumentException(
            "Can't save user ${user.id}: empty Address")
    }
    // ...
}

위처럼 중복되는 검증 로직을 하나의 함수로 개선한다면 다음과 같이 구현할 수 있습니다.

fun saveUser(user: User) {
    fun validate(value: String, fieldName: String) {
        if (value.isEmpty()) {
            throw IllegalArgumentException(
                "Can't save user ${user.id}: empty ${fieldName}")
        }
    }

    validate(user.name, "Name")
    validate(user.address, "Address")
    //...
}

코틀린은 확장 함수 기능이 있습니다. 이를 통해 검증 로직을 확장 함수로 만들어 좀 더 개선할 수 있습니다.

fun User.validateBeforeSave() {
    fun validate(value: String, fieldName: String) {
        if (value.isEmpty()) {
            throw IllegalArgumentException(
               "Can't save user $id: empty $fieldName")
        }
    }
    validate(name, "Name")
    validate(address, "Address")
}

fun saveUser(user: User) {
    user.validateBeforeSave()
    //...
}

요약

코틀린은 자체 컬렉션 클래스를 정의하지 않고 자바 클래스를 확장하여 더 풍부한 API를 제공한다.
함수 파라미터의 디폴트 값을 정의하면 `overloading` 함수의 필요성이 줄어든다.
코틀린은 파일에서 클래스 멤버가 아닌 최상위 함수와 프로퍼티를 직접 선언할 수 있다.
확장 함수와 프로퍼티를 사용하면 외부 라이브러리에 정의된 클래스를 포함해 모든 클래스의 API를 해당 클래스의 코드를 바꿀 필요없이 유연하게 확장할 수 있다. 확장 함수를 사용해도 실행 시점에 부가 비용이 들지 않는다.
중위 호출을 통해 인자가 하나 밖에 없는 경우 더 깔끔한 구문을 호출할 수 있다.
로컬 함수를 써서 코드를 더 깔끔하게 유지하면서 중복을 제거할 수 있다.

[Kotlin in Action 2/e] 코틀린의 기초

Hui._. — Fri, 12 Dec 2025 14:57:07 +0900

Kotlin in Action 2/e 서적을 읽으면서 정리하고자 쓴 글입니다.

kotlin logo

함수와 변수(Variables)

Java, Kotlin 각각 `Hello, world` 출력 함수를 출력하면 다음과 같습니다.

// Java
public class Main {
    public static void main(String[] args) {
    	System.out.println("Hello, world");
    }
}

// Kotlin
fun main(args: Array<String>) {
    println("Hello, world")
}

함수 선언을 할 때 `fun` (파라미터 이름: 파라미터 타입) 키워드를 사용합니다.
Java의 경우 메서드를 호출하기 위해 클래스를 선언 후 작성해야 하지만 Kotlin의 함수는 클래스 생성 없이 파일 내 최상위 수준에 위치할 수 있습니다.
Java와 달리 배열 처리를 위한 문법이 따로 존재하지 않습니다. Kotlin에서 배열은 일반적인 클래스와 동일하게 사용됩니다.
`System.out.println ` 대신 `println`을 사용합니다. Java 표준 라이브러리 함수를 간결하게 사용할 수 있도록 ` wrapper `를 제공합니다.
세미콜론(`;`)을 붙이지 않아도 됩니다.
Kotlin은 Java와 다르게 `변수: 타입`순으로 선언합니다.

1) 함수

Kotlin의 함수는 `fun` 키워드를 사용하며, 기본적인 형태는 다음과 같습니다.

fun max(a: Int, b: Int): Int {
    return if (a > b) a else b
}

함수 형태는 `fun` (파라미터 이름: 파라미터 타입): 반환 타입 { 함수 본문 }과 같습니다.

위 예시에서 주목해야 할 점은 `if`가 Statement(문)가 아니고 Expression(식)으로 사용되었다는 점입니다. 즉, 예제의 `if` 식은 Java의 삼항 연산자 ` (a < b) ? a : b `와 유사하게 동작하여 결과 값을 즉시 반환합니다.

`if` 식처럼 함수 본문 전체가 하나의 식으로만 구성되어 값을 반환하는 경우, Kotlin에서는 식이 본문인 함수 형태로 더욱 간결하게 표현할 수 있습니다. (Kotlin에서 자주 사용되는 형태)

fun max(a: Int, b: Int): Int = if (a > b) a else b

더 나아가 Kotlin은 타입 추론 기능이 있어 반환 타입을 생략할 수 있습니다. 단, 본문인 함수에서는 컴파일러가 타입을 추론할 수 없기 때문에 반드시 반환 타입을 명시하고 `return` 문을 이용해 반환 값을 명시해야 합니다.

// expression body - 반환 타입 추론 가능 (생략 OK)
fun max(a: Int, b: Int) = if (a > b) a else b

// block body - 반환 타입 명시 필요
fun max(a: Int, b: Int): Int {
    return if (a > b) a else b
}

Statement(문): 값을 만들어내지 않습니다. 자신을 둘러싼 블록의 최상위 요소만 존재합니다. (ex. `var`, `fun`, `return`, `while`)
Expression(식): 값을 만들어 냅니다. 다른 식의 하위 요소로 계산에 참여할 수 있습니다. (ex. `if`, `when`, `a+b`, 10)

2) 변수

Kotlin에서는 변수 이름 뒤에 타입을 명시하는 방식을 사용하며, 종종 타입 지정을 생략할 수 있습니다.

val age = 10 // 타입이 생략되었지만 값 10을 보고 Int 타입을 추론한다.

만약 초기화 식을 사용하지 않고 변수를 선언하려면 컴파일러가 타입을 추론할 수 없기 때문에 변수 타입을 반드시 명시해야 합니다.

val age: Int // 값 초기화 X
age = 10 // 이후 값 초기화 O

Kotlin은 변경 가능한 `var`과 불변성을 가진 `val` 2가지 키워드를 제공합니다.

키워드	유래	특징	Java 대응
`val`	Value (값)	변경 불가능한 참조(Immutable Reference) 초기화 후 재대입이 불가능합니다.	`final` 변수
`var`	Variable (변수)	변경 가능한 참조(Mutable Reference) 초기화 후 재대입이 가능합니다.	일반 변수

불변성 사용 권장 원칙

기본적으로 모든 변수를 `val` 키워드를 사용하여 불변 변수로 선언하고, 꼭 필요할 때에만 `var`로 변경하는 것을 권장합니다. 이는 불변성 기반 설계의 핵심이며 코드의 안정성을 높입니다.

`val` 변수의 초기화 규칙

`val`은 참조 자체는 불변이지만, 반드시 블록이 실행될 때 정확히 한 번만 초기화 되어야 합니다. 컴파일러가 특정 실행 경로에서 오직 하나의 초기화 문장만 실행됨을 확인할 수 있다면, 조건에 따라 `val` 값을 여러 다른 값으로 초기화할 수 있습니다.

val message: String
if (canPerformOp()) { // 특정 조건 별 분기
    message = "success"
} else {
    message = "failed"
}
// 컴파일러는 이 시점에서 message가 반드시 한 번 초기화되었음을 확인

참조의 불변성과 객체의 가변성

`val` 참조 자체는 불변이지만, 그 참조가 가리키는 객체의 내부 값은 변경될 수 없음을 유의해야 합니다.

val numbers = mutableListOf(1, 2, 3) // numbers 참조 자체는 불변
numbers.add(4) // numbers가 가리키는 객체의 내부 상태는 변경 가능하다.
// numbers = mutableListOf(5) 재대입 시도 시 컴파일 오류 발생!!

클래스와 프로퍼티

Kotlin은 데이터를 저장하는 클래스, 특히 값 객체(Value Object)를 간결하게 정의할 수 있도록 지원합니다.

// Java
public class Person {
    private final String name;
    public Person(String name) { this.name = name; }
    public getName() { return name; }
}

// Kotlin
class Person(val name: String)

위처럼 데이터만을 포함하는 클래스는 Kotlin의 간결성을 극대화하는 대표적인 예시입니다.

1) 프로퍼티

클래스의 주된 목적은 데이터를 캡슐화하고, 데이터를 다루는 코드를 하나의 주체 아래에 통합하는 것입니다.

Java 방식: 데이터를 필드(Field)에 저장하고, 이 필드에 접근할 수 있는 통로로 접근 메서드(Accessor Method)인 getter/setter를 제공합니다. Java에서는 필드와 해당 접근자 메서드를 묶어 프로퍼티라고 관례적으로 부릅니다.

Kotlin 방식: 프로퍼티 개념을 언어의 기본 기능으로 제공하며, Java의 필드와 접근자 메서드를 완전히 대신합니다.

선언: Kotlin에서 프로퍼티를 선언할 때는 변수와 마찬가지로 `val`과 `var` 키워드를 선언합니다.

키워드	프로퍼티 유형	자동 생성 접근자
`val`	읽기 전용 프로퍼티	비공개 필드와 getter만 선언합니다.
`var`	변경 가능한 프로퍼티	비공개 필드와 getter/setter 모두 선언합니다.

2) 커스텀 접근자

프로퍼티는 단순히 값을 저장하는 필드 역할뿐만이 아닌 접근할 때도 특정 로직을 실행하도록 정의할 수 있습니다.

커스텀 `getter` 정의

직사각형을 표현하는 `Rectangle` 클래스에 해당 사각형이 정사각형인지 여부를 판단하는 기능을 커스텀 `getter`로 구현할 수 있습니다. 이 경우 별도의 필드를 만들어 상태를 저장할 필요가 없습니다.

class Rectangle(
    val height: Int,
    val width: Int
) {
    val isSquare: Boolean
        get() = height == width
}

fun run() {
    val r = Rectangle(10, 10)
    println("${r.isSquare}") // 출력: true
}

위처럼 `getter`를 호출할 때마다 값을 새로 계산합니다. 즉, `Rectangle`의 `height`나 `width`가 변경된다면, `isSquare` 프로퍼티를 호출할 때마다 변경된 값을 반영한 최신 결과를 얻을 수 있습니다.

enum & when

1) `enum` 클래스

Kotlin에서 `enum`은 Soft keyword입니다. 즉, 예약어로 동작하는 것이 아니라 `enum class` 형태로 `class` 앞에 사용될 때만 특별한 의미를 가지게 됩니다. 단순히 상수를 열거하는 것 이상으로, 프로퍼티와 메서드를 가질 수 있는 완전한 클래스입니다.

enum class Color(val r: Int, val g: Int, val b: Int) {
    RED(255, 0, 0), ORANGE(255, 165, 0), YELLOW(255, 255, 0),
    GREEN(0, 255, 0), BLUE(0, 0, 255); // 상수 목록 끝에 세미콜론 필수

    fun rgb() = (r * 256 + g) * 256 + b // 메서드 정의
}

2) `when` 식

Kotlin은 Java의 `switch`문을 대체하면서 더 강력한 기능을 제공하는 `when`이 있습니다. `when`은 문(Statement)이 아닌 식(Expression)이므로 결괏값을 반환할 수 있습니다.

fun getWarmth(color: Color) = when(color) {
    Color.RED, Color.ORANGE, Color.YELLOW -> "warm"
    Color.GREEN -> "neutral"
    Color.BLUE, Color.INDIGO, Color.VIOLET -> "cold"
}

Java와 달리 각 분기 끝에 `break`를 넣지 않아도 되며, 한 분기 안에서 여러 값을 매칭하려면 콤마(`,`)로 연결합니다. 또한 Java와 달리 `when`의 분기 조건에 상수 뿐만이 아닌 임의의 객체를 사용할 수 있습니다.

fun mix(c1: Color, c2: Color) = when (setOf(c1, c2)) {
    setOf(Color.RED, Color.YELLOW) -> Color.ORANGE
    setOf(Color.YELLOW, Color.BLUE) -> Color.GREEN
    else -> throw Exception("Dirty color")
}

위 처럼 `setOf`를 통해 두 색상의 순서와 상관없이 조합을 검사할 수 있습니다.

다만 위 방식은 setOf를 호출할 때마다 새로운 Set 객체가 생성되므로, 함수가 자주 호출되는 경우 불필요한 임시 객체와 가비지 컬렉션 부담이 발생할 수 있습니다.

Kotlin은 이러한 상황을 위해 인자 없는 `when`을 사용할 수 있습니다.

fun mixOptimized(c1: Color, c2: Color) = when {
    (c1 == RED && c2 == YELLOW) ||
    (c1 == YELLOW && c2 == RED) -> ORANGE

    (c1 == YELLOW && c2 == BLUE) ||
    (c1 == BLUE && c2 == YELLOW) -> GREEN

    (c1 == BLUE && c2 == VIOLET) ||
    (c1 == VIOLET && c2 == BLUE) -> INDIGO

    else -> throw Exception("Dirty color")
}

3) 스마트 캐스트

Kotlin 컴파일러는 형 변환을 자동으로 수행해 주는 스마트 캐스트 기능을 제공합니다.

`is` 연산자: Java의 `instanceof`와 비슷하게 타입을 검사합니다.
스마트 캐스팅: `is`로 타입을 검사하고 나면, 컴파일러가 해당 블록 내에 변수를 해당 타입으로 간주하므로 명시적인 캐스팅(`as`) 없이 프로퍼티를 사용할 수 있습니다.

fun eval(e: Expr): Int = when (e) {
    is Num -> e.value // 스마트 캐스트 적용
    is Sum -> eval(e.left) + eval(e.right) // 스마트 캐스트 적용
    else -> throw IllegalArgumentException("Unknown expression")
}

4) `if`와 `when`의 리팩토링 및 블록 사용

Kotlin은 `if` 역시 식(Exprssion)이므로 값으로 반환할 수 있습니다. 따라서 Java와 같은 별도의 3항 연산자가 없습니다.

val result = when (e) {
    is Num -> {
        println("value: ${e.value}")
        e.value // 이 블록의 결과값
    }
    // ...
}

while과 for loop

Kotlin의 `while` & `do-while`의 경우 Java와 완전히 동일한 구조를 가지고 있습니다.

`for loop`의 경우 Java의 고전적인 `int i = 0; i < 10; i++` 방식이 존재하지 않으며, Kotlin은 범위 연산자를 사용합니다.

1) 수에 대한 이터레이션: 범위와 순열

표현식	설명	Java 대응 코드
1..10	1부터 10까지 (10포함)	i = 0; i <= 10; i++
1 until 10	1부터 9까지	i = 0; i < 10; i++
10 downTo 1	10부터 1까지 역순	i = 10; i >= 1; i--
step 2	2씩 증가 (간격 설정)	i += 2

// 1. 기본 범위 반복 (10 포함)
for (i in 1..10) { // a..z 로 사용해도 a b c d e f g... 출력
    print("$i ") // 1 2 3 ... 10
}

// 2. 마지막 숫자 제외 (until) - 배열 인덱스 순회 시 유용
val list = listOf("Java", "Kotlin", "Spring")
for (i in 0 until list.size) {
    println("Index $i: ${list[i]}")
}

// 3. 역순 및 간격 설정 (downTo, step)
for (i in 10 downTo 1 step 2) {
    print("$i ") // 10 8 6 4 2
}

// 4. 컬렉션 직접 순회 (for-each 스타일)
for (lang in list) {
    println("Learning $lang")
}

// 5. 인덱스와 값을 동시에 추출 (withIndex)
for ((index, value) in list.withIndex()) {
    println("[$index]: $value")
}

2) `in`으로 컬렉션이나 범위의 원소 검사

`in` 연산자를 통해 어떤 값이 범위에 속하는지, 반대로 `!in`을 사용한다면 범위에 속하지 않는지 검사할 수 있습니다.

fun isLetter(c: Char) = c in 'a'..'z' || c in 'A'..'Z'
fun main() {
    println(isLetter('h')) // true
    println(isLetter('11')) // false
}

fun recognize(c: Char) = when (c) {
    in '0'..'9' -> "It's a digit!"
    in 'a'..'z', in 'A'..'Z' -> "It's a letter!"
    else -> "I don't know…"
}
fun main() {
    println(recognize('8')) // It's a digit!
}

Kotlin의 예외처리

Kotlin의 예외처리는 Java나 다른 언어의 예외처리와 비슷합니다.

1) try, catch, finally를 사용한 예외처리와 오류 복구

Java 코드와 가장 큰 차이는 `throws` 절이 Kotlin에 없다는 점입니다.

fun readNumber (reader: BufferedReader): Int {
    try {
    	val line = reader.readLine()
    	return Integer.parseInt(line)
    } catch (e: NumberFormatException) {
    	return 0
    } finally {
    	reader.close()
    }
}

Kotlin은 모든 예외를 언체크 예외(Unchecked Exception)로 취급합니다. 따라서 Java와 달리 `throws`를 명시하거나 예외 처리를 강제할 필요가 없어 코드가 간결해집니다.

또한 `try-with-resources` 대신 표준 라이브러리의 `.use` 확장 함수를 사용해 리소스를 안전하게 해제할 수 있습니다.

// Kotlin: .use() 확장 함수 사용
val line = BufferedReader(FileReader(path)).use { br ->
    br.readLine()
}
// 블록을 나가는 순간 자동으로 br.close() 호출

2) try를 식으로 사용

`try`문 또한 식(Expression)으로 사용할 수 있습니다.

fun readNumber (reader: BufferedReader) { 
     val number = try {
        Integer.parseInt(reader.readLine()) // 이 식의 값이 try 식의 값이 된다.
     } catch (e: NumberFormatException) { 
        return 
    }
    println(number)
}

`if`와 달리 `try`의 본문을 중괄호 {}로 둘러싸야합니다.

요약

함수를 정의할 때 `fun` 키워드를 사용하며, val는 읽기 전용 변수, var는 변경 가능한 변수를 선언할 때 쓰인다.
Kotlin의 `if`는 식(Expression)이며, 값을 만들 수 있다.
Java의 `switch`를 대체하며, 더 강력한 기능을 제공하는 `when`이 있다.
스마트 캐스팅: 어떤 변수의 타입을 검사하면 직접 캐스팅하지 않아도 형 변환을 한 변수처럼 사용할 수 있다.
`1..5`와 같은 식으로 범위를 나타낼 수 있고, 어떤 값이 범위 안에 들어있거나 들어있지 않은지 검사하기 위해 `in`이나 `!in`을 사용할 수 있다.
Kotlin의 예외처리는 Java와 비슷하다. 다만 함수가 던질 수 있는 예외를 선언하지 않아도 된다. (언체크 예외)

[Kotlin in Action 2/e] 코틀린이란 무엇이며, 왜 필요한가?

Hui._. — Fri, 12 Dec 2025 11:28:42 +0900

Kotlin in Action 2/e 서적을 읽으면서 정리하고자 쓴 글입니다.

왜 JetBrains는 Kotlin을 만들었는가

JetBrains는 IntelliJ IDEA를 만든 회사로 내부 서비스와 툴 대부분 Java로 이루어져 있으며 다음과 같이 불편이 누적되었습니다.

Java의 장황한 문법 (Boilerplate)
안전하지 않는 Null 처리
더 생산적이고 간결한 코드에 대한 실용적인 요구 증가 (모던한 방식)

C#처럼 모던한 방식을 원했고, 기존 Java로 이뤄진 코드를 호환할 수 있는 언어를 찾아보았으나 그러한 언어가 없었습니다. 그렇게 JetBrains는 Java와 호환성이 좋고, 모던함을 갖추고자 실용적인 언어 Kotlin을 만들기로 결정합니다.

Kotlin은 코틀린 개발 팀이 대부분 살고 있는 러시아의 상트페테르부르크 근처에 있는 섬이름을 따서 만든 이름입니다. Java나 Ceylon 같이 언어 기원의 전통을 따른 것인데, 고향에 가까운 섬의 이름을 따왔습니다.

Kotlin이 무엇이고, 왜 써야하는가

Java보다 더 모던한 방식이며서 Java로 만든 라이브러리, 프레임워크, SDK를 이용할 수 있는 언어가 필요하였고, 위 조건을 충족할 수 있는 목표로 만들어진 언어가 Kotlin입니다. 아래는 Java 코드를 Kotlin으로 변환하면 어떻게 되는지 알 수 있습니다.

Java 코드

public class Main {
    public static void main(String[] args) {
        List<Person> persons = List.of(
                new Person("owen"),
                new Person("bella", 29)
        );

        Person oldPerson = persons.stream()
                .max(Comparator.comparingInt(p -> p.getAge() != null ? p.getAge() : 0))
                .orElse(null);
        System.out.println("나이가 가장 많은 사람: " + oldPerson);
    }
}

class Person {
    private String name;
    private Integer age; // nullable

    public Person(String name) {
        this(name, null);
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person(name=" + name + ", age=" + age + ")";
    }
}

Kotlin 코드

fun main() {
    val persons = listOf(
        Person("owen"),
        Person("bella", 29)
    )

    val oldPerson = persons.maxBy { it.age ?: 0 }
    println("나이가 가장 많은 사람: $oldPerson")
}

data class Person(val name: String, val age: Int? = null)

40줄이 넘는 코드가 10줄 정도로 줄어드는 마술을 보면 왜 Kotlin을 써야 하는지 알 수 있습니다.

Kotlin은 다음과 같은 특성들이 있습니다.

1) 활용 플랫폼

Kotlin은 JVM 위에 동작하는 언어지만 여러 플랫폼에서 사용할 수 있습니다.

JVM 기반 활용

Spring Boot, Android 등 Java가 동작하는 곳이라면 그대로 Koltin을 사용할 수 있습니다.

멀티 플랫폼 지원

Koltin/JS → React, Node.js 환경에서 동작

Kotlin/Native → IOS, Windows, macOS, Linux에서 실행 가능

Kotlin Multiplatform → 비즈니스 로직 공유가 가능하여 mobile/web/back-end 공통 로직을 하나로 유지 가능

2) 정적 타입 언어 (+ 타입 추론)

Kotlin은 정적 언어이기 때문에 안정성을 확보하면서도 타입 추론을 지원해 코드가 간결합니다.

타입 추론

타입을 직접 쓰지 않아도 Kotlin은 타입을 추론합니다. 하지만 추론이 과도하면 상위 타입이 강제로 할당되거나 의도한 타입이 모호해지는 경우가 있을 수 있어 주의가 필요합니다.

val age = 20     // Int 추론
val name = "Kim" // String 추론

Unit 타입 (Java의 void와 차이)

Kotlin에서는 반환값을 명시하지 않은 함수도 내부적으로는 항상 `Unit`타입을 반환합니다. 이 `Unit`은 Java의 `void`처럼 “아무것도 없다”는 의미가 아니라, 하나의 값만 존재하는 정상적인 타입입니다. 개념적으로는 Java의 `void`보다는 `Void` 클래스에 가깝기 때문에 값처럼 전달하거나 파라미터로 사용할 수 있습니다.

// Kotlin에서는 반환값이 없는 함수도 "Unit" 타입을 반환합니다.
// 즉, 이 함수의 실제 시그니처는 fun test1(): Unit 입니다.
fun test1() {
    println("Hello")
}

// Unit을 파라미터 타입으로 받는 함수 정의가 가능합니다.
fun test2(value: Unit) {
    value // Unit은 실제로 객체처럼 전달이 가능하다.
}

// test1()을 호출하면 println은 수행되지만, 반환값으로 Unit 인스턴스가 반환됩니다.
// 이 Unit 값이 test2의 파라미터로 정상 전달됩니다.
fun main() {
    test2(test1())
}

3) 객체 지향(OOP) + 함수형 프로그래밍(FP)을 모두 갖춘 멀티 패러다임

Kotlin은 객체지향과 함수형 두 접근 방식을 상황에 따라 혼합할 수 있습니다.

일급 함수

함수가 다른 일반적인 값(변수, 객체 등)과 동일한 자격을 갖는 것을 의미합니다.

// 1. 함수 정의 (A: 일반 함수)
val sum: (Int, Int) -> Int = { a, b -> a + b }

// 2. 함수 타입 정의 및 변수에 함수 할당 (Function Reference 사용)
// ::sum 은 sum 함수 자체를 참조(Reference)하는 것을 의미합니다.
// (Int, Int) -> Int 는 이 함수의 타입(signature)을 의미합니다.
val myOperation: (Int, Int) -> Int = ::sum 

// 3. 변수에 할당된 함수 실행
val result = myOperation(10, 5) 
println("결과: $result") // 결과: 15

// 4. 함수를 리스트에 저장
val functionList = listOf(::sum)

고차 함수

다른 함수를 인자로 받거나 함수를 결과로 반환하는 함수를 말합니다. 일급 함수 개념이 있기 때문에 고차 함수를 만들 수 있습니다.

fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int = op(a, b)

val result = operate(3, 5) { x, y -> x + y } // Kotlin은 람다 함수를 뒤로 뺄 수 있다.
println("결과: $finalResult") // 결과: 8

선언형 프로그래밍

Java가 `stream()`을 통해 컬렉션 파이프라인을 구축하는 반면, Kotlin은 컬렉션 API의 확장 함수들을 바로 연결하여 데이터의 변환 및 필터링 흐름을 명령형 코드보다 더욱 직관적인 파이프라인 구조로 설계할 수 있습니다.

// Java21
var names = List.of("A", "B", "C")
var result = names.stream()
	.map(String::toLowerCase)
    .filter(s -> s.startWith("a"))
    .toList();
System.out.println(result); // [a]

// Kotlin
val names = listOf("A", "B", "C")
val result = names
	.map { it.lowerCase() }
	.filter { it.startsWith("a") }
println(result) // [a]

4) 안드로이드 프로그래밍

Kotlin은 Android 공식 언어로 선정되었으며, 많은 최적화가 적용되어 있습니다.

Jetpack Compose

Google의 최신 UI 프레임워크인 Jetpack Compose는 Kotlin API를 활용하여 선언 UI를 구축하는 대표 사례입니다. 이는 Kotlin의 DSL(Domain-Spectofoc Language)적인 특성을 살린 모던한 개발 방식입니다.

@Composable
fun Greeting(name: String) {
    Text(text = "Hello $name")
}

Kotlin과 Java와 비교했을 때 성능 차이가 없다.

Kotlin으로 작성된 애플리케이션은 최종적으로 JVM 바이트코드로 컴파일되므로, 기존 Java와 성능 차이가 거의 없습니다. 또한 런타임 시스템의 용량이 작기 때문에 패키지(APK/AAB) 크기에 미치는 영향이 미미합니다.

Kotlin의 고차 함수는 인자로 받은 람다를 `inline`처리합니다. (함수에 함수를 호출하지만 마치 하나의 함수로 호출되는 마술) 이를 통해 람다를 호출할 때 새로운 객체가 생성되는 것을 방지합니다. 이는 GC 활동을 줄여 성능의 효율을 높일 수 이습니다.

5) Kotlin의 철학: 실용성 · 간결성 · 안정성 · 상호 운용성

실용성 (Practicality)

학술적 언어가 아닌 실전 문제를 해결하기 위한 언어
IntelliJ 기반이라 IDE 지원이 매우 뛰어남 (자동 변환, 리팩토링, 빠른 인스펙션)

간결성 (Conciseness)

getter/setter, 생성자, 데이터 객체 등 모두 간결하게 작성할 수 있습니다.

// Java
class Person {
    private String name;
    public Person(String name) { this.name = name; }
    public String getName() { return name; }
    public String setName(String name) { this.name = name; }
}

// Kotlin: data class로 선언하면 기본적으로 getter/setter를 생성해준다.
data class Person(val name: String)

fun main() {
    val person = Person("hun")
    println("이름은 ${person.name}입니다.") // 이름은 hun입니다.
}

안정성 (Safety)

다양한 문법적 안전장치(Null 안정성, 스마트 캐스트 등)를 제공합니다.

// 1. Non-nullable Type: 변수를 선언할 때 기본적으로 `null`값을 허용하지 않습니다.
var name: String = "hun"
name = null // 컴파일 오류 발생!!

// 2. Nullable Type: 변수에 `null`을 저장하려면 타입 뒤에 물음표(?)를 명시적으로 붙여야 합니다.
var age: Int? = 20
name = null // 허용

// 3. 안전 호출 연산자(?.): `null` 아닌 경우 메서드나 프로퍼티 호출을 보장합니다.
val length = name?.toString()?.length // age가 null이면 전체 결과는 null

// 4. elvis 연산자(?:): 안전 호출 결과가 `null`인 경우 대신 사용할 값을 지정합니다.
val safeLength = age?.toString()?.length ?: 0 // age가 null이면 0 사용

// 5. 스마트 캐스트 (Smart Casts): 타입 검사 후 명시적 형 변환 없이 바로 해당 타입을 사용할 수 있습니다.
fun printLength(x: Any) { // Any: Java의 Object 클래스처럼 Kotlin의 최상위 타입이다.
	if (x is String) { // x instanceOf String
    	print(x.length) // 타입 검사가 유효하다면 x는 Any -> String으로 캐스팅된다.
    }
}

// 6. 예외 안전 처리 runCatching 함수: try-catch를 함수형 스타일로 사용할 수 있는 표준 라이브러리 함수
// 성공하면 결과를, 예외가 발생하면 "fallback value"를 반환
val result = runCatching {
	riskOp(); // 예외가 발생할 수 있는 함수
}.getOrDefault("fallback value")

상호 운용성 (Interoperability)

프로젝트 내 Java와 Kotlin으로 작성된 클래스가 각각 있을 때 서로 의존해도 아무런 호환 문제가 없습니다.

단, Java에서 가져온 클래스를 Kotlin에서 사용할 때, Java는 기본적으로 `null` 가능성을 명시적으로 처리하지 않기 때문에 해당 타입은 코틀린에서 플랫폼 타입으로 인식됩니다. 플랫폼 타입은 `null` 허용 여부 정보가 없어 코틀린의 `null` 안정성 시스템을 보장받지 못하기 때문에 이를 주의해서 사용해야 합니다.

Kotlin Build 과정

Kotlin Build

1. 소스 코드 작성 (.kt 파일)

입력: 개발자가 작성한 Kotlin 소스 파일 (.kt)

2. Kotlin Compiler (kotlinc)

역할: 코틀린 컴파일러(kotlinc)는 `.kt` 파일을 JVM이 이해할 수 있는 형태로 변환합니다.
출력: 표준 자바 클래스 파일 포맷인 `.class` 파일(바이트코드)이 생성됩니다.
상호 운용성 핵심: 이 바이트코드는 자바 컴파일러가 생성한 바이트코드와 완벽히 호환됩니다. 따라서 코틀린과 자바 코드가 서로를 호출할 수 있으며, 기존 자바 라이브러리를 그대로 사용할 수 있습니다.

3. 패키징 및 최종 아티팩트 생성

JVM (back-end/desktop): `.class` 파일들을 모아 `META-INF/services` 등의 메타 데이터와 함께 압축 → `.jar` (Java Archive)

4. 애플리케이션 실행 환경 및 런타임 의존성

최종 아티팩트가 실행될 때, 해당 애플리케이션은 코틀린 런타임(Kotlin Runtime) 라이브러리에 의존합니다.

Kotlin Runtime: 코틀린의 표준 라이브러리(kotlin-stdlib.jar)를 의미합니다. 이 라이브러리는 확장 함수, 기본 함수, 코틀린만의 컬렉션 인터페이스 등 코틀린 언어의 고유한 기능을 지원하는 데 필요한 클래스들을 포함하고 있습니다.
의존성: 이 런타임 라이브러리는 최종 `.jar`에 포함되어 배포되어야 애플리케이션이 실행될 수 있습니다.

JVM 바이트코드 사용: 코틀린은 자바와 동일한 바이트코드를 사용하므로, 코틀린 파일과 자바 파일은 한 프로젝트 내에서 함께 컴파일되고 실행될 수 있습니다.

Kotlin Runtime 포함: 코틀린 고유의 문법을 지원하기 위해 소형의 표준 라이브러리(런타임)가 최종 애플리케이션에 포함됩니다.

백준 15990번: 1, 2, 3 더하기 5

Hui._. — Mon, 13 Jan 2025 22:56:38 +0900

https://www.acmicpc.net/problem/15990

백준 15990번: 1, 2, 3 더하기 5

문제풀이

위 문제는 1, 2, 3의 합으로 표현하는 모든 경우를 구하여야 합니다. 또한 같은 숫자를 연속해서 2번 이상 사용할 수 없습니다. 즉 마지막으로 사용한 숫자가 다시 연속으로 등장하면 안됩니다.

이 조건을 만족하기 위해 각 경우의 마지막으로 사용된 숫자를 명시적으로 관리해야 합니다.

이를 위해 2차원 배열을 사용해 dp[i][j]를 다음과 같이 정의합니다.

dp[i][j]: i를 1, 2, 3의 합으로 나타날 때 마지막 숫자가 j인 경우의 수

왜 2차원 배열을 써야할까?

마지막으로 사용된 숫자를 추척함으로써, 같은 숫자가 연속해서 등장하지 않도록 관리할 수 있으며, 이를 통해 결과를 계산한다면 dp[i][1], dp[i][2], dp[i][3]의 값을 합하면 i를 만드는 모든 경우의 수를 구할 수 있기 때문입니다.

만약 dp[i]를 단순히 i를 만드는 모든 경우의 수로 정의한다면 마지막 숫자가 무엇인지 알 수 없습니다. 또한 점화식을 세울 때 중복된 계산이 발생하거나, 조건을 만족하는 않는 경우를 포함할 위험이 있습니다.

점화식 설명

2차원 배열 dp[i][j]는 위에서 "i를 1, 2, 3의 합으로 나타날 때 마지막 숫자가 j인 경우의 수"라고 정의했습니다.

수식의 마지막이 + 3 이라면 j는 1 or 2이 될 수 있습니다.

수식의 마지막이 + 2 이라면 j는 1 or 3이 될 수 있습니다.

수식의 마지막이 + 1 이라면 j는 2 or 3이 될 수 있습니다.

i를 7로 보고 1, 2, 3의 합을 나타낸다면 다음과 같이 볼 수 있습니다.

4 에서 3을 더해주고,

5 에서 2를 더해주고,

6 에서 1을 더해주면 각각 7이 됩니다.

7을 만들 수 있는 수식 중 3으로 끝나는 수식(마지막에 + 3인 경우)은

4를 만드는 수식에서 1(으)로 끝나는 것에 3을 더 하는 것

4를 만드는 수식에서 2(으)로 끝나는 것에 3을 더 하는 것

즉, dp[7][3] = dp[4][1] + dp[4][2] 입니다.

이를 점화식으로 표현하면 dp[n][3] = dp[n - 3][1] + dp[n - 3][2] 입니다.

7을 만들 수 있는 수식 중 2로 끝나는 수식(마지막에 + 2인 경우)은

5를 만드는 수식에서 1(으)로 끝나는 것에 2를 더 하는 것

5를 만드는 수식에서 3(으)로 끝나는 것에 2를 더 하는 것

즉, dp[7][2] = dp[5][1] + dp[5][3] 입니다.

이를 점화식으로 표현하면 dp[n][2] = dp[n - 2][1] + dp[n - 2][3] 입니다.

7을 만들 수 있는 수식 중 1로 끝나는 수식(마지막에 + 1인 경우)은

6을 만드는 수식에서 2(으)로 끝나는 것에 1을 더 하는 것

6을 만드는 수식에서 3(으)로 끝나는 것에 1을 더 하는 것

즉, dp[7][1] = dp[6][2] + dp[6][3] 입니다.

이를 점화식으로 표현하면 dp[n][1] = dp[n - 1][2] + dp[n - 1][3] 입니다.

이를 그림으로 표현한다면

7을 i로 즉, 점화식으로 설명한다면 다음과 같습니다.

마지막이 3으로 끝나는 경우 (dp[i][3])

i - 3 에서 1로 끝나는 경우 3을 더함
i - 3 에서 2으로 끝나는 경우 3을 더함
dp[i][3] = (dp[i − 3][1]+dp[i − 3][2])

마지막이 2로 끝나는 경우 (dp[i][2])

i - 2 에서 1로 끝나는 경우 2를 더함
i - 2 에서 3으로 끝나는 경우 2를 더함
dp[i][2] = (dp[i − 2][1]+dp[i − 2][3])

마지막이 1로 끝나는 경우 (dp[i][1])

i - 1 에서 2로 끝나는 경우 1을 더함
i - 1 에서 3으로 끝나는 경우 1을 더함
dp[i][1] = (dp[i − 1][2]+dp[i − 1][3])

위와 같은 과정을 통해 n >= 4 일 때

dp[i][1] = dp[i - 1][2] + dp[i - 1][3]

dp[i][2] = dp[i - 2][1] + dp[i - 2][3]

dp[i][3] = dp[i - 3][1] + dp[i - 3][2] 라는 점화식이 나옵니다.

주어진 n에 대해 마지막으로 사용한 숫자가 다시 연속으로 등장하지 않도록 각자 마지막에 끝나는 숫자 1, 2, 3을 별도로 관리하여 합한 후, 마지막으로 dp[n][1], dp[n][2], dp[n][3]을 모두 더한 값이 정답이 됩니다.

dp[n][1] + dp[n][2] + dp[n][3]

문제에서는 1,000,000,009로 나눈 나머지를 출력하라고 되어 있기 때문에 코드는 다음과 같습니다.

1,000,000,009 으로 나눈 이유는?

n이 커질수록 가능한 경우의 수가 매우 커지게 됩니다. 이를 % 연산으로 적용된 dp[n]을 저장하지 않는다면 overflow가 발생할 수 있습니다. 따라서, 1,000,000,009로 나눈 나머지를 저장함으로써 결과의 안정성을 확보할 수 있습니다.

코드

public class Main {

    private static final int MAX = 100_000;
    private static final int DIVISOR = 1_000_000_009;

    public static void main(String[] args) throws Exception {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
             BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out))
        ) {
            int t = Integer.parseInt(br.readLine());
            int[] arr = new int[t];
            for (int i = 0; i < t; i++) {
                arr[i] = Integer.parseInt(br.readLine());
            }
            for (long a : solution(t, arr)) {
                bw.write(a + "\n");
            }
            bw.flush();
        }
    }

    private static List<Long> solution(int n, int[] arr) {
        List<Long> list = new ArrayList<>();

        // dp[i][j]일 때 i가 4인 경우, j는 수식 마지막에 더하는 값
        // ex) i = 4, j = 1 or 2 or 3
        // dp[4][1] = (1+2+1, 3+1) = 경우의 수 2개
        // dp[4][2] = (x) = 경우의 수 0개
        // dp[4][3] = (1+3) = 경우의 수 1개
        // 총 경우의 수는 dp[4][1] + dp[4][2] + dp[4][3] = 3개
        long[][] dp = new long[MAX + 1][4];
        dp[1][1] = 1; // 1
        dp[2][2] = 1; // 2
        dp[3][1] = 1; // 1+2
        dp[3][2] = 1; // 2+1
        dp[3][3] = 1; // 3

        for (int i = 4; i <= MAX; i++) {
            dp[i][1] = (dp[i - 1][2] + dp[i - 1][3]) % DIVISOR;
            dp[i][2] = (dp[i - 2][1] + dp[i - 2][3]) % DIVISOR;
            dp[i][3] = (dp[i - 3][1] + dp[i - 3][2]) % DIVISOR;
        }

        for (int i : arr) {
            long answer = (dp[i][1] + dp[i][2] + dp[i][3]) % DIVISOR;
            list.add(answer);
        }

        return list;
    }
}

public class Main {

    static long [][] dp = new long[100_001][4];
    static long mod = 1_000_000_009;

    public static void main(String[] args) throws Exception {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
             BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out))
        ) {
            int t = Integer.parseInt(br.readLine());
            int[] arr = new int[t];

            for (int i = 0; i < t; i++) {
                arr[i] = Integer.parseInt(br.readLine());
            }

            StringBuilder sb = new StringBuilder();
            dp[1][1] = dp[2][2] = dp[3][1] = dp[3][2] = dp[3][3] = 1;
            int i = 4;

            for (int n : arr) {
                while (i <= n) {
                    dp[i][1] = (dp[i - 1][2] + dp[i - 1][3]) % mod;
                    dp[i][2] = (dp[i - 2][1] + dp[i - 2][3]) % mod;
                    dp[i][3] = (dp[i - 3][1] + dp[i - 3][2]) % mod;
                    i++;
                }
                long rs = (dp[n][1] + dp[n][2] + dp[n][3]) % mod;
                sb.append(rs).append("\n");
            }

            bw.write(sb.toString());
            bw.flush();
        }
    }
}

백준 2563번: 색종이

Hui._. — Wed, 28 Aug 2024 11:37:53 +0900

https://www.acmicpc.net/problem/2563

백준 2563번: 색종이

문제 풀이

가로와 세로 길이가 각각 100인 도화지가 있습니다. 이 도화지 위에 가로와 세로 크기가 각각 10인 색종이 N장을 붙입니다. 색종이는 도화지의 변과 평행하게 붙이며, 색종이가 겹칠 수 있습니다. 이 문제는 겹치는 부분을 고려하여 총 검은색 영역의 넓이를 계산하는 문제입니다.

수학적으로 푼다면 넓이를 계산하고 겹친 부분을 뺀다면 쉽게 구할 수 있으나, 해당 문제는 알고리즘으로 풀어야 합니다. 우선 도화지를 나타낼 배열을 [100][100] 크기로 생성합니다. 이때 타입은 boolean으로 하여 ture는 포함, false는 미포함으로 구분합니다.

즉, 어떤 수 x, y에 대해 배열[x][y]가 true이면 그 부분은 색종이가 붙어져 있다는 것을 뜻합니다.

입력 받은 색종이를 N개를 입력 받고, 색종이의 x, y이 주어지면 x, y ~ x + 9, x + 9까지 순회하면서 색종이를 붙입니다. 이때 이미 붙여진 색종이가 있다면 제외하고 붙였다면 넓이 값을 +1 해줍니다. 순회가 끝나면 총 넓이가 구해집니다.

코드

import java.util.Scanner;

public class Main {

    private static final int SIZE = 100;

    public static void main(String[] args) {
        boolean[][] arr = new boolean[SIZE][SIZE];
        int answer = 0;

        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        for (int i = 0; i < n; i++) {
            int x = sc.nextInt();
            int y = sc.nextInt();

            for (int j = x; j < x + 10; j++) {
                for (int k = y; k < y + 10; k++) {
                    if (!arr[j][k]) {
                        arr[j][k] = true;
                        answer++;
                    }
                }
            }
        }

        System.out.print(answer);
    }
}

Invalid bean definition with name 'jpaAuditingHandler'...

Hui._. — Mon, 19 Aug 2024 15:05:52 +0900

서론

사이드 프로젝트를 진행하면서 전체 테스트 코드를 실행시켰더니 다음과 같은 예외가 발생하였습니다.

Caused by: org.springframework.beans.factory.support.BeanDefinitionOverrideException: Invalid bean definition with name 'jpaAuditingHandler' defined in null: Cannot register bean definition...

멀쩡하게 돌아가던 테스트가 안되니 식은 땀이 났고, 문제를 찾아보니 테스트 코드에 @EnableJpaAuditing를 붙여 발생한 해프닝이였습니다... BeanDefinitionOverrideException은 동일한 이름의 Bean이 여러 번 등록되려고 할 때 발생됩니다.

문득 문제 원인에 대해 구체적으로 알고 싶어 포스트를 정리하게 되었습니다.

문제의 원인

@EnableJpaAuditing은 JPA Auditing 기능을 활성화하기 위해 사용됩니다. 이 기능을 활성화하면 엔티티가 생성되거나 수정될 때 자동으로 시간과 사용자를 기록하는 등의 작업을 할 수 있습니다.

문제는 @EnableJpaAuditing이 애플리케이션의 main 클래스나 별도의 설정 클래스뿐만 아니라 테스트 컨텍스트에서도 중복으로 등록될 때 발생합니다. Spring Boot는 애플리케이션 실행 시와 테스트 실행 시 각각의 애플리케이션 컨텍스트를 생성합니다. 이 과정에서 두 개의 @EnableJpaAuditing이 발견되면, Spring은 2번 JpaAuditingHandler를 생성하려고 시도하며, 이로 인해 Bean 중복 등록으로 충돌이 발생합니다.

이러한 문제는 특히 @SpringBootTest를 사용할 때 발생할 가능성이 큽니다. @SpringBootTest는 기본적으로 전체 애플리케이션 컨텍스트를 로드하기 때문에, @EnableJpaAuditing이 설정된 클래스가 이미 로드된 상태에서 또 다른 @EnableJpaAuditing이 포함된 설정이 테스트 컨텍스트에 포함되면서 충돌이 발생할 수 있습니다.

해결 방법

해결 방법은 테스트 코드 내 문제 부분의 코드(@EnableJpaAuditing)를 지우면 됩니다.

만약 테스트 클래스에 조건부로 설정하고 싶다면 어떻게 해야할까요?

테스트에 필요한 설정을 별도로 적용하고 싶다면, @TestConfiguration을 사용하여 필요한 설정을 조건적으로 추가하는 방법이 있습니다. 그러나, @EnableJpaAuditing을 테스트에 직접 사용하는 것을 권장하지는 않습니다.

@TestConfiguration
static class TestConfig {
    @Bean
    @ConditionalOnMissingBean
    public AuditingHandler jpaAuditingHandler() {
        return new AuditingHandler();
    }
}

요약

테스트 클래스에서 @EnableJpaAuditing을 사용하는 경우, JpaAuditingHandler Bean이 중복 등록되어 BeanDefinitionOverrideException이 발생할 수 있습니다. 해결 방법은 테스트 클래스에서 @EnableJpaAuditing을 제거하면 됩니다. 또한 애플리케이션 컨텍스트에서 자동으로 설정된 JPA Auditing을 사용하는 것을 권장하며, 테스트 컨텍스트에 별도 설정은 권장되지 않습니다.