Item30 - 이왕이면 제네릭 메서드로 만들라

 

 

매개변수화 타입을 받는 정적 유틸리티 메서드

 - 한정적 와일드카드 타입(아이템31)을 사용하면 더 유연하게 개선할 수 있다.

 

클래스와 같이 메서드도 제네릭으로 만들 수 있다. 매개변수화 타입을 받는 정적 유틸리티 메서드는 보통 제네릭이다.

다음 예제를 보자 두 집합의 합집합을 반환하는 메서드이다.

public static Set union(Set s1, Set s2) {
    Set result = new HashSet<>(s1);
    result.addAll(s2);
    return result;
}

 

메서드 사용시 타입이 다른 두개의 Set을 호출해도 이상이 없지만 합집합을 타입 캐스팅하면 문제가 생긴다.

	/*정상*/
	public static void main(String[] args) {
        Set guys = Set.of("톰", "딕", "해리");
        Set stooges = Set.of(1,2,3);
        Set all = union(guys, stooges);

        System.out.println(all);
    }
    
    => [톰, 1, 해리, 2, 3, 딕]
    
    ======================================================================================
    
    /*에러*/
    public static void main(String[] args) {
        Set guys = Set.of("톰", "딕", "해리");
        Set stooges = Set.of(1,2,3);
        Set all = union(guys, stooges);

        for (Object o : all) {
            System.out.println((String)o);
        }
    }
    
    => 
	톰
    Exception in thread "main" java.lang.ClassCastException:
    class java.lang.Integer cannot be cast to class java.lang.String
    (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
    at effective.study.chapter05.item30._01_before.Union.main(Union.java:23)

 

이 메서드를 타입 안전하게 만들어야 한다. 메서드 선언에서 세 집합(입력 2개, 반환 1개)의 원소 타입을 타입 매개변수로 명시한다. (타입 매개변수 목록은 메서드의 제한자와 반환 타입 사이에 온다.)

public static <E> Set<E> union(Set<E> s1, Set<E> s2) {
    Set<E> result = new HashSet<>(s1);
    result.addAll(s2);
    return result;
}

 

제네릭 메서드로 바꾸면 두 매개변수가 같은 데이터 타입을 받기 때문에 데이터 타입이 다른 매개변수가 들어올 시 컴파일이 되지 않는다.

 

 

제네릭 싱글턴 팩터리

 - (소거 방식이기 때문에) 불변 객체 하나를 어떤 타입으로든 매개변수화 할 수 있다.

 

때때로 불변 객체를 여러 타입으로 활용할 수 있게 만들어야 할 때가 있다. 제네릭은 런타임에 소거되므로 하나의 객체를 어떤 타입으로든 매개변수화할 수 있다. 이렇게 하려면 요청한 타입 매개 변수에 맞게 매번 그 객체의 타입을 바꿔주는 정적 팩터리를 만들어야 한다. => 제네릭 싱글턴 팩터

// 코드 30-4 제네릭 싱글턴 팩터리 패턴 (178쪽)
private static UnaryOperator<Object> IDENTITY_FN = (t) -> t;

@SuppressWarnings("unchecked")
public static <T> UnaryOperator<T> identityFunction() {
    return (UnaryOperator<T>) IDENTITY_FN;
}


public static void main(String[] args) {
    String[] strings = { "삼베", "대마", "나일론" };
    UnaryOperator<String> sameString = identityFunction();
    for (String s : strings)
        System.out.println(sameString.apply(s));

    Number[] numbers = { 1, 2.0, 3L };
    UnaryOperator<Number> sameNumber = identityFunction();
    for (Number n : numbers)
        System.out.println(sameNumber.apply(n));
}

바이트 코드를 보면

UnaryOperator<String> sameString = identityFunction();

=> UnaryOperator<Object> sameString = identityFunction();

 

위처럼 제네릭이 소거되고 Object가 String으로 타입 캐스팅하는 모습을 볼 수 있다.

 

 

재귀적 타입 한정

 - 자기 자신이 들어간 표현식을 사용하여 매개변수의 허용 범위를 한정한다.

 

상대적으로 드물지만, 자기 자신이 들어간 표현식을 사용하여 타입 매개변수의 허용 범위를 한정할 수 있다.

=> 재귀적 타입 한정

 

재귀적 타입 한정은 주로 타입의 순서를 정하는 Comparable 인터페이스와 함께 쓰인다.

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;
}

 

타입 한정인 <E extends Comparable<E>> 는 "모든 타입 E는 자신과 비교할 수 있다"라고 읽을 수 있다.

 

String 클래스는 Comparable을 구현하고 있어서 위 메서드를 사용할 수 있다.

 

제네릭에 String을 넣어보면 훨씬 직관적이다.

 

<E extends Comparable<E>>

String implements Comparable<String>