로 타입은 사용하지 말라 - [5장. 제네릭(아이템26)]

  이번 장(5장)부터는 제네릭을 다룬다. 혹시나 제네릭에 대한 기본 개념이 필요하다면 이전 글을 먼저 보고 오도록 하자.

 

1. 로 타입 (Raw Type) 개념 💽

  로 타입이란 제네릭 타입에서 타입 매개변수를 전혀 사용하지 않을 때를 말한다. 예를 들어 List<E>의 로 타입은 List다.

 

2. 로 타입을 사용하면 안 되는 이유 💾

  제네릭이 안겨주는 안전성과 표현력을 고려할 때 로 타입은 절대로 써서는 안 된다.

  로 타입을 사용하는 코드(= 제네릭을 사용하지 않는 코드)와 로 타입을 사용하지 않는 코드(= 제네릭을 사용하는 코드)를 비교해 보자.

📒 1. 로 타입을 사용하는 경우

  기본적인 동작은 numbers에 숫자를 넣고 반복문을 통해 들어간 숫자를 확인하려고 하는 코드다. 숫자가 들어가야 하지만 문자열이 들어간 경우에 어떻게 동작하는지 살펴보자.

// 로 타입 사용 O (Generic 사용 X)
public static void main(String[] args) {


    List numbers = new ArrayList();
    numbers.add(10);
    numbers.add("amenable");

    for (Object number : numbers) {
        System.out.println((Integer) number); // ClassCastException
    }
}

  로 타입을 사용하면 문자열이 들어가더라도 컴파일이 된다. 하지만 런타임에 문자열을 Integer로 바꿀 때 ClassCastException이 발생하게 된다.

  오류는 런타임 상황이 아닌 컴파일할 때 발견하는 것이 가장 좋은데, 위의 경우는 그것을 만족하지 못하고 있다.

📒 2. 로 타입을 사용하지 않는 경우

// 로 타입 사용 X (Generic 사용 O)
public static void main(String[] args) {

    List<Integer> numbers = new ArrayList<>();
    numbers.add(10);
    numbers.add("amenable"); // Compile Error 발생

    for (Integer number : numbers) {
        System.out.println(numbers);
    }
}

  로 타입을 사용하지 않고 제네릭을 사용하는 경우를 살펴보자. 이 경우에는 컴파일 에러가 바로 발생한다. numbers에는 Integer만 넣어야 하는 것을 컴파일러가 인지하고 있는데 문자열(String)을 넣으려고 해서 컴파일 에러가 발생하는 것이다.

 

1. 즉, 이렇게 컴파일 시점에 오류를 발견할 수 있으므로 안전성을 확보할 수 있다.
2. 또한, 'List<Integer> numbers'라고 선언한다면 numbers에 Integer 타입만 넣어야 한다는 것을 바로 알 수 있으므로 표현력 또한 확보할 수 있다.

 

3. List VS List<Object> 💿

  List 같은 로 타입은 사용해서는 안 되나, List<Object>처럼 임의 객체를 허용하는 매개변수화 타입은 괜찮다.

  List는 제네릭 타입이 아예 아니고, List<Object>는 Object를 타입 매개 변수로 가지기 때문이다. 즉, List<Object>는 모든 타입을 허용한다는 의사를 컴파일러에 명확히 전달한다.

  그래서 매개변수로 List를 받는 메서드에 List<String>을 넘길 수는 있지만, List<Object>를 받는 메서드에는 넘길 수 없다. List<String>은 로 타입인 List의 하위 타입이지만, List<Object>의 하위 타입은 아니기 때문이다.

  List와 List<Object>를 사용하는 코드를 비교해 보면 쉽게 이해할 수 있을 것이다.

📒 1. List

public static void main(String[] args) {
    List<String> strings = new ArrayList<>();
    unsafeAdd(strings, Integer.valueOf(27));
    String s = strings.get(0); // ClassCastException
}

private static void unsafeAdd(List list, Object o) {
    list.add(o);
}

  해당 코드에서 strings.get(0)의 결과를 형변환 하려고 할 때 ClassCastException이 발생한다. 

  컴파일할 때 발생하는 것이 아닌 런타임에 발생한다.

📒 2. List<Object>

public static void main(String[] args) {
    List<String> strings = new ArrayList<>();
    safeAdd(strings, Integer.valueOf(27)); // Compile Error
    String s = strings.get(0);
}

private static void safeAdd(List<Object> list, Object o) {
    list.add(o);
}

  반면에 List<Object>를 사용하면 Compile Error가 발생하면서 컴파일조차 되지 않는 것을 확인할 수 있다.

 

4. Set VS Set<?> 📀

  위에서 List<Object>를 사용하면서 원소의 타입을 몰라도 되는 코드를 작성하고 싶을 것이다. 이런 경우 로 타입이 아닌 비한정적 와일드카드 타입(unbounded wildcard type)을 사용하는 게 좋다.

  즉, 제네릭 타입을 쓰고 싶지만 실제 타입 매개변수가 무엇인지 신경 쓰고 싶지 않다면 물음표(?)를 사용하자. 이것은 어떤 타입이라도 담을 수 있는 가장 범용적인 매개변수화 타입이다.

  그러면 Set<?> 대신 Set도 매개변수를 신경 쓰지 않아도 되는데 왜 Set<?>을 권장하는 것일까? Set과 Set<?>를 사용하는 코드를 비교해 보자.

📒 1. Set

static int numElementsInCommon(Set s1, Set s2) {

    s1.add("4"); // UnsupportedOperationException

    int result = 0;
    for (Object o1 : s1) {
        if (s2.contains(o1)){
            result++;
        }
    }

    return result;
}

public static void main(String[] args) {

    System.out.println(Numbers.numElementsInCommon(Set.of(1, 2, 3), Set.of(1, 2)));
}

  위의 코드는 Set인 s1과 s2에 공통적으로 있는 숫자의 개수를 카운트하려고 하고 있다. 하지만, 코드에서 확인할 수 있는 것처럼 숫자뿐만 아니라 문자열도 넣을 수 있다. (s1.add("4"))

  코드에서 s1.add("1")을 하려고 할 때 UnsupportedOperationException 발생한다. 컴파일할 때 발생하는 것이 아닌 런타임에 발생한다.

  즉, 로 타입 컬렉션에 아무 원소나 넣을 수 있어서 안전하지 않은 상황이다.

📒 2. Set<?>

static int numElementsInCommon(Set<?> s1, Set<?> s2) {

    s1.add(4); // Compile Error

    int result = 0;
    for (Object o1 : s1) {
        if (s2.contains(o1)){
            result++;
        }
    }

    return result;
}

public static void main(String[] args) {

    System.out.println(Numbers.numElementsInCommon(Set.of(1, 2, 3), Set.of(1, 2)));
}

  반면, Collection<?>에는 null 외에는 어떤 원소도 넣을 수 없으므로 안전하다. s1.add(4)가 있는 경우 Compile Error가 발생한다.

  그래서 결국 안전성을 고려하였을 때 Set이 아닌 Set<?>을 사용해야 한다.

 

5. 예외 📼

  계속해서 로 타입을 사용하지 말라고 말해왔다. 하지만 역시 로 타입을 쓰지 말라는 규칙에도 2가지 예외가 존재한다.

📒 1. class 리터럴

  class 리터럴에는 로 타입을 써야 한다.

  자바 명세는 class 리터럴에 매개변수화 타입을 사용하지 못하게 했다. (배열과 기본 타입은 허용한다.)

public class UserRawType<E> {

    private E e;
}

----------

public static void main(String[] args) {

    // 혀용 X
    System.out.println(UserRawType<Integer>.class);

    // 허용 O
    System.out.println(UserRawType.class);
}

  즉, List.class, String[].class, int.class는 허용하고 List<String>.class와 List<?>.class는 허용하지 않는다.

📒 2. instanceof 연산자

public class UserRawType<E> {

    private E e;
}

----------

public static void main(String[] args) {

    UserRawType<String> stringType = new UserRawType<>();

    // 허용 O
    System.out.println(stringType instanceof UserRawType<String>);
    // 허용 O
    System.out.println(stringType instanceof UserRawType);
}

  위의 코드처럼 instanceof에 제네릭을 사용하는 방식과 로 타입을 사용하는 방식 둘 다 사용할 수는 있다. 런타임에는 제네릭 타입 정보가 지워지므로 두 개 모두 완전히 똑같이 동작한다.

  그러므로 제네릭이 아무런 역할 없이 코드만 지저분하게 만들고 있으므로 이런 경우에는 차라리 로 타입을 쓰는 편이 깔끔하다.

 

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