[Kotlin] Generics

Generics

- 가장 흔하게 볼 수 있는 Generics 정의는 List이다.

  - List<T>

- Generics은 <>안에 타입 파라미터 정의

> java

interface Generic<T> {

void setItem (T item);

}

> kotlin

interface Generic<in T> {

fun setItem (item : T);

}

> kotlin 구현

class Sample : Generic<Generics type 정의> {

override fun setItem(item : Generics type 정의) {

// 구현

}

}

예제)

interface Generic<in T> {

fun setItem(item : T)

}

class Sample : Generic<String> {

override fun setItem (item : String) {

// 구현

}

}

@Test

fun test() {

Sample().setItem("Foo")

}

Generics Function

private fun <T> abc(t : T) {

// . . .

}

// Use

abc<String>("ABC")

abc("ABC")

-> "ABC"는 String으로 유추가능하므로 두가지 모두 동일함

private fun <T> createArrayList() : List<T> {

return ArrayList()

}

// Use

createArrayList<String>()

createArrayList<Boolean>()

-> 꼭 자료형 써줘야됨!!!

> java는 <>자료형 안쓰면 Object로 배정됨 - 코틀린은 오류뜸!!

private <T> List<T> createArrayList() {

return new ArrayList<>();

}

@Test

public void test() {

List list = createArrayList();                              // <Object>로 배정됨

List<String> stringList = createArrayList();

}

Kotlin Generics 추론

-> Type 생략 가능한 경우

class Foo<out T>(val t : T)

@Test

fun test() {

val foo1 = Foo<String>("foo1")                                         // 생략 가능

val foo2 = Foo("foo2")                                                    // 선언 가능

}

-> Type 생략 불가능한 경우

class Foo<T>

@Test

fun test() {

val foo1 = Foo<String>()                                                 // 선언 가능

val foo2 = Foo()                                                             // 선언 불가능

}

Wildcard type argument

>java

- ? extends T : read만 가능한 서브타입 와일드카드

- ? super T : write만 가능한 슈퍼 타입 와일드카드

>-? extends T

private void printAll (ArrayList<? extends Output<String>> items) {

for (int i = 0; i < items.size(); i++) {

if ( items.get(i).isArgument("")) {

System.out.println("item : " + items.get(i).isArgument(""));

}

}

}

>-? super T

private void printAll (ArrayList<? super Output<String>> items) {

items.add(new Output<String>() {

@Override

public boolean isArgument(String argument) {

return true;

}

});

items.add(null);

}

Kotlin의 in/out

- T : 별도의 Wildcard 정의가 없이 read/write 모두 가능

- in T : Java의 ? super T와 같고, input의 약자이며 write only

- out T : Java의 ? extends T와 같고, output의 약자이며 read only

>Kotlin - out

private fun printAll (items : ArrayList<out Output<String>>) {

items.indices

.filter{ items[it].isArgument("") }

.forEach { println("item : " + items[it]) }

}

>Kotlin - in

private fun printAll (items : ArrayList<in Output<String>>) {

items.add(object : Output<String> {

override fun isArgument ( argument : Stirng ) = false

})

}

Star-Projections

private fun printArrayList (list : List<String>) {

list.forEach {

println("it $it")

}

}

@Test

fun test() {

printArrayList(mutableListOf ("AA", "BB", "CC"))

}