2022-03-20 TIL

Genric Invariant & Covariant & Contravariant

Generic과 하위 타입 (Grape가 Fruit의 자식이라고 해서, List<Grape>가 List<Fruit>의 자식인 건 아니다)

Grape가 Fruit의 자식이라고 할 때,

    List<Grape> grapes = new ArrayList<>();
    fruits.add(new Grape()); 

    List<Fruit> fruits = grapes; // compile error

위 코드를 보면 fruits 리스트(ArrayList<Fruit>)를 List<Grape> grapes = fruits; 하면 컴파일 에러가 발생한다. 그 이유는 타입 안정성이 깨지기 때문이다. 예를 들어, Fruit가 Grape의 상위 타입이라고 해서, 반드시 GenericType가 GenericType의 상위 타입이라고 할 수 없는 것이다. 이를 **무변성** 혹은 **무공변**이라고 한다. 다음 코드를 참고하자.

    List<Grape> grapes = new ArrayList<Fruit>(); // 이게 된다면
    grapes.add(new Fruit());
    List<Apple> apples = grapes.getAll(); // List<Grape> 리턴 <-- List<Apple>에 List<Grape>가 담기는 건 좀 이상하지 않은가?

Covariant 상한 경계 와일드카드, Upper Bounded Wildcards)

그러면 List<Fruit> fruits = new ArrayList<Grape>();가 가능하려면 어떻게 해야할까? 답은 extends에 있다. 앞서 말했다시피 List와 List는 상속 관계가 아니라고 했다. 하지만 `List<? extends Fruit> grapes`를 해주면 List와 상속 관계를 만들 수 있다.

    List<? extends Fruit> grapes = new ArrayList<>();
    List<Fruit> fruits = grapes; // ok

    Fruit tempFruit = fruits.get(0); // ok
    Apple apple = fruits.get(1); // compile error
    fruits.add(null); // ok
    fruits.add(new Fruit); // compile error

• extends 키워드를 이용해서 Fruit가 Grape의 상위타입이고, List가 List의 상위 타입일 때 extends 키워드를 이용해서 할당이 가능하게 해줄 수 있다. 이를 공변(Covariant)라고 한다.
• 상한 경계 와일드카드의 원소는 (? extends T) T 혹은 T의 하위 클래스이다.
• 원소들의 최고 공통 조상인 T로 읽으면. 어떤 타입이 오든 T로 읽을 수 있다. 다시 말하면, list.get(0)을 할 때, 반환 타입은 Fruit이며 그보다 하위 타입인 Apple이나 Banana로 읽을 시 컴파일 에러가 발생한다. 그 이유는 역시 타입 안정성 때문이다. 예를 들어 Applie apple = fruits.get(1);가 compile error가 발생하는 이유는 리스트에 Fruit 혹은 Banana가 들어오면 Apple로 타입을 변경할 수 없기 때문이다.
• List<? extends Fruit>에는 타입 안정성을 이유로 null만 삽입할 수 있다. 그 이유는 상한 경계 와일드카드(? extends Fruit)의 element가 어떤 타입인지 알 수 없기 때문이다. Fruit 혹은 Fruit의 하위 클래스라면 삽입할 수 있지 않을까? 다음 코드를 보자

        List<Apple> apples = new ArrayList<>();
        List<? extends Fruit> fruits = apples; // ok
        fruits.add(new Banana()); // compile error <-- List<Apple>에 Banana가 들어가 버렸다!!
  

Contravariant (하한 경계 와일드카드, Lower Bounded Wildcards)

    List<Grape> grapes = new ArrayList<>();
    List<? super Grape> fruits = grapes; // Grape보다 상위 타입 할당 가능

    Grape grape = fruits.get(0); // compile error
    Object object = fruits.get(0); // ok

    fruits.add(new Grape()); // ok
    fruits.add(new Fruit()); // compile error

• Fruit가 Grape의 상위 타입이고 List가 List의 **하위 타입**이면 반공변(super를 이용해서 반공변 처리 가능)
• T 하한 경계 와일드카드의 element는 T의 상위 클래스 중 어떤 타입도 될 수 있다. 어떤 타입이 와도 읽을 수 있도록 T들의 공통 조상인 Object로 받는다. Object보다 하위 클래스의 인스턴스로 get을 하면 Compile error가 발생한다. 그 이유는 하한 제한(super)는 아래만을 제한하므로 T보다 상위 클래스의 List는 얼마든지 올 수 있다. 그래서 T들의 공통 조상인 Object로만 get을 할 수 있다.
• 위 코드를 보면 List<? super Grape> fruits의 상위 타입은 super 키워드로 인해 List이거나 그보다 더 상위 타입이 된다. 최소 타입이 Grape이므로 new Grape() element의 추가는 보장하지만 그보다 더 상위 타입일 경우 해당 element가 Fruit일지, Object일지 컴파일러가 타입을 확정할 수 없으므로 element 추가는 Grape나 Grape보다 하위 타입으로 제한된다. 여기서 드는 의문점은 Grape만 삽입할 수 있다고 하면 그려려니 하겠는데 Grape보다 더 하위 타입도 삽입할 수 있다니? `fruits.add(new Grape());` 까지는 알겠는데 `fruits.add(new ShineMuscat());`도 가능하다는 소리다. fruits에는 Grape 혹은 Grape보다 상위 클래스만 삽입할 수 있어야 하는 거 아닐까? 어째수 Grape나 Grape보다 하위 클래스만 올 수 있는 걸까? -> 컴파일러는 fruits가 List인지 List

(+추가) List<?>에는 null만 삽입할 수 있다.

Covariant나 Contravariant처럼 와일드카드(?)에 경계(extends OR super)가 없는 경우 List<?>의 element가 어떤 타입인지 알 수 없다. 그러므로 타입 안정성을 지키기 위해 null만 삽입할 수 있다.

    public static void main(String[] args) {
        List<Integer> ints = new ArrayList<>();
        addDouble(ints);
    }

    public static void addDouble(List<?> ints) {
        ints.add(3.14);
    }

위 코드를 보자. 위 코드에서 상한이나 하한 경계가 없는 List<?> ints = List<Integer>를 할당하고 ints.add(3.14);를 실행하면 컴파일 오류가 발생한다. 해당 명령이 컴파일 오류가 나는 건 당연하다. 그 이유는 분명히 List를 넘겼는데 Double 타입을 삽입하면 이상하지 않은가? 그래서 하한이나 상한 경계가 없는 List<?>는 타입 안정성을 지키기 위해 할당은 어떤 리스트도 받을 수 있지만, 삽입은 null만 가능하다. 난이도가 있는 개념이니 확실히 이해하도록 노력하자.