[이펙티브 자바] Item29. 이왕이면 제네릭 타입으로 만들라.

 

[이펙티브 자바] Item29. 이왕이면 제네릭 타입으로 만들라. 

 

public class Stack
{
   private Object[] elements;
   private int size = 0;
   private static final int DEFAULT_INITIAL_CAPACITY = 16;
   
   public Stack()
   {
      elements = new Object[DEFAULT_INITIAL_CAPACITY];
   }
   
   public void push(Object e)
   {
      ensureCapacity();
   }
   
   public Object pop()
   {
      if (size == 0) {
         throw new EmptyStackException();
      }
      
      Object 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 static void main(String[] args)
   {
      Stack stack = new Stack();
      for (String arg: List.of("a", "b", "c"))
      {
         stack.push(arg);
      }
      while (!stack.isEmpty())
      {
         System.out.println(((String) stack.pop()).toUpperCase());
      }
   }
}

이 클래스에서는 Object 배열을 사용해서 Stack을 구현했는데 지금 클래스에서는 클라이언트 코드에서 꺼낼 때 마다 객체를 형변환 해야 하는데 이때 런타임 오류가 날 위험이 있다. 

 

따라서 이 클래스는 원래 제네릭 타입이어야 한다. 

1️⃣  E[] 를 이용한 제네릭 스택 

public class Stack<E>
{
   private E[] elements;
   private int size = 0;
   private static final int DEFAULT_INITIAL_CAPACTIY = 16;
   
   // 배열을 사용한 코드를 제네릭으로 만드는 방법 1
   // 배열 elements는 push(E) 로 넘어온 E 인스턴스만 담는다.
   // 따라서 타입 안정성을 보장하지만,
   // 이 배열의 런타임 타입은 E[]가 아닌 Object[] 다!
   // -> 이 방법의 유일한 단점은 Heap 오염이 발생할 수 있다는 점이다.
   @SuppressWarnings("unchecked")
   public Stack()
   {
      elements = (E[]) new Object[DEFAULT_INITIAL_CAPACTIY];
   }
   
   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 == 0) {
         elements = Arrays.copyOf(elements, 2 * size + 1);
      }
   }
   
   public static void main(String[] args)
   {
      Stack<String> stack = new Stack<>();
      for (String arg : List.of("a", "b", "c"))
      {
         stack.push(arg);
      }
      while (stack.isEmpty())
      {
         System.out.println(stack.pop().toUpperCase());
      }
   }
}

일반 클래스를 제네릭 클래스로 만드는 첫번째 방법은 클래스 선언에 타입 매개변수를 추가하는 일이다. 

그리고 이때 타입 이름으로는 보통 E를 많이 사용한다. 

@SuppressWarnings("unchecked")
public Stack()
{
   elements = (E[]) new Object[DEFAULT_INITIAL_CAPACTIY];
}

여기서 보면 E와 같은 실체화 불가 타입으로는 배열을 만들 수 없기 때문에 Object 배열을 생성한 다음에 제네릭 배열로 형변환을 하는 방법이다. 그러고 나면 이제 컴파일 오류가 발생하지는 않지만 타입 안전하지 않기 때문에 경고가 뜬다!  

 

컴파일러 입장에서 보면 이 프로그램이 타입 안전한지 증명할 방법이 없지만 우리는 알 수 있다. 

elements 배열은 private 필드에 저장되고, 클라이언트로 반환되거나 다른 메서드에 전달되는 일이 없다. 

그리고 push 메서드를 통해 배열에 저장되는 원소의 타입은 항상 E이다. 따라서 이 비검사 형변환은 확실히 안전하다! 

 

이렇게 비검사 형변환이 안전하다라는 것이 증명된다면 범위를 최소로 좁혀서 @SuppressWarnings("unchecked") 어노테이션을 통해서 경고를 숨길 수 있다. 

 

 

2️⃣ Object[] 를 이용한 제네릭 Stack 

public class Stack<E>
{
   private Object[] elements;
   private int size = 0;
   private static final int DEFAULT_INITIAL_CAPACTIY = 16;
   
   public Stack()
   {
      elements = new Object[DEFAULT_INITIAL_CAPACTIY];
   }
   
   public void push(E e)
   {
      ensureCapacity();
      elements[size++] = e;
   }
   
   // 배열을 사용한 코드를 제네릭으로 만드는 방법 2
   // 비검사 경고를 적절히 숨긴다.
   public E pop()
   {
      if (size == 0) {
         throw new EmptyStackException();
      }

      // push에서 E 타입만 허용하므로 이 형변환은 안전하다.
      @SuppressWarnings("unchecked")
      E result = (E) elements[--size];
      elements[size] = null; // 다 쓴 참조 해제
      return result;
   }
   
   public boolean isEmpty()
   {
      return size == 0;
   }
   
   
   private void ensureCapacity()
   {
      if (elements.length == 0) {
         elements = Arrays.copyOf(elements, 2 * size + 1);
      }
   }
   
   public static void main(String[] args)
   {
      Stack<String> stack = new Stack<>();
      for (String arg : List.of("a", "b", "c"))
      {
         stack.push(arg);
      }
      while (stack.isEmpty())
      {
         System.out.println(stack.pop().toUpperCase());
      }
   }
}

 

제네릭 배열 생성 오류를 해결하는 두번째 방법은 elements 필드의 타입을 E[] 에서 Object[]로 바꾸는 것이다. 

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

   // push에서 E 타입만 허용하므로 이 형변환은 안전하다.
   @SuppressWarnings("unchecked")
   E result = (E) elements[--size];
   elements[size] = null; // 다 쓴 참조 해제
   return result;
}

이제 elements 를 꺼낼 때 원소에 E로 형변환하면 오류 대신 경고가 뜨는데 

E는 역시 실체화 불가 타입이므로 컴파일러는 런타임에 이뤄지는 형변환이 안전한지 증명할 방법이 없다. 

하지만 우리는 직접 안전한지 증명하고 경고를 숨길 수 있다. 

pop 메서드 전체에 경고를 숨기지 말고 범위를 최소화해서 형변환을 수행하는 할당문에만 어노테이션을 붙여 경고를 숨겼다. 

 

 

 

🚩 위에서 언급한 제네릭 배열 생성을 제거하는 두 방법 모두 나름의 지지를 얻고 있다. 

첫번째 방법인 Object 배열을 생성한 뒤에 제네릭 배열로 형변환 하는 방법은 가독성이 좋고, 형변환을 배열 생성시 한 번만 한다는 장점이 있으며, 코드도 짧다. 

두번째 방법인 제네릭 배열 대신에 Object 배열을 사용하고, 배열이 반환한 원소를 E로 형변환하는 방법은 배열에서 원소를 읽을 때 마다 형변환을 해줘야 한다. 

따라서 현업에서는 첫번째 방법을 더 선호하며 자주 사용하는 편이다. 

 

그런데 첫번째 방법은 E가 Object가 아닌한 런타임 타입이 컴파일 타입과 달라서 힙 오염 heap pollution을 발생할 수 있다. 

힙 오염이 걸리는 사람은 두번째 방식을 사용하기도 한다. 

 

 

 

 

📚 정리

클라이언트에서 직접 형변환해야 하는 타입보다 제네릭 타입이 더 안전하고 쓰기 편하다. 

따라서 새로운 타입을 설계할 때는 형변환 없이도 사용할 수 있도록 제네릭 타입으로 만들자!!