한정적 와일드카드를 사용해 API 유연성을 높이라 - [5장. 제네릭(아이템31)]

1. PECS 🌞

  PECS(Producer-Extends, Consumer-Super)란 매개변수화 타입 T가 생산자라면 <? extends T>를 사용하고, 소비자라면 <? super T>를 사용하라는 것이다.

  예시와 함께 PECS를 이해해 보도록 하자.

public class Stack<E> {
    private E[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    // 배열 elements는 push(E)로 넘어온 E 인스턴스만 담는다.
    // 따라서 타입 안전성을 보장하지만,
    // 이 배열의 런타임 타입은 E[]가 아닌 Object[]다!
    @SuppressWarnings("unchecked")
    public Stack() {
        elements = (E[]) new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(E e) {
        ensureCapacity();
        elements[size++] = e;
    }

    public E pop() {
        if(size == 0)
            throw new EmptyStackException();

        E result = elements[--size];
        elements[size] = null; // 다 쓴 참조 객체 해제
        return result;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    private void ensureCapacity() {
        if(elements.length == size) {
            elements = Arrays.copyOf(elements, 2 * size + 1);
        }
    }

    public void pushAll(Iterable<E> src) {
        for(E e : src)
            push(e);
    }

    public void popAll(Collection<E> dst) {
        while(!isEmpty())
            dst.add(pop());
    }
}

  코드에서 확인할 수 있는 것처럼 지금까지는 타입매개변수 E만을 사용하였다. 즉, 하나의 타입만 지정해서 사용한 것이다.

  제네릭은 불공변이기 때문에 아래 코드에서 확인할 수 있는 것처럼 다른 타입을 넣지 못하게 된다.

public static void main(String[] args) {
    Stack<Number> numberStack = new Stack<>();

    Iterable<Number> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
    numberStack.pushAll(numbers); // 가능 

    Iterable<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6);
    numberStack.pushAll(integers); // 불가능 // 컴파일 에러
}

  하지만, 일반적으로 Stack<Number>에 Integer를 넣는 것이 문제가 되지는 않는다 해당하는 객체의 상위 타입으로 사용하는 것은 아무런 문제가 되지 않기 때문이다.

  그래서 아래와 같이 한정적 와일드카드를 사용하여 문제를 해결할 수 있다.

// 기존
public void pushAll(Iterable<E> src) {
    for(E e : src)
        push(e);
}


// 변경 - 한정적 와일드카드 사용
public void pushAll(Iterable<? extends E> src) {
    for(E e : src)
        push(e);
}

public static void main(String[] args) {
    Stack<Number> numberStack = new Stack<>();

    Iterable<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6);
    numberStack.pushAll(integers);

    Iterable<Double> doubles = Arrays.asList(1.0, 2.1, 3.2, 4.3, 5.4, 6.5);
    numberStack.pushAll(doubles);
}

  이렇게 하면 Number의 하위 타입들을 넣을 수 있다.

  이러한 역할을 하는 것을 생산자(Producer)라고 하는데 생산자에서는 extends를 사용할 수 있다. 사용하고 있는 E의 하위 타입을 받아서 넣어도 문제가 없기 때문이다

 

  pushAll로 넣는 것을 살펴보았으므로 꺼내는 것인 popAll도 살펴보도록 하자

  꺼낼 때에는 해당 타입 E보다 더 상위 타입으로 꺼낼 수 있다. 예를 들어 E가 Number인 경우 Object로 꺼낼 수 있다는 것이다.

  하지만 아래와 같이 현재는 타입 하나로 선언이 되어 있기 때문에 우리의 의도대로 사용하지 못한다.

// 기존
public void pushAll(Iterable<E> src) {
    for(E e : src)
        push(e);
}

  그래서 이런 경우에도 한정적 와일드카드를 사용하여 문제를 해결할 수 있다.

// 변경 - 한정적 와일드카드 사용
public void pushAll(Iterable<? extends E> src) {
    for(E e : src)
        push(e);
}

public static void main(String[] args) {
    Stack<Number> numberStack = new Stack<>();

    Collection<Object> objects = new ArrayList<>();
    numberStack.popAll(objects);
}

  즉, 이렇게 pushAll과 같이 생산자(Provider) 역할을 할 때에는 extends를 사용하고 popAll과 같이 소비자(Consumer) 역할을 할 때에는 super를 사용해야 한다.

  이것이 PECS(Producer-Extends, Consumer-Super) 규칙이다.

 

 

2. 타입 매개변수 VS 와일드카드 🌝

  타입 매개변수와 와일드카드에는 공통되는 부분이 있어서, 메서드를 정의할 때 둘 중 어느 것을 사용해도 괜찮을 때가 많다.

  swap이라는 메서드를 정의한다고 할 때 아래와 같이 두 가지 방식으로 선언할 수 있다.

// 타입 매개변수 사용
public static <E> void swap(List<E> list, int i, int j);
// 와일드카드 사용
public static void swap(List<?> list, int i, int j);

  만약 public API라고 한다면 두 번째가 낫다. 어떤 리스트든 이 메서드에 넘기면 명시한 인덱스의 원소들을 교환해 줄 것이고, 신경 써야 할 타입 매개변수도 없기 때문이다.

 

  기본 규칙은 다음과 같다. 메서드 선언에 타입 매개변수가 한 번만 나오면 와일드카드로 대체하라는 것이다.

  이때 비한정적 타입 매개변수라면 비한정적 와일드카드로 바꾸고, 한정적 타입 매개변수라면 한정적 와일드카드로 바꾸면 된다.

  하지만 다음과 같이 구현하면 컴파일되지 않는다.

public class Swap {

    public static void swap(List<?> list, int i, int j) {
        list.set(i, list.set(j, list.get(i)));
    }
}

  List<?>에는 null 외에는 어떤 값도 넣을 수 없기 때문이다. 그래서 아래와 같이 도우미 메서드를 따로 작성해서 사용해야 한다.

public class Swap {

    public static void swap(List<?> list, int i, int j) {
        swapHelper(list, i, j);
    }

    private static <E> void swapHelper(List<E> list, int i, int j){
        list.set(i, list.set(j, list.get(i)));
    }
}

 

해당 글은 백기선 님의 '이펙티브 자바 완벽 공략'을 참고하였습니다.