[이펙티브 자바] Item26. 로 타입은 사용하지 말라.

 

[이펙티브 자바] Item26. 로 타입은 사용하지 말라. 

 

https://hyejin.tistory.com/1124

[이펙티브 자바] Item26. 로 타입은 사용하지 말라.

저번 글에서 제네릭 타입에 대한 용어 정리를 했고, 그러면서 로 티입을 사용하면 안좋은? 이유에 대해서 살짝 적었는데 이번 글에서 좀 더 자세히 작성한다. 

 

 

로 타입을 사용하지 말고 매개변수화 타입을 사용하라. 

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

for (Object number : numbers) {
    System.out.println("number = " + (Integer)number); // error!
}

 

        List<Integer> numbers2 = new ArrayList<>();
        numbers2.add(10);
        numbers2.add("whiteShip"); // compile error 발생

        // 형변환도 필요 없음
        for (Integer integer : numbers2) {
            System.out.println("integer = " + integer);
        }

로 타입을 사용한 위의 예제와 매개변수화 타입을 사용한 아래 예제로 이유를 알 수 있다. 

먼저 매개변수화 타입을 사용하면 런타임이 아닌 컴파일 시점에 문제를 찾을 수 있다. 

밑에서는 List<Integer> 로 numbers를 선언했기 때문에 여기에 whiteShip이라는 문자열을 넣으려고 하니 컴파일 시점에서 바로 에러를 나타내 런타임까지 가지 않고도 에러를 수정할 수 있다.

 

그리고 제네릭을 활용하면 이 정보가 주석이 아닌 타입 선언 자체에 녹아있기 때문에 표현력역시 좋다. 

List numbers 를 보면 필드명을 numbers 을 통해 대충 짐작은 할 수 있긴 하지만 정확히 어떤 값이 들어가는지에 대해서는 넣어봐야 안다.

하지만 List<Integer> numbers2를 보면 그냥 한눈에 아 이 List는 Integer를 넣는구나! 하고 알 수 있다. 

 

따라서 제네릭을 활용하진 않은 로타입을 사용하면 안정성과 표현력을 잃는다. 

 

 

근데.. 그렇다면 로타입이 굳이 왜 있는가? 에 대해서 의문을 가질 수 있다. 

그냥 매개변수화 타입만 사용하면 되는거 아닌가?

public class Box<E /*extends Number*/> { // 제네릭 클래스 <E> : 타입 매개변수 extends Number : Number를 상속받은 타입만 가능 (한정적인 타입 매개변수)

    private E item;

    private void add(E e) {
        this.item = e;
    }

    private E get() {
        return this.item;
    }

    public static void main(String[] args) {
        Box<Integer> box = new Box<>(); // <Integer> : 실제 타입 매개변수
        box.add(10);
        System.out.println(box.get() * 100);
        printBox(box);

    }
    private static void printBox(Box<?> box) { // 비한정적 와일드 카드 타입 (아무런 타입이나 대응이 된다.)
        System.out.println("box = " + box.get());
    }
}

여기서 보면 Box<Integer>로 매개변수화 타입을 사용해서 box를 선언했다. 

build 후 byte code를 보면 

컴파일런느 컬렉션에서 원소를 꺼내는 모든 곳에 보이지 않는 형변환을 추가하여 절대 실패하지 않음을 보장한다. 

Box의 Integer가 아닌 Object인걸 확인할 수 있고, 그 다음 CHECKCAST를 통해 Integer로 형변환을 따로 해주는 것을 알 수 있다. 

즉, 코드 상에서만 우리가 사용하기 편하게 매개변수화 타입을 사용하는 것이라는 것이다. 

 

또한 하위 자바 버전과의 호환성을 위해서도 로타입을 지원한다. 

자바 제네릭을 받아들이기 전까지 10년이라는 시간이 걸렸기 때문에 제네릭이 없이 짠 코드가 이미 많이 있다. 

따라서 기존 코드를 모두 수용하기 하면서 제네릭을 사용하는 새로운 코드와도 맞물려 돌아가야만 했다. 

이 마이그레이션 호환성을 위해 로 타입을 지원하고 제니릭 구현에는 소거 방식을 사용하기로 했다. 

 

 

 

 

List와 List<Object>의 차이는?

public class Raw {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        unsafeAdd(strings, Integer.valueOf(42)); // 잘못된 값이 들어갈 수 있다!
        String s = strings.get(0); // 컴파일러가 자동으로 형변환 코드를 넣어준다.

//        unsafeAdd2(strings, Integer.valueOf(42)); // List<Object>와 List<String>은 다른것이기 때문에 애초에 에러가 난다.
    }

    // 로 타입은 타입 안정성을 잃었다.
    // 왜냐하면 어떤 List든 일단 받고 잘못된 값이 들어갈 확률이 많기 때문이다.
    private static void unsafeAdd(List list, Object o) {
        list.add(o);
    }

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

List와 List<Object>는 그럼 같은 것 아닌가? 할 수 있는데 거의 비슷하지만 안정성의 부분에서 차이가 있다. 

List는 제네릭 타입에서 완전히 발을 뺀 것이고, List<Object>는 모든 타입을 허용한다는 의사를 컴파일러에 명확히 전달한 것이다. 

unsafeAdd 메서드를 보면 List에 strings 가 들어가고, 42가 들어가고, strings에서 get 하는 부분에서 에러가 나는데 애초에 값이 들어가는 부분에서 값이 잘못 들어가는 문제가 있다. 

 

 

그런데 unsafeAdd2를 보면 List<Object>에 strings를 넣으려고 하면 에러가 난다. 왜냐하면 List<Object>와 List<String>은 다르기 때문이다. 

String이 Object의 하위 클래스니까 되지 않나? 할 수 있지만  다르다. 

매개변수로  List를 받는 메서드에 List<String>은 넘길 수 있지만, List<Object> 를 받는 메서드에는 넘길 수 없다. 이는 제네릭 하위 타입 규칙 때문으로 List<String> 은 List의 하위 타입이지만 List<Object>는 아니기 때문이다. 

 

따라서 List<Object> 같은 매개변수화 타입을 사용할 때와 달리 List같은 로타입을 사용하면 타입 안정성을 잃게 된다. 

 

 

또한 Set과  Set<?> 차이 역시 안정성에 있다. 

public class Numbers {
    static int numElementsInCommon(Set s1, Set s2) { // 역시 Set은 안정성이 깨진다 (아무값이나 넣을 수 있어서)
        int result = 0;
        for (Object o : s1) {
            if (s2.contains(o)) {
                result ++;
            }
        }
        return result;
    }

    // Set<?>으로 선언하면 무엇이든 받을 수 있는 Set 타입이 된다.
    static int numElementsInCommon2(Set<?> s1, Set<?> s2) { // Set<?>는 한종류의 타입만 받을 수 있다.
        int result = 0;
        for (Object o : s1) {
            if (s2.contains(o)) {
                result ++;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        Set<?> mySet = set;


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

Set과 Set<?> 역시 비슷하긴 하지만 Set은 안정성을 잃는 다는 점에서 차이가 있다. 

제네릭 타입을 쓰고는 싶지만 실제 타입 매개변수가 무엇인지 신경  쓰고 싶지 않다면 와일드 카드를 대신 사용하는게 좋다. 

Set<?> 은 어떤 타입이라도 담을 수 있는 가장 범용적인 매개변수화 Set 타입이다. 

 

로 타입 컬렉션에서는 아무 원소나 넣을 수 있어 타입 불변식을 훼손하기 쉬운 반면, Collection<?>에는 null 외에는 어떤 원소도 넣을 수 없다. 

 

 

대부분의 경우에서 로타입이 아닌 매개변수화 타입을 사용하면 되는데 예외가 있다. 

바로 class 리터럴과 instanceof이다. 

public class UseRawType<E> {
    private E e;

    public static void main(String[] args) {
        System.out.println("UseRawType.class = " + UseRawType.class);

        UseRawType<String> stringUseRawType = new UseRawType<>();

        System.out.println("stringUseRawType = " + (stringUseRawType instanceof UseRawType));
    }
}

UserRawType<Integer>.class라는것은 없고, 클래스명.class만 가능하다.

그리고 instanceof도 매개변수화 타입을 지원하지 않고 로타입으로 사용해야 한다. 

 

 

 

📖 정리 

class 리터럴과 instanceof 예외를 제외하고는 로 타입을 사용하면 안정성과 표현력을 잃기 때문에 매개변수화 타입을 사용하자!! 

로 타입을 사용하면 런타임 에러가 일어날 수 있기 때문에 사용하면 안된다. 로 타입은 그저 제네릭이 도입되기 전에 이전 코드와의 호환성을 위해 제공되었을 뿐이다! 

 

Set<Object>는 어떤 타입의 객체도 저장할 수 있는 매개변수화 타입 

Set<?> 는 모종의 타입 객체만 저장할 수 있는 와일드 카드 타입 

Sest 은 로 타입으로 제네릭 타입 시스템에 속하지 않는다. 

 

Set<Object>와 Set<?> 는 안전하지만, 로 타입은 안전하지 않다. 

 

 

한글 용어	영문 용어	예
매개변수화 타입	paramterized type	List<String>
실제 타입 매개변수	actual type paramteter	String
제네릭 타입	generic type	List<E>
정규 타입 매개변수	formal type paramteter	E
비한정적 와일드 카드 타입	unbounded wildcard type	List<?>
로 타입	raw type	List
한정적 타입 매개변수	bounded type paramter	<E extends Number>
재귀적 타입 한정	recursive type bound	<T extends Comparable<T>>
한정적 와일드 카드 타입	bounded wildcard type	List<? extends Number>
제네릭 메서드	generic method	static <E> List<E>
타입 토큰	type token	String.class