5-2 제네릭, 배열보다는 리스트를 사용하라, (+슈퍼타입 구현방법)

 

• 💨제네릭 invariant(무변성), covariant(공변, extend), contravariant(반공변, super) 에 대해 설명해주세요. 힌트. 이펙티브 자바 Item31. PECS - producer는 extends로 consumer는 super로 사용하자
  📌공변 성질 : A가 B의 하위타입일 때, 제네릭 T<A> 가 T<B>의 하위타입인가?
  📌반공변 성질: A가 B의 하위타입일 때, 제네릭 T<B> 가 T<A>의 하위 타입인가?
  📌무변성 성질: A가 B의 하위타입일 때, 제네릭 T<A> 와 T<B> 타입이 서로 아무런 관계가 없으면 무변성.
  

Object number = new Number() // 참고로 Integer와 Double은 Number를 상속한다.
Number integer = new Integer()
Number double = new Double()

List<Object> error = new List<Number> // 무변성이라 불가능. 컴파일 에러
List<Number> error = new List<Integer> // 무변성이라 불가능. 컴파일 에러

List<? extends Number> foo3 = new ArrayList<Number>();  // 자기자신은 당연히 가능
List<? extends Number> foo3 = new ArrayList<Integer>(); // 공변성 있음. 가능
List<? extends Number> foo3 = new ArrayList<Double>();  // 공변성 있음. 가능

List<? super Integer> foo3 = new ArrayList<Integer>();  // 자기자신은 당연히 가능
List<? super Integer> foo3 = new ArrayList<Number>();   // 반공변성 있음. 가능
List<? super Integer> foo3 = new ArrayList<Object>();   // 반공변성 있음. 가능

/* 참고로 다운캐스팅은 아래와 같이 사용시 컴파일은 되지만, 런타임에 ClassCastException 발생. */
var parent = new Parent();
var child = parent // ClassCastException. 방지하려면 if(parent instanceof Child)를 사용해줍시다.

// 생산자는 공변성을 제공해주면 됨. extends
class ZooService{
    public void train(Cage<? extends Animal> cage){
        List<Animal> myCage = cage.getAll(); // Cage에서 꺼내서 Animal타입으로 받음
    }
}

ZooService zoo = new ZooService();
Cage<Tiger> tigerCage = new Cage<>();
Cage<Lion> lionCage = new Cage<>();

zoo.train(tigerCage) // 공변성을 지원해주기 때문에 OK
zoo.train(lionCage)

여기서 중요한점은, 바이트코드상으로는 제네릭을 쓰던 안쓰던 똑같다는 사실. 컴파일 시점에 타입이 결정됨.

Cage<..>에 담아서 주는건 어차피 바이트코드로는 Object라서, 사용하는데 아무런 문제가 없음

🧨 문제는 그냥 push(T animal) 이라고 적어버리면, T가 어떤 하위타입인지 알 수 없어서 컴파일 에러를 띄움.
제네릭은 타입을 동적으로 변환시켜주는 기능이 아님. <Tiger>는 괜찮지만 <? extends Animal>은 문제가 발생함.
제네릭은 컴파일시간에 타입 안정성을 보장하기위한 기능임. 타입이 다르면 당연히 컴파일 에러가 발생.
하위타입인 Tiger가 상위인 Animal은 변환이 가능해서 상관없음 / 하지만 Tiger를 Lion으로 변경? 불가능. 이런 실수를 방지하기 위해 컴파일 에러를 발생시켜줌.

제네릭을 <? extends Animal>이라 Tiger, Lion 둘 다 가능한데? 그거 캐스팅 불가능하자나 위험해. 컴파일 에러!

그럴 땐 생산자(Cage) 코드 해결하려고 하지말고 소비자, 즉 타입을 사용하는 쪽에서 super를 사용해서 해결하면 됨.

Cage<Tiger> tigerCage = new Cage<>();

Cage<? super Tiger> cage = tigerCage; // 이건 <? extends Animal>과 같음.
cage.push(new Tiger()); // 여기서 차이가 있다. cage.push(T Animal) 이 가능함.

하위타입은 Lion으로 결정하면, Dog로 변경이 불가능함. 컴파일러는 방법이 없음.

하지만 상위타입은 Tiger를 넣든 Animal을 넣든 Object를 넣든 상관없음. 캐스팅하면 되니까(바이트코드는 object 사용) 
Producer-extends, Consumer-super. 줄여서 패-쓰 (PECS)

 

• 💨List<T>, 제네릭 타입정보(super-type 토큰)는 아래 코드처럼 사용이 불가능합니다. 하지만 스프링에서는 사용 가능하게 구현을 해놨는데,  어떻게 사용할 수 있을까요?

f.put(myList,  List<String>.class);

📌 우선, Object로 받아서 타입변환을 하는 방법도 있으나, 매우 위험한 방법임. 런타임 에러를 만들기 쉬움. 

📌 그 대안으로 나온게 타입토큰, 즉 Class<T> 를 같이 줘서 그걸로 제네릭 타입을 결정하고, .cast()로 안전하게 변환.

 

 

배열과 리스트의 차이

자바에도 단순 배열은 제공해주나, 가능하면 컬렉션의 리스트를 사용하자.

물론 기능적인 차이 - (배열은 크기를 동적으로 늘릴 수 없음)도 있지만 배열은 타입 안정성을 보장할 수 없고 제네릭을 사용하지 않기 때문에 공변성 , 즉 하위타입을 넣을 수 있다는 문제가 생긴다.

Object[] objects = new Long[1]; // 가능. 다만 런타임때 문제가 생길 수 있음.

List<Object> list = new ArrayList<Long>(); //컴파일 에러

리스트는 상위타입의 배열은 하위타입도 받을 수 있어, 데이터 삽입에 대한 에러를 런타임시 확인 가능하다. 하지만, 리스트는 컴파일 에러가 발생해서 쉽게 찾을수 있다.

 

물론 리스트는 래퍼타입이므로 배열보다 속도가 느리다. 하지만 Collection은 내부적인 최적화가 이미 되어있고, 대부분의 서비스에서 리스트 -> 배열로 최적화가 필요한 경우는 없다. 트레이드 오프를 고려하자. 배열의 치명적인 단점을 가지면서까지 최적화가 필요한 서비스인가?

 

 

# 이왕이면 제네릭 타입/ 제네릭 메서드로 만들어라.

위의 배열 vs 리스트를 보면 알겠지만, 제네릭은 런타임에 아무런 영향을 끼치지 않고도 타입 안정성을 보장할 수 있다. 새로운 타입으로 사용할 객체를 설계할 때 형변환(캐스팅)이 필요하다면 제네릭으로 만들 수는 없는지 고려하자.

 

 

# 리스트에서 공변성 (하위타입 받기)가 필요하면 한정적 와일드카드를 사용

<? extends T>와 <? super T> 를 제네릭으로 사용하자.

public class CustomObject<E> {

    private List<E> items;

    public void customAddAll(List<? extends E> items) { // E와 E의 하위객체
        this.items.addAll(items);
    }

    public void copy(List<? super E> items){ // E와 E의 상위 객체
        items.addAll(this.items);
    }

    public void customRemoveAll(List<? extends E> items){
        this.items.removeAll(items);
    }
}

 

 

# 제네릭과 가변인수(...)을 같이 사용할 때는 신중하라.

자바에서는 아래와 같이 가변인수(인자 개수를 유동적으로) 받을 수 있다.

이 경우 제네릭 가변인수에 값을 저장하는건 안전하지 않다. ClassCastException을 발생시킨다.

static void dangerous(List<String>... stringLists) {
    Object[] objects = stringList; // 가변인수를 이렇게 사용할 수 있다.
    
    // 미친짓이지만 아래와 같이 사용하면 제네릭의 컴파일 타입검증을 무시해버린다.
    List<Integer> intList = List.of(42);
    objects[0] = intList;
    
    String s = stringList[0].get(0); // 사용하는 시점에 ClassCastException 발생
}

 

물론 가변인수 배열을 외부에 노출하지않고, 사용에 주의한다면 큰 문제없이 사용할 수 있다.

이 경우에는 @SafeVarargs를 메서드에 붙여주자. 이는 @SupressWarnings와 비슷하게 컴파일 경고를 제거해준다.

다만 반드시 안전하다는걸 보장해줘야한다. @SafeVarargs는 표시하는 용도일뿐, 어떠한 추가작업도 하지 않는다.

public class Machine<T> {
    private List<T> versions = new ArrayList<>();

    @SafeVarargs
    public final void safe(T... toAdd) {
        for (T version : toAdd) {
            versions.add(version);
        }
    }
}

 

 

 

# 타입 안정 이종 컨테이너 (타입정보 Class<T>를 매개변수로 함께받기)

제네릭에서 와일드카드보다 타입을 유연하게 사용하고 싶다면, 아래와 같은 방법을 사용하자.

public class Favorites {

    private Map<Class<?>, Object> favorites = new HashMap<>();

    public <T> void putFavorite(Class<T> type, T instance) {
        //cast 메서드를 사용해 타입 안정성을 보장한다!
        favorites.put(Objects.requireNonNull(type), type.cast(instance));
    }

    public <T> T getFavorite(Class<T> type) {
        //cast 메서드를 사용해 타입 안정성을 보장한다!
        return type.cast(favorites.get(type));
    }
}

    Favorites f = new Favorites();

    f.putFavorite(String.class, "스트링");
    f.putFavorite(Integer.class, 1);
    f.putFavorite(Long.class, 1L);
    
    // 물론 아래와 같이 실체화가 불가능한 제네릭을 타입으로 사용할 순 없다.
    // 에러 - f.putFavorite(List<String>.class, new ArrayList<>());

제네릭까지 타입으로 받고싶다면 슈퍼타입을 사용하면 된다.

1. ParameterizedType를 사용
2. TypeFactory를 사용

//슈퍼타입을 사용하여 타입안정성을 보장한다!
    public <T> void putFavorite(TypeReference<T> valueTypeRef, T instance) {

        // ParameterizedType로 캐스팅하여 Class<T>를 얻는다!
        Class<T> tClass = ((Class<T>) ((ParameterizedType) valueTypeRef.getType()).getRawType());

        favorites.put(Objects.requireNonNull(tClass), Objects.requireNonNull(instance));
    }

    //슈퍼타입을 사용하여 타입안정성을 보장한다!
    public <T> T getFavorite(TypeReference<T> valueTypeRef) {

        // TypeFactory를 이용해서 Class<T>를 얻는다!
        Class<T> rawClass = (Class<T>) TypeFactory.type(valueTypeRef.getType()).getRawClass();

        return rawClass.cast(favorites.get(rawClass));
    }
    
    
    @Test
    public void 이종_타입_컨테이너_실체화_불가_타입_슈퍼타입_토큰() {
        //given
        Favorites f = new Favorites();

        // 슈퍼타입으로 넣는다!
        f.putFavorite(new TypeReference<List<String>>() {}, Collections.singletonList("슈퍼 타입 토큰"));

        // 슈퍼타입으로 꺼낸다!
        List<String> strings = f.getFavorite(new TypeReference<List<String>>() {});

        //then
        assertEquals("슈퍼 타입 토큰", strings.get(0));
    }

 

참고로 스프링에서는 ParameterizedTypeReference 를 슈퍼타입으로 사용한다. 궁금하다면 아래링크를 참고하자.

https://homoefficio.github.io/2016/11/30/%ED%81%B4%EB%9E%98%EC%8A%A4-%EB%A6%AC%ED%84%B0%EB%9F%B4-%ED%83%80%EC%9E%85-%ED%86%A0%ED%81%B0-%EC%88%98%ED%8D%BC-%ED%83%80%EC%9E%85-%ED%86%A0%ED%81%B0/

클래스 리터럴, 타입 토큰, 수퍼 타입 토큰

https://www.youtube.com/watch?v=01sdXvZSjcI 

https://www.bsidesoft.com/2903

[java] 토비의 봄 TV라이브 #2 - Bsidesoft co.