이펙티브 자바 아이템 31 - 한정적 와일드카드를 사용해 API 유연성을 높이라 - 핵심 정리

아이템 31 - 한정적 와일드카드를 사용해 API 유연성을 높이라 - 핵심 정리

이 글은 백기선 님의 이펙티브 자바 강의와 이펙티브 자바 3 / E 편을 참고하여 작성하였습니다.

---

Chooser 와 Union API 개선

// 와일드카드 타입을 이용해 대량 작업을 수행하는 메서드를 포함한 제네릭 스택 (181-183쪽)
public class Stack<E> {
   private E[] elements;
   private int size = 0;
   private static final int DEFAULT_INITIAL_CAPACITY = 16;

   // 코드 29-3 배열을 사용한 코드를 제네릭으로 만드는 방법 1 (172쪽)
   // 배열 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);
   }

   // 코드 31-2 E 생산자(producer) 매개변수에 와일드카드 타입 적용 (182쪽)
   public void pushAll(Iterable<E> src) {
      for (E e : src)
         push(e);
   }

   // 코드 31-3 와일드카드 타입을 사용하지 않은 popAll 메서드 - 결함이 있다! (183쪽)
//    public void popAll(Collection<E> dst) {
//        while (!isEmpty())
//            dst.add(pop());
//    }

   // 코드 31-4 E 소비자(consumer) 매개변수에 와일드카드 타입 적용 (183쪽)
   public void popAll(Collection<E> dst) {
      while (!isEmpty())
         dst.add(pop());
   }
}

지금까지는 Stack<E> 를 통해 오직 한 타입만을 지칭해 사용했다.

제네릭은 공변 하지 않기 때문에 그 타입의 상속구조와는 관계없이 하나의 타입만 지칭하게 된다.

만약 Stack<Number> 에 Integer 객체를 넣고 싶다면 넣을 수가 없게된다.

그러나 Stack<Number> 에 Integer 객체를 넣는 행위는 위험한 행위가 아니다.

해당하는 객체의 상위 인터페이스로 사용 하는 건 전혀 문제가 되지 않는다.

   // 코드 31-2 E 생산자(producer) 매개변수에 와일드카드 타입 적용 (182쪽)
   public void pushAll(Iterable<E> src) {
      for (E e : src)
         push(e);
   }

그러나 pushAll(Iterable<E> src) 메서드의 매개변수로 E 타입을 정의했기 때문에

Stack<Number> 에서 Integer 객체를 pushAll 메서드의 매개변수로 전달할 수 없다.

여기서 한정적 와일드 카드 사용하면 어떻게 될까?

한정적 타입 은 Iterable<E extends Number> 와 같이 E 라는 어떠한 한정적인 타입을 지칭하고

한정적 와일드 카드 는 Iterable<? extends Number> 와 같이 어떠한 타입을 지칭하지 않는다.

<? extends Number> 는 Number 클래스를 상속받은 아무 타입 을 의미한다.

   // 코드 31-2 E 생산자(producer) 매개변수에 와일드카드 타입 적용 (182쪽)
   public void pushAll(Iterable<? extends E> src) {
      for (E e : src)
         push(e);
   }

pushAll 메서드의 매개변수를 한정적 와일드 카드 로 변경한다.

E 타입을 상속한 아무 타입의 Iterable 을 매개변수로 받을 수 있다.

// 와일드카드 타입을 이용해 대량 작업을 수행하는 메서드를 포함한 제네릭 스택 (181-183쪽)
public class Stack<E> {
    private E[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    // 코드 29-3 배열을 사용한 코드를 제네릭으로 만드는 방법 1 (172쪽)
    // 배열 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);
    }

     // 코드 31-2 E 생산자(producer) 매개변수에 와일드카드 타입 적용 (182쪽)
    public void pushAll(Iterable<? extends E> src) {
        for (E e : src)
            push(e);
    }

   // 코드 31-3 와일드카드 타입을 사용하지 않은 popAll 메서드 - 결함이 있다! (183쪽)
    public void popAll(Collection<E> dst) {
        while (!isEmpty())
            dst.add(pop());
    }


   // 제네릭 Stack을 사용하는 맛보기 프로그램
    public static void main(String[] args) {
        Stack<Number> numberStack = new Stack<>();
        Iterable<Integer> integers = Arrays.asList(3, 1, 4, 1, 5, 9);
        numberStack.pushAll(integers);
    }
}

한정적 와일드카드 타입 을 사용하면 Stack<Number> 에 pushAll 메서드를 통해 Integer 를 넣을 수 있게된다.

Iterable<? extends E> 를 풀어보면 E 는 Number 클래스가 되고

Iterable<? extends E> 는 결국 Number 클래스를 상속받은 모든 타입을 의미하므로 Integer 를 매개변수로 전달할 수 있는 것이다.

이렇게 어떤 매개변수를 받아 어딘가에 쌓아두는 역할 을 하는 것을 생산자 혹은 프로듀서 라고 한다.

이러한 경우에는 객체를 쌓아두는 컨테이너의 타입보다 하위 타입 을 넣어줄 수 있다.

전달받은 객체보다 상위타입으로 사용하기 떄문에 컨테이너의 타입보다 하위 타입 을 넣어주어도 안전하기 떄문이다.

ppublic class Main {
   public static void main(String[] args) {
      Stack<Number> numberStack = new Stack<>();
      Iterable<Integer> integers = Arrays.asList(3, 1, 4, 1, 5, 9);
      numberStack.pushAll(integers);

      Iterable<Double> doubles = Arrays.asList(3.1, 1.0, 4.0, 1.0, 5.0, 9.0);
      numberStack.pushAll(doubles);
   }
}

Number 의 하위타입을 전부 넣을 수 있으므로 위와같이 Double 타입도 넣을 수 있게된다.

결국 Double 을 Number 타입으로 사용하게되기 때문에 아무런 문제가 발생하지 않는다.

어떤 매개변수를 받아 어딘가에 쌓아두는 역할 을 하는 것을 생산자 에서는 <? extends E> 와 같이

extends 를 활용할 수 있다.

한정적 와일드카드 타입 을 사용하면 API 의 유연성이 높아진다.

반대로 컨테이너 안에 들어있는 객체를 꺼낼 때 는 해당 타입보다 높은 타입 으로 꺼낼 수 있다.

public class Main {
   public static void main(String[] args) {
      Stack<Number> numberStack = new Stack<>();
      Iterable<Integer> integers = Arrays.asList(3, 1, 4, 1, 5, 9);
      numberStack.pushAll(integers);

      Iterable<Double> doubles = Arrays.asList(3.1, 1.0, 4.0, 1.0, 5.0, 9.0);
      numberStack.pushAll(doubles);

      Collection<Object> objects = new ArrayList<>();
      numberStack.popAll(objects); // 컴파일 에러
   }
}

위처럼 Stack<Number> 에 있는 값을 꺼내 Collection<Object> 에 넣어주고 싶지만 컴파일 에러가 발생한다.

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

popAll 메서드의 매개변수가 Collection<E> 로 타입 하나로 선언되어있기 떄문에

더 상위 타입인 Object 와는 다른 타입인 것이다.

Stack<Number> 안에 있는 값을 Collection<Object> 에서 사용해도 문제가 되지 않는다.

Number 보다 상위타입인 Object 타입으로 사용하기 때문이다.

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

Collection<? super E> 와 같이 super 를 사용한 한정적 와일드 카드 타입 을 사용하여 해결한다.

<? extends E> 와 같이 상위 타입이 한정되어 있는 경우는 상위 한정 이라고 부르고,

<? super E> 는 하위 타입이 한정되어 있어서 하위 한정 이라고 부른다.

<? super E> 는 E 타입의 상위 타입들을 의미한다.

예를들어 <? super Integer> 라면 Integer 의 상위 타입인 Number 나 Object 를 허용한다.

부모 클래스 혹은 그 클래스가 구현하고 있는 인터페이스 타입들을 허용하는 것이다.

public class Main {
   public static void main(String[] args) {
      Stack<Number> numberStack = new Stack<>();
      Iterable<Integer> integers = Arrays.asList(3, 1, 4, 1, 5, 9);
      numberStack.pushAll(integers);

      Iterable<Double> doubles = Arrays.asList(3.1, 1.0, 4.0, 1.0, 5.0, 9.0);
      numberStack.pushAll(doubles);

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

Object 클래스는 Number 의 상위 타입이므로 popAll 메서드의 사용이 가능해진다.

Number 를 Object 컬렉션에 넣어도 아무 문제가 없다.

Object 가 Number 의 상위 타입이기 때문이다.

이렇게 한정적 와일드 카드 타입 을 사용해 API 의 유연성을 높일 수 있다.

여기서 규칙을 찾을 수 있는데

프로듀서 (뭔가를 받아와서 쌓아넣는 곳, add 나 push 같은), 생산자 에서는 <? extends E> 를 사용하고,

컨슈머 (내가 가지고 있는 것을 꺼내 전달하는 곳) 에서는 <? super E> 를 사용한다.

프로듀서는 extends, 컨슈머는 super 의 앞글자만 따서 PECS 라고 부른다.

PECS: Producer-Extends, Consumer-Super

---

// T 생산자 매개변수에 와일드카드 타입 적용 (184쪽)
public class Chooser<T> {
   private final List<T> choiceList;
   private final Random rnd = new Random();

   // 코드 31-5 T 생산자 매개변수에 와일드카드 타입 적용 (184쪽)
   public Chooser(Collection<> choices) {
      choiceList = new ArrayList<>(choices);
   }

   public T choose() {
      return choiceList.get(rnd.nextInt(choiceList.size()));
   }
}

Chooser 클래스이다.

   public Chooser(Collection<T> choices) {
      choiceList = new ArrayList<>(choices);
   }

생성자에서 어떠한 Collection 을 받아서 랜덤한 값을 꺼내주는 기능을 한다.

어떠한 값을 가져와 추가하는 것이기 때문에 프로듀서 에 해당한다.

프로듀서 에서 위와 같이 T 라는 하나의 타입만 정의를 하면 선언한 그 타입만 사용해야한다.

public class Main {
   public static void main(String[] args) {
      List<Integer> intList = List.of(1, 2, 3, 4, 5, 6);
      Chooser<Number> chooser = new Chooser<>(intList);
      for (int i = 0; i < 10; i++) {
         Number choice = chooser.choose();
         System.out.println(choice);
      }
   }
}

위와 같이 Chooser<Number> 로 선언했기 때문에

List<Integer> 타입은 넘길 수 없다.

그러나 Number 의 하위 타입인 Integer 타입의 값을 할당해도 문제가 발생하지 않는다.

Integer 를 Number 타입으로 사용하기 때문이다.

이 반대인 Number 을 Integer 타입으로 사용할 수 없다.

더 추상적인 타입을 구체화된 타입으로 사용할 수 없다.

   public Chooser(Collection<? extends T> choices) {
      choiceList = new ArrayList<>(choices);
   }

위와같이 프로듀서 에 extends 키워드를 사용하면 아무런 무리없이

Nuumber 의 하위 타입인 Integer 타입의 List 를 받을 수 있다.

---

// 코드 30-2의 제네릭 union 메서드에 와일드카드 타입을 적용해 유연성을 높였다. (185-186쪽)
public class Union {
    public static <E> Set<E> union(Set<E> s1,
                                   Set<E> s2) {
        Set<E> result = new HashSet<>(s1);
        result.addAll(s2);
        return result;
    }
}

두 개의 Set 을 합쳐주는 Union 클래스이다.

public class Main {
   // 향상된 유연성을 확인해주는 맛보기 프로그램 (185쪽)
   public static void main(String[] args) {
      Set<Integer> integers = new HashSet<>();
      integers.add(1);
      integers.add(3);
      integers.add(5);

      Set<Double> doubles =  new HashSet<>();
      doubles.add(2.0);
      doubles.add(4.0);
      doubles.add(6.0);

      Set<Number> numbers = union(integers, doubles);

//      // 코드 31-6 자바 7까지는 명시적 타입 인수를 사용해야 한다. (186쪽)
//      Set<Number> numbers = Union.<Number>union(integers, doubles);

      System.out.println(numbers);
   }
}

Set<Integer> 과 Set<Double> 을 Set<Number> 으로 합쳐도 전혀 문제가 되지 않는다.

// 코드 30-2의 제네릭 union 메서드에 와일드카드 타입을 적용해 유연성을 높였다. (185-186쪽)
public class Union {
    public static <E> Set<E> union(Set<E> s1,
                                   Set<E> s2) {
        Set<E> result = new HashSet<>(s1);
        result.addAll(s2);
        return result;
    }
}

하지만 현재는 E 라는 하나의 타입만 사용하고 있기 때문에 불가능하다.

union 메서드는 무언가를 받아와 넣어주는 역할을 하기 때문에 프로듀서 이다.

// 코드 30-2의 제네릭 union 메서드에 와일드카드 타입을 적용해 유연성을 높였다. (185-186쪽)
public class Union {
    public static <E> Set<E> union(Set<? extends E> s1,
                                   Set<? extends E> s2) {
        Set<E> result = new HashSet<>(s1);
        result.addAll(s2);
        return result;
    }
}

위처럼 extends 를 사용한 한정적 와일드카드 타입 을 사용해 API 를 더 유연하게 사용할 수 있다.

---

// 재귀적 타입 한정을 이용해 상호 비교할 수 있음을 표현 (179쪽)
public class RecursiveTypeBound {
    // 코드 30-7 컬렉션에서 최댓값을 반환한다. - 재귀적 타입 한정 사용 (179쪽)
    public static <E extends Comparable<E>> E max(Collection<E> c) {
        if (c.isEmpty())
            throw new IllegalArgumentException("컬렉션이 비어 있습니다.");

        E result = null;
        for (E e : c)
            if (result == null || e.compareTo(result) > 0)
                result = Objects.requireNonNull(e);

        return result;
    }

    public static void main(String[] args) {
        List<String> argList = List.of("keesun", "whiteship");
        System.out.println(max(argList));
    }
}

RecursiveTypeBound 클래스는 가장 큰 값을 꺼내주는 기능을한다.

이때 재귀적 타입 한정 을 사용했다.

여기서 좀 더 유연하게 만들려면

public static <E extends Comparable<? super E>> E max(List<? extends E> list) {
      if (list.isEmpty())
      throw new IllegalArgumentException("빈 리스트");

      E result = null;
      for (E e : list)
      if (result == null || e.compareTo(result) > 0)
      result = e;

      return result;
      }

위와 같이 값을 받아오는 프로듀서 애서는 List<? extends E> 를 사용하고

Comparable 은 무언가 값을 꺼내 비교하는 소비자 이기 떄문에

Comparable<? super E> 를 사용했다.

우리가 사용하는 타입의 상위 타입만 Comparable 을 구현한 경우가 있기 때문이다.

public class Box<T extends Comparable<T>> implements Comparable<Box<T>> {

    protected T value;

    public Box(T value) {
        this.value = value;
    }

    public void change(T value) {
        this.value = value;
    }

    @SuppressWarnings("unchecked")
    @Override
    public int compareTo(Box anotherBox) {
        return this.value.compareTo((T)anotherBox.value);
    }

    @Override
    public String toString() {
        return "Box{" +
                "value=" + value +
                '}';
    }
}

Comparable 을 구현한 Box 클래스를 작성한다.

public class IntegerBox extends Box<Integer> {

    private final String message;

    public IntegerBox(int value, String message) {
        super(value);
        this.message = message;
    }

    @Override
    public String toString() {
        return "IntegerBox{" +
                "message='" + message + '\'' +
                ", value=" + value +
                '}';
    }
}

IntegerBox 클래스는 Box 클래스만 상속받고 있다.

IntegerBox 클래스는 직접적으로 Comparable 구현하고 있지는 않다.

public class Main {
   public static void main(String[] args) {
      List<IntegerBox> list = new ArrayList<>();
      list.add(new IntegerBox(10, "keesun"));
      list.add(new IntegerBox(2, "whiteship"));

      System.out.println(RecursiveTypeBound.max(list));
   }
}

이러한 경우에도 max 메서드가 잘 동작한다.

IntegerBox 클래스는 직접적으로 Comparable 구현하고 있지는 않지만

IntegerBox 의 super 타입인 Box 타입이

Comparable 구현했기 때문에 <E extends Comparable<? super E>> 타입에 맞는 타입이다.

---

와일드 카드 활용 팁

와일드 카드를 언제 어떻게 사용하면 좋은지와 주의사항을 알아보도록 하자.

와일드 카드는 ? 를 지칭한다.

? 하나만 사용하지는 않고 더 허용하고 싶은 매개변수를 넓혀줄 때

extends 나 super 키워드와 같이 와일드 카드 를 사용한다.

? 하나만 선언했을 때는 불특정 타입 이 된다.

E 는 특정할 수 있는 타입이지만 ? 는 특정할 수 없는 임의의 타입이다.

// 와일드카드 타입을 실제 타입으로 바꿔주는 private 도우미 메서드 (189쪽)
public class Swap {

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

    // 와일드카드 타입을 실제 타입으로 바꿔주는 private 도우미 메서드
    private static <E> void swapHelper(List<E> list, int i, int j) {
        list.set(i, list.set(j, list.get(i)));
    }

    public static void main(String[] args) {
        // 첫 번째와 마지막 인수를 스왑한 후 결과 리스트를 출력한다.
        List<String> argList = Arrays.asList(args);
        swap(argList, 0, argList.size() - 1);
        System.out.println(argList);
    }
}

위의 클래스처럼 E 를 사용하는 경우에는 ? 로 고칠 수 있다.

// 와일드카드 타입을 실제 타입으로 바꿔주는 private 도우미 메서드 (189쪽)
public class Swap {

    public static void swap(List<?> list, int i, int j) {
        list.set(i, list.set(j, list.get(i))); // 컴파일 에러
    }

    // 와일드카드 타입을 실제 타입으로 바꿔주는 private 도우미 메서드
    private static <E> void swapHelper(List<E> list, int i, int j) {
        list.set(i, list.set(j, list.get(i)));
    }

    public static void main(String[] args) {
        // 첫 번째와 마지막 인수를 스왑한 후 결과 리스트를 출력한다.
        List<String> argList = Arrays.asList(args);
        swap(argList, 0, argList.size() - 1);
        System.out.println(argList);
    }
}

위와같이 ? 를 사용하게 되면 값을 넣을 수가 없어진다.

List<?> list 와 같이 비 한정적 타입 을 사용하면

list.set(j, list.get(i)) 에서도 비 한정적 타입 을 원한다.

심지어 list.get(i) 에서도 우리가 모르는 무언가의 타입이 나오게된다.

비 한정적 와일드카드 타입 은 타입을 모른다.

E 는 어떠한 특정한 타입을 안다.

? 타입은 오로지 Null 밖에 허용하지 않는다.

때문에 ? 타입 하나만 사용하는 걸 권장하지는 않는다.

? 를 사용했을 때 메서드 시그니쳐는 간소화시킬 수 있지만

값을 넣는 것 은 가능하지 않다.

대신 값을 꺼내는 것 은 가능하다.

? 타입은 Null 빼고는 아무것도 매치가 되지 않는다.

그래서 무언가를 꺼내기만 할 거라면 ? 하나만 사용해도 되지만

무언가를 넣는 작업이 있다면 ? 하나만 사용하면 안된다.

// 와일드카드 타입을 실제 타입으로 바꿔주는 private 도우미 메서드 (189쪽)
public class Swap {

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

    // 와일드카드 타입을 실제 타입으로 바꿔주는 private 도우미 메서드
    private static <E> void swapHelper(List<E> list, int i, int j) {
        list.set(i, list.set(j, list.get(i)));
    }
}

무언가를 넣는 작업을 한다면 결국 E 타입을 정의해 사용할 수 밖에 없다.