[Kotlin] 제네릭스

🌟 화면을 넓게 하시면 오른쪽에서 목차를 확인하실 수 있습니다. :)

제네릭 타입 파라미터

제네릭 타입 파라미터를 사용하여 제네릭 함수, 프로퍼티, 클래스를 선언하는 방식은 자바와 비슷하다.

제네릭스를 사용하여 타입 파라미터를 받는 타입을 정의할 수 있고, 타입 인자로 치환하여 인스턴스를 만들 수 있다. 타입 인자(type argument)는 프로그래머가 직정 타입 인자를 정의하거나 컴파일 과정에서 타입 추론에 의해 타입 인자가 추론될 수 있어야한다.
List<String> // 타입 파라미터로 String을 받고 있는 리스트

제네릭 함수와 프로퍼티

리스트를 다루는 함수를 작성할 때, 모든 리스트를 다룰 수 있는 함수를 만들고 싶을 때 제네릭 함수를 작성한다.

그림 9.1 설명: 타입 파라미터를 선언 후, 수신 객체와 반환 타입에 쓰였음.

• 제네릭 확장 프로퍼티도 마찬가지로 타입 마라미터를 선언하여 사용 가능하다.

val <T> List<T>.penultimate: T
    get() = this[size-2]
fun main() {
    println(listOf(1, 2, 3, 4).penultimate)
}

제네릭 클래스 선언

클래스, 인터페이스에 타입 파라미터를 정의해서 본문 안에서 일반 타입처럼 사용 가능하다.

interface List<T> {
    operator fun get(index: Int): T
}

타입 파라미터 제약 (type parameter constraint)

Type parameter 제약이란, 클래스나 함수에 사용할 수 있는 타입 인자를 제한하는 기능이다. 타입 파라미터 이름 뒤에 : 를 표시하고 뒤에 상한 타입을 명시해서 제한할 수 있다.

•  
• fun <T: Number> List<T>.sum(): T

• 두가지 이상의 제약을 둬야하는 경우:

fun <T> ensureTrailingPeriod(seq: T)
where T: CharSequence, T: Appendable { // 타입 파라미터 제약 목록
    if (!seq.endsWith('.')) { // CharSequence 인터페이스의 확장 함수 호출
        seq.append('.') // Appendable 인터페이스의 메서드 호출
    }
}

타입 파라미터를 널이 될 수 없는 타입으로 한정

• 상한이 없는 타입은 Any? 와 마찬가지로 널을 허용한다.
• <T: Any> 로 타입을 한정해서 널이 될 수 없는 타입을 보장할 수 있다.

실행 시 제너릭스의 동작: 소거된 타입 파라미터와 실체화된 타입 파라미터

함수를 inline 으로 선언해서 제너릭스 사용 시 타입 소거를 막을 수 있다 (실체화한 타입 파라미터).

실행 시점의 제네릭: 타입 검사와 캐스트

제네릭 클래스 인스턴스가 인스턴스를 생성할 때 쓰인 타입 인자에 대한 정보를 유지하지 않는다.

• 실행 시점에서 List<String> 과 List<Int> 둘다 List로만 보임.

타입 검사

• 컴파일 시점에 타입 정보를 제공하면 is 검사가 가능하다. (아닌 경우엔 컴파일 에러)

fun printSum(c: Collection<Int>) { // 타입 정보를 제공함.
    if (c is List<Int>) {
    	println(c.sum())
    }
}

fun main() {
    val typeCasting = TypeCasting()
    printSum(listOf(1,2,3))
}

타입 캐스트

• 기저 클래스는 같지만 타입 인자가 다른 타입으로 캐스팅해도 에러가 나지 않음을 주의해야한다.

fun printSum(c: Collection<*>) {
    val intList = c as? List<Int>
        ?: throw IllegalArgumentException("List is expected")
    /// BREAKPOINT : intList[0] = "a", intList[1] = "b", intList[2] = "c"
    println(intList.sum()) // ClassCastException 발생
}

fun main() {
    printSum(listOf(1,2,3))
    printSum(listOf("a", "b", "c")) //List<String>
}

실체화한 타입 파라미터를 사용한 함수 선언

인라인 함수의 타입 파라미터는 실체화되어서 실행 시점에 인라인 함수의 타입 인자를 알 수 있다.

• 인라인 함수의 타입 파라미터를 reified 로 지정하면 실행 시점에 타입 검사 가능하다.
  • 컴파일 시 함수가 호출되는 코든 지점에 인라인 함수의 본문을 구현한 바이트코드가 들어가게 됨
  • = 타입 인자로 쓰인 구체적인 클래스를 참조하는 바이트 코드를 생성

fun main() {
  val items =listOf("one", 2, "three")
    println(items.filterIsInstance<String>())
}

실체화한 타입 파라미터 제약

개념으로 인해 생기는 제약 및 코틀린이 실체화를 구현하는 방식에 의해 생기는 제약

• 타입 파라미터 클래스의 인스턴스 생성하기
• 타입 파라미터 클래스의 동반 객체 메소드 호출하기
• 실체화한 타입 파라미터를 요구하는 함수를 호출하면서 실체화하지 않은 타입 파라미터로 받은 타입을 타입 인자로 넘기기
• 클래스, 프로퍼티, 인라인 함수가 아닌 함수의 타입 파라미터를 refied로 지정하기

실체화한 타입 파라미터를 사용할 수 있는 경우

• 타입 검사와 캐스팅(is, !is, as, as?)
• 10장에서 설명할 코틀린 리플렉션 API(::class)
• 코틀린 타입에 대응하는 java.lang.Class를 얻기(::class.java)
• 다른 함수를 호출할 때 타입 인자로 사용

변성: 제네릭과 하위 타입

변성은 타입이 같고 타입 인자가 다른 여러 타입의 관계를 설명한다. 위험할 여지가 있는 메서드를 호출할 수 없게 만들어서 클래스 인스턴스를 잘못 사용하는 일을 방지할 수 있다.

변성이 있는 이유: 인자를 함수에 넘기기

적절한 인터페이스를 선택해야 안전하지 못한 함수 호출을 막을 수 있다. 예를 들어, 읽기 전용의 List<Any> vs. 데이터 변경이 가능한 MutableList<Any>가 있다고 한다면,

• 읽기 전용인 경우 구체적인 타입의 원소를 갖는 리스트를 함수에 넘길 수 있다.
• MutableList<Any> 파라미터를 받는 함수에 MutableList<String>을 넘기는 경우 리스트의 원소가 추가되거나 변경되면 타입 불일치가 생길 수 있음.

fun main() {
    val strings =mutableListOf("abc", "def")
//    addAnswer(strings)
//    println(strings.maxBy { it.length })
}

fun addAnswer(list: MutableList<Any>) {
    list.add(42)
}

클래스, 타입, 하위 타입

클래스와 타입

타입과 클래스라는 용어가 혼용되었지만, 같지 않다..!

클래스 이름으로 타입을 쓸 수 있고, null이 될 수도 있는 타입/아닌 타입 둘 이상의 타입을 구성할 수 있다. 제네릭 클래스는 많은 타입을 만들어낼 수 있다.

• List<T> : 클래스
• List<String>, List<Int>, List<String?> : 타입

하위 타입과 상위 타입

타입 A에 ← 타입 B의 값을 넣어도 되는 경우:

• “타입 B는 타입 A의 하위 타입이다.”
• “타입 A는 타입 B의 상위 타입이다.”
• 컴파일러는 변수 대입이나 함수 인자 전달 시 하위 타입 검사를 매번 수행함.
  • 하위 타입인 경우에만 변수에 값 대입을 허용
• 널을 허용하는 클래스가 아닌 클래스보다 상위 타입임.
• Mutable<Any> ← Mutable<String> 상위-하위 타입 관계가 아님.(이전 예시 참조)

공변성: 하위 타입 관계를 유지

• 공변적(covariant): A가 B의 하위 타입이면 List<A>가 List<B>의 하위 타입인 경우
  • 표현 방식: <out T> - 타입 파라미터 앞에 out을 붙임.
  • ↔ 무공변(invariant): 인스턴스 타입 간 하위 타입 관계가 성립하지 않음.
• out 과 in
  • 클래스 멤버를 선언할 때 타입 파라미터를 사용할 수 있는 지점은 모두 인(in)과 아웃(out)으로 나뉨.:
  • out: T타입의 값을 “생산”
    • 타입 안정성 보장을 위해 공변적 파라미터는 항상 out 위치에 있어야 함.
  • in: T타입의 값을 “소비”
  • out+in : 무변성

반공변성: 뒤집힌 하위 타입 관계

• 반공변성(contravariance): A가 B의 하위 타입이면 List<B>가 List<A>의 하위 타입인 경우

공변성 지정: 선언 지점 변성 또는 사용 지점 변성

제네릭 클래스의 공변성을 전체적으로 지정하거나 구체적인 사용 위치에서 지정할 수 있다.

선언 지점 변성

• 클래스를 선언하면서 변성을 지정
• in/out 지정
• 예제) Box 클래스 전역에 설정함: T 타입을 out 위치에서만 사용할 수 있도록 제한.

class Box<out T>(val data: T)

• val box: Box<Number> = Box(10) : Box 객체는 Number의 하위 타입인 Int, Double 타입만 가질 수 있음.

사용 지점 변성

• 타입 파라미터가 있는 타입을 사용할 때마다 어떤 타입으로 대치할 수 있는지 명시하는 방법(해당 타입 파라미터 or 하위 타입으로 명시)
• 공변적이거나 반공변적인지 선언할 수 없는 경우 변성을 정하는 방법
• 예제 설명
  • Box 클래스는 무변성이지만 printObj 함수에서(=Box<> 사용 지점에서) 가변성을 정하고자 할 때 사용 지점 변성으로 변성을 정할 수 있음.
  • Box : 공변성. 세터를 통해 값을 설정하는 것이 제한됨.

class Box<T>(var item: T) // 무변성

fun <T> printObj(box: Box<out Animal>) {
    val obj: Animal = box.item // out이므로 getter가 동작
// box.item = Animal() <- out이므로 setter는 동작하지 않음.
    println(obj)
}

스타 프로젝션: 타입 인자 대신 * 사용

제네릭 타입 인자 정보가 없음을(알려지지 않음을) 표한할 때 스타 프로젝션(*)을 사용한다.

• MutableList<*> 와 MutableList<Any?>
  • any? : 기저타입에 모든 타입의 원소를 담을 수 있다는 의미
  • * : 원소의 타입을 모를 뿐 정해진 구체적인 타입의 원소만을 가지고 있음.
• 타입 인자 정보가 중요하지 않을 때 스타 프로젝션 구문 사용