이왕이면 제네릭 메서드로 만들라 - [5장. 제네릭(아이템30)]

  클래스와 마찬가지로, 메서드도 제네릭으로 만들 수 있다. 제네릭 메서드 3가지를 살펴보면서 어떻게 제네릭 메서드를 만드는지 알아보자.

 

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

  매개변수화 타입을 받는 정적 유틸리티 메서드는 보통 제네릭이다. (Collections의 알고리즘 메서드는 모두 제네릭이다.)

우선, 제네릭을 사용하지 않은 메서드를 살펴보자

public class Union {

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

  해당 메서드는 아래의 예시에서 살펴볼 수 있는 것처럼 안전하지 않다.

public static void main(String[] args) {
    Set names = Set.of("amenable", "immortal", "choi");
    Set numbers = Set.of(1, 2, 3);

    Set all = union(names, numbers);

    for(Object o : all){
        System.out.println((String)o); // ClassCastException
    }
}

 

  그러므로 이것을 제네릭 메서드로 바꿔보자. 방법은 다음과 같다.

1. 원소 타입을 타입 매개변수로 명시한다.
2. 메서드 안에서도 이 타입 매개변수만 사용하게 수정한다.
3. 타입 매개변수들을 선언하는 타입 매개변수 목록은 메서드의 제한자와 반환 타입 사이에 넣는다.

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

  제네릭 메서드를 사용하면 문제가 되던 상황(런타임 에러가 발생하는 것)을 컴파일 타임에 알 수 있다.

public static void main(String[] args) {
    Set<String> names = Set.of("amenable", "immortal", "choi");
    Set<Integer> numbers = Set.of(1, 2, 3);

    Set all = union(names, numbers); // 컴파일 에러
}

  또한, 직접 형변환하지 않아도 어떤 오류나 경고 없이 컴파일된다.

public static void main(String[] args) {
    Set<String> groupA = Set.of("amenable", "immortal", "choi");
    Set<String> groupB = Set.of("perseverance", "sunny");

    Set<String> all = union(groupA, groupB);

    for(String o : all){
        System.out.println(o);
    }
}

  한정적 와일드카드 타입을 사용하면 더 유연하게 개선할 수 있는데, 이것은 다음 아이템인 아이템 31에서 살펴보도록 하자. 

 

 

2. 제네릭 싱글턴 팩터리 🌻

  때때로 불변 객체를 여러 타입으로 활용할 수 있게 만들어야 할 때가 있다.

  올바르지 않은 코드(여러 타입을 활용할 수 있는 것이 아닌 경우)는 다음과 같다. (예제는 모든 원소를 자기 자신으로 대응시키는 함수인 항등함수를 이용한 코드다.)

public class GenericSingletonFactory {

    public static Function<String, String> stringIdentityFunction() {
        return (t) -> t;
    }

    public static Function<Number, Number> integerIdentityFunction() {
        return (t) -> t;
    }
}

----------

public static void main(String[] args) {
    String[] names = {"amenable", "immortal", "choi"};
    Function<String, String> sameNames = stringIdentityFunction();
    for (String s : names) {
        System.out.println(sameNames.apply(s));
    }

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

 

  하지만, 자바의 제네릭이 실체화되는 게 아니라 소거되기 때문에 불변 객체 하나를 어떤 타입으로든 매개변수화 할 수 있다.

  요청한 타입 매개 변수에 맞게 매번 그 객체 타입을 바꿔주는 정적 팩터리를 이용하면 된다. 이 패턴을 제네릭 싱글턴 팩터리 패턴이라고 한다.

public class GenericSingletonFactory {

    private static UnaryOperator<Object> IDENTITY_FN = (t) -> t;

    // 입력 값을 수정 없이 그대로 반환하는 항등함수이므로,
    // T가 어떤 타입이든 UnaryOperator<T>를 사용해도 타입 안전하다.
    @SuppressWarnings("unchecked")
    public static <T> UnaryOperator<T> identityFunction() {
        return (UnaryOperator<T>) IDENTITY_FN;
    }
}

----------

public static void main(String[] args) {
    String[] names = {"amenable", "immortal", "choi"};
    Function<String, String> sameNames = identityFunction();
    for (String s : names) {
        System.out.println(sameNames.apply(s));
    }

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

 

 

3. 재귀적 타입 한정 🌷

  자기 자신이 들어간 표현식을 사용하여 타입 매개변수의 허용 범위를 한정할 수 있는 '재귀적 타입 한정(Recursive Type Bound)을 알아보자.

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

public class RecursiveTypeBound {

    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 = Arrays.asList("amenable", "immortal");
    System.out.println(max(argList)); // immortal
}

  타입 한정인 <E extends Comparable<E>>는 "모든 타입 E는 자신과 비교할 수 있다"라고 읽을 수 있다. 상호 비교 가능하다는 뜻을 아주 정확하게 표현한 것이다.

 

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