Kotlin <in, out, where>

in 키워드

• 들어오는 타입을 제한하는 generic

interface Consumer<in T> {
    fun consume(item: T)
}

class StringConsumer : Consumer<String> {
    override fun consume(item: String) {
        println("Consuming string: $item")
    }
}

class AnyConsumer : Consumer<Any> {
    override fun consume(item: Any) {
        println("Consuming any type: $item")
    }
}

fun main() {
    val stringConsumer = StringConsumer()
    stringConsumer.consume("Hello") // prints "Consuming string: Hello"

    val anyConsumer: Consumer<Any> = AnyConsumer()
    anyConsumer.consume("Hello") // prints "Consuming any type: Hello"
    anyConsumer.consume(123) // prints "Consuming any type: 123"
}

→ in으로 들어가는 string 과 Int를 특정함

out 키워드

• 출력(반환) 형식을 제한하는 generic

interface Producer<out T> {
    fun produce(): T
}

class StringProducer : Producer<String> {
    override fun produce(): String = "Hello"
}

class AnyProducer : Producer<Any> {
    override fun produce(): Any = "Hello"
}

fun main() {
    val stringProducer = StringProducer()
    println(stringProducer.produce()) // prints "Hello"

    val anyProducer: Producer<Any> = AnyProducer()
    println(anyProducer.produce()) // prints "Hello"
}

→ 리턴값인 string과 any를 특정함

where키워드

• 인수(입력값), 반환(출력값) 둘 중 하나로 사용할 수 있는 generic

interface Processor<T> where T : CharSequence, T : Comparable<T> {
    fun process(value: T): Int
}

class StringProcessor : Processor<String> {
    override fun process(value: String): Int = value.length
}

interface Processor<T> where T : CharSequence, T : Comparable<T> {
    fun process(value: T): Int
}

class StringProcessor : Processor<String> {
    override fun process(value: String): Int = value.length
}

fun main() {
    val stringProcessor = StringProcessor()
    println(stringProcessor.process("Hello")) // prints "5"
}

in + out

class InOut<in T, out R>(val item: T) {
    fun get(): R {
        return item as R
    }
}

Uploaded by N2T