[이펙티브 자바] Item30. 이왕이면 제네릭 메서드로 만들라.

 

[이펙티브 자바] Item30. 이왕이면 제네릭 메서드로 만들라. 

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

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

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

ex) Collections의 binarySearch, sort 등의 메서드는 모두 제네릭이다. 

 

 

 

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 guys = Set.of("톰", "닥", "해리");
      Set stooges = Set.of(1, 2, 3);
      Set all = union(guys, stooges);
      
      for (Object o : all)
      {
         System.out.println("o = " + (String) o);
      }
   }
}

 

다음 union 메서드는 두 집합의 합집합을 반환하는데 이때 문제가 있는 메서드이다. 

컴파일 에러는 없지만 이를 실행해보면 런타임 에러가 발생하는 것을 확인할 수 있다. 

 

문제를 해결하기 위해서는 메서드 선언에서 세 집합(입력 2개, 반환 1개)의 원소 타입을 타입 매개변수로 명시하고, 메서드 안에서 이 타입 매개변수만 사용하게 수정하면 된다.

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> guys = Set.of("톰", "닥", "해리");
      Set<String> stooges = Set.of("래리", "모에", "컬리");
//    Set<Integer> stooges = Set.of(1, 2, 3);
      Set<String> all = union(guys, stooges); // <Integer> 는 같은 타입을 넣으라고 했기 때문에 error
      
      for (String o : all)
      {
         System.out.println("o = " + o);
      }
   }
}

타입 매개변수들을 선언하는 타입 매개변수 목록은 메서드의 제한자와 반환 타입 사이에 온다. 

제네릭 메서드는 경고 없이 이제 컴파일 되고, 타입 안전하며, 쓰기도 쉽다는 장점이 있다. 

union 메서드는 집합 3개(입력 2개, 반환 1개)의 타입이 모두 같아야 한다. (이는 한정적 와일드 카드를 사용하면 좀 더 유연하게 사용할 수 있다.)

 

 

제네릭 싱글턴 팩터리 

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

제네릭은 런타임에 타입 정보가 소거되므로 하나의 객체를 어떤 타입으로든 매개변수화할 수 있다. 

하지만 이렇게 하려면 요청한 타입 매개변수에 맞게 매번 그 객체의 타입을 바꿔주는 정적 팩터리를 만들어야 한다. 

이러한 패턴을 제네릭 싱글턴 팩터리라고 한다. 

 

public class GenericSingletonFactory
{
   public static Function<String, String> stringIndentityFunction()
   {
      return (t) -> t;
   }
   
   public static Function<Number, Number> integerIdentityFunction()
   {
      return (t) -> t;
   }
   
   
   public static void main(String[] args)
   {
      String[] strings = { "삼베", "대마", "나일론" };
      Function<String, String> sameString = stringIndentityFunction();
      for (String string : strings)
      {
         System.out.println("sameString = " + sameString.apply(string));
      }
      
      Number[] numbers = { 1, 2.0, 3L };
      Function<Number, Number> sameNumber = integerIdentityFunction();
      for (Number number : numbers)
      {
         System.out.println("sameNumber = " + sameNumber.apply(number));
      }
   }
}

-> 이 클래스는 항등함수를 담은 클래스로 지금은 제네릭 사용하기 전으로 항등함수를 타입별로 하나씩 만들어야 했지만, 

 

public class GenericSingletonFactory
{
   // 제네릭 싱글톤 팩터리 패턴
   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 string : strings)
      {
         System.out.println("sameString = " + sameString.apply(string));
      }
      
      Number[] numbers = { 1, 2.0, 3L };
      UnaryOperator<Number> sameNumber = identityFunction();
      for (Number number : numbers)
      {
         System.out.println("sameNumber = " + sameNumber.apply(number));
      }
   }
}

소거 방식을 사용한 덕에 제네릭 싱글턴 하나만 충분히 사용할 수 있다. 

public static <T> UnaryOperator<T> identityFunction()
{
   return (UnaryOperator<T>) IDENTITY_FN;
}

여기서 IDENDITY_FN을 UnaryOperator<T>로 형변환하면 비검사 형변환 경고가 발생한다. 

T가 어떤 타입이든 UnaryOpeartor<Object>는 UnaryOperator<T>가 아니기 때문이다. 

 

그런데 위의 예제는 항등함수로 입력 값을 수정없이 그대로 반환하고 있기 때문에 T가 어떤 타입이든 UnaryOperator<T>를 사용해도 타입 안전하다. 

따라서 @SuppressWarning 어노테이션을 추가해서 경고를 숨길 수 있다. 

 

 

 

 

재귀적 타입 한정 recursive type bound 

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

public class RecursiveTypeBound
{
   // 재귀적 타입 한정을 사용해 컬렉션에서 최대값을 반환한다.
   public static <E extends Comparable<E>> E max(Collection<E> collection)
   {
      if (collection.isEmpty()) {
         throw new IllegalArgumentException();
      }
      
      E result = null;
      for (E e : collection)
      {
         if (result == null || e.compareTo(result) > 0)
         {
            result = Objects.requireNonNull(e);
         }
      }
      
      return result;
   }
   
   public static void main(String[] args)
   {
      List<String> argList = List.of("hyejin", "park");
      System.out.println("max(argList) = " + max(argList));
   }
}

<E extends Comparable<E>> : 모든 타입 E는 자신과 비교할수 있다. 

 

 

 

 

📚 정리

클라이언트에서 입력 매개변수와 반환값을 명시적으로 형변환해야 하는 메서드보다 제네릭 메서드가 더 안전하며 사용하기 쉽다. 

메서드도 타입과 마찬가지로 형변환 없이 사용할 수 있는 편이 좋으며, 그렇게 하려면 거의 제네릭 메서드가 되어야 한다. 

따라서 타입과 마찬가지로 형변환을 해줘야 하는 기존 메서드는 제네릭하게 만들자!!!