이펙티브 코틀린 - 5장 객체 생성

---

아이템 33. 생성자 대신 팩토리 함수를 사용하라

팩토리 함수의 장점

• 함수에 이름을 추가할 수 있다.
  • ArrayList(3) vs ArrayList.withSize(3)
• 원하는 타입의 리턴이 가능하다.
• 호출될 때마다 새로운 객체를 만들 필요가 없다.
  • 객체를 만들 수 없는 경우 null 리턴을 하도록 만들 수 있다.
  • ex) createOrNull(), findByIdOrNull()
• inline, reified로 만들 수 있다.
  • 인라인 함수로 만들면 컴파일 후 생성되는 바이트코드에 함수 본문이 들어가서 함수 호출의 오버헤드가 없어진다.
  • reified로 만들면 제네릭 타입의 정보를(Class Type) 런타임에도 사용할 수 있다.

 

코틀린에서 팩토리 함수

class MyList<T>(
    val head: T,
    val tail: MyList<T>,
) {
    companion object {
        fun <T> of(vararg elements: T): MyList<T> { // 팩토리 함수
            // ...
            
        }
    }
}

// 인터페이스
class MyLinkedList<T>(
    val head: T,
    val tail: MyLinkedList<T>?
) : MyList<T> {
    // ...
}

interface MyList<T> {
    // ...

    companion object {
        fun <T> of(vararg elements: T): MyList<T> {
            // ...
        }
    }
}

val list = MyList.of(1, 2)

 

팩토리 함수 네이밍

• from: 파라미터를 하나 받고, 동일한 인스턴스 하나를 리턴하는 함수
• of: 파라미터를 여러 개 받고, 이를 통합하여 인스턴스를 생성하는 함수
• instance(getInstance): 싱글턴으로 관리하는 인스턴스를 생성하는 함수
• get(), new() ...

 

확장 팩토리 함수

• 객체의 함수처럼 사용할 수 있는 팩토리 함수를 만들어야 할 때, 이미 다른 companion 객체가 존재하는 경우 확장 함수를 활용할 수 있다.

// 이미 companion object가 존재하는 경우
class Tool {
    companion object {
        fun createSmallTool(): Tool = Tool()
        fun createMediumTool(): Tool = Tool()
        
        // 여기에 새로운 팩토리 함수를 추가하고 싶지만...
        // 1) 소스코드를 수정할 수 없거나
        // 2) 다른 모듈/라이브러리의 클래스인 경우
        // 3) 관심사 분리를 위해 별도로 관리하고 싶은 경우
    }
}

// 확장 팩토리 함수
fun Tool.Companion.createBigTool(size: Int): Tool {
    return Tool().apply {
        // BigTool 특별한 초기화 로직
    }
}

 

 

톱레벨 팩토리 함수

• 컬렉션에서 객체를 만드는 대표적인 팩토리 함수 중 listOf, setOf, mapOf 등이 있다.
• public 톱레벨 함수는 모든 곳에서 사용할 수 있고, 네이밍 등에 있어서 신중하게 사용해야 한다.

expect는 Kotlin Multiplatform에서 사용되는 키워드로, 플랫폼별로 다른 구현을 제공할 수 있도록 하는 메커니즘

각 플랫폼별 실제 구현은 actual 키워드로 구현할 수 있다.

 

// 공통 코드에서 선언만 하고 구현은 하지 않음
@SinceKotlin("1.9")
public expect fun <T> listOf(element: T): List<T>

// JVM 플랫폼 구현
public actual fun <T> listOf(element: T): List<T> = 
    java.util.Collections.singletonList(element)

// JavaScript 플랫폼 구현  
public actual fun <T> listOf(element: T): List<T> = 
    arrayOf(element).asList()

// Native 플랫폼 구현
public actual fun <T> listOf(element: T): List<T> = 
    ImmutableList.of(element)

---

아이템 34. 기본 생성자에 이름 있는 옵션 아규먼트를 사용하라

객체를 정의하고 생성하는 방법을 지정할 때 사용하는 가장 기본적인 방법은 기본 생성자(primary constructor)를 사용하는 것

class User(val name: String, val surname: String)
val user = User(name = "A", surname = "B")

 

코틀린에서는 디폴트 아규먼트를 사용한다.

class Pizza(
    val size: String,
    val cheese: Int = 0,
    val olives: Int = 0,
    val bacon: Int = 0
)

val myFavorite = Pizza("L", olives = 3)
val myFavorite = Pizza("L", cheese = 1, olives = 3)

---

아이템 35. 복잡한 객체를 생성하기 위한 DSL을 정의하라

DSL(Domain Specific Language)은 복잡한 객체, 계층 구조를 가지고 있는 객체들을 정의할 때 유용하다.

import javax.management.Query.div

// 코틀린 DSL을 통해 표현한 HTML
body {
    div {
        a("https://kotlinlang.org") {
            target = ATarget.blank
            +"Main site"
        }
    }
    +"Some content"
}

// Main site
// Some content


// Android View DSL
verticalLayout {
    val name = editText()
    button("Say Hello") {
        onClick { toast("Hello, ${name.text}!") }
    }
}


// Ktor API
fun Routing.api() {
    route("news") {
        get {
            val newsData = NewsUseCase.getAcceptedNews()
            call.respond(newsData)
        }
        get("propositions") {
            requireSecret()
            ...
        }
    }
}


// kotest
class SearchTest : BehaviorSpec(
    {
        given("SearchTest") {
            `when`("랜덤으로 셔플할 변호사가 8명보다 적은 경우,") {
                then("셔플링 없이 모든 변호사를 그대로 반환한다.") {
                    val sut = List(5) { LawyerSearchFixture.create(lawyerId = it.toLong()) }

                    val actual = LawyerSearch.getShuffledLawyerSearches(sut)

                    assertSoftly {
                        actual.size shouldBe sut.size
                        actual shouldBe sut
                    }
                }
            }
        }
    },
)

 

사용자 정의 DSL

리시버를 사용하는 함수 타입에 대한 개념을 이해해야 하는데, 함수 타입은 함수로 사용할 수 있는 객체를 나타내는 타입

// predicate에 함수 타입이 활용
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}

 

함수 타입의 예시

• () → Unit : 아규먼트를 갖지 않고, Unit 반환
• (Int) → Unit
• (Int, Int) → Int

 

함수 타입을 만드는 기본적인 방법

• 람다 표현식, 익명 함수, 함수 레퍼런스

fun plus(a: Int, b: Int) = a + b

// plus() 와 유사 함수
val plus1: (Int, Int) -> Int = { a, b -> a + b }
val plus2: (Int, Int) -> Int = fun(a, b) = a + b
val plus3: (Int, Int) -> Int = ::plus
val plus4: { a: Int, b: Int -> a + b }