1.6 지네릭 메서드

메서드의 선언부에 지네릭 타입이 선언된 선언된 메서드를 지네릭 메서드라고 한다.
앞에서 본 것처럼 Collections.sort()가 바로 지네릭 메서드이며,
지네릭 타입의 선언 위치는 반환 타입 바로 앞이다.

static <T> void sort(List<T> list, Comparator<? super T>c)

지네릭 클래스에 정의된 타입 매개변수와 지네릭 메서드에 정의된 타입 매개변수는 전혀 별개의 것이다.
같은 타입 문자 T를 사용해도 같은 것이 아니라는 것에 주의해야 한다.
!지네릭 메서드는 지네릭 클래스가 아닌 클래스에도 정의될 수 있다.

class FruitBox<T> {
		...
	static <T> void sort(List<T> list, comparator<? super T> c) {
		...
	}
}

위 코드에서 지네릭 클래스 FruitBox에 선언된 타입 매개변수 T와
지네릭 메서드 sort()에 선언된 타입 매개변수 T는 타입 문자만 같을 뿐 서로 다른 것이다.
그리고 sort()가 static메서드라는 것에 주목하자.
앞서 설명한 것처럼, static멤버에는 타입 매개변수를 사용할 수 없지만,
이처럼 메서드에 지네릭 타입을 선언하고 사용하는 것은 가능하다.

메서드에 선언된 지네릭 타입은 지역 변수를 선언한 것과 같다고 생각하면 이해하기 쉬운데,
이 타입 매개변수는 메서드 내에서만 지역적으로 사용될 것이므로 메서드가 static이건 아니건 상관이 없다.
! 같은 이유로 내부 클래스에 선언된 타입 문자가 외부 클래스의 타입 문자와 같아도 구별될 수 있다.

앞에서 나왔던 makeJuice()를 지네릭 메서드로 바꾸면 다음과 같다.

static Juice makeJuice(Fruit<? extends Fruit> box) {
	String tmp = "";
	for(Fruit f : box.getList()) tmp += f + "";
	return new Juice(tmp);
}

==>

static <T extends Fruit> Juice makeJuice(Fruit<T> box) {
	String tmp = "";
	for(Fruit f : box.getList()) tmp += f + "";
	return new Juice(tmp);
}

이제 이 메서드를 호출할 때는 아래와 같이 타입 변수에 타입을 대입해야 한다.

FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
FruitBox<Apple> appleBox = new FruitBox<Apple>();
	...
System.out.println(Juice.<Fruit>makeJuice(fruitBox));
System.out.println(Juice.<Apple>makeJuice(appleBox));

그러나 대부분의 경우 컴파일러가 타입을 추정할 수 있기 때문에 생략해도 된다.
위 코드에서도 fruitBox와 appleBox의 선언부를 통해 대입된 타입을 컴파일러가 추정할 수 있다.

System.out.println(Juice.<Fruit>makeJuice(fruitBox)); // 대입된 타입을 생략할 수 있다.
System.out.println(Juice.<Apple>makeJuice(appleBox));

주의할 점은 지네릭 메서드를 호출할 때,
대입된 타입을 생략할 수 없는 경우에는 참조변수나 클래스 이름을 생략할 수 있다는 점이다.

System.out.println(<Fruit>makeJuice(fruitBox));	// 에러. 클래스 이름 생략불가
System.out.println(this.<Fruit>makeJuice(fruitBox));	// Ok
System.out.println(Juicer.<Fruit>makeJuice(fruitBox));	// Ok

같은 클래스 내에 있는 멤버들끼리 참조변수나 클래스이름,
즉 'this'나 '클래스 이름'을 생략하고 메서드 이름만으로 호출이 가능하지만,
대입된 타입이 있을 때는 반드시 써줘야 한다.
이것은 단지 기술적인 이유에 의한 규칙이므로 그냥 지키기만 하면 된다.

지네릭 메서드는 매개변수의 타입이 복잡할 때도 유용하다.
만일 아래와 같은 코드가 있다면 타입을 별도로 선언함으로써 코드를 간략히 할 수 있다.

public static void printAll(ArrayList<? extends Product> list,
			ArrayList<? extends Product> list2) {
	for(Unit u : list) {
		System.outprintln(u);
	}
}

==>

public static <T extends Product> void printAll(ArrayList<T> list,
						ArrayList<T> list2) {
	for(Unit u : list) {
		System.outprintln(u);
	}
}

아래의 메서드는 Collections클래스의 sort()인데,
조금 전에 소개한 sort()와 달리 매개변수가 하나짜리다.

public static<T extends Comparable<? super T>> void sort(List<T> list)

매개변수로 지정한 List를 정렬한다는 것은 알겠지만,
메서드에 선언된 지네릭 타입이 조금 복잡한데 이럴 때는 와일드 카드를 걷어보면 된다.

public static<T extends Comparable<T>> void sort(List<T> list)

위 코드를 보면 알 수 있다시피 List의 요소가 Comparable인터페이스를 구현한 것이어야 한다.
앞에서 살펴본 것처럼 인터페이스라고 해서 'implements'라고 쓰지 않는다.

이제 다시 와일드 카드를 넣어보자

public static <T extends Comparable<? super T>> void sort(List<T> list)

1 : List
2 : <T extends Comparable<? super T>>

1. 타입 T를 요소로 하는 List를 매개변수로 허용한다.
2. 'T'는 Comparable을 구현한 클래스이어야 하며 ().
   'T'또는 그 조상의 타입을 비교하는 Comparable이어야 한다는 것 (Comparable<? super T>)을 의미한다.
   만일 T가 Student이고, Person의 자손이라면, <? super T>는 Student, Person, Object가 모두 가능하다.

Box		box = null;
Box<Object> object = null;

box = (Box)objBox; // Ok. 지네릭 타입 -> 원시 타입. 경고 발생
ObjBox = (Box<Object>box;) // Ok. 원시 타입 -> 지네릭 타입 경고 발생

Box<Object> objBox = null;
Box<String> strBox = null;

objBox = (Box<Object>)strBox; // 에러 발생 Box<String> -> Box<Object>
strBox = (Box<Object>objBox; // 에러 발생 Box<Object> -> Box<String>

// Box<O:bject objBox = (Box<Object>)new Box<String>();
Box<Object> objBox = new Box<String>(); // 에러 발생 형변환 불가능

Box<? extends Object> wBox = new Box<String>)();

static Juice makeJuice(FruitBox<? extends Fruit> box) {...}

FruitBox<? extends Fruit> box = new FruitBox<Fruit>(); // OK
FruitBox<? extends Fruit> box = new FruitBox<Apple>(); // OK
FruitBox<? extends Fruit> box = new FruitBox<Grape>(); // OK

FruitBox<? extends Fruit>box = null; // Ok. 미확인 타입으로 형변환 경고
FruitBox<Apple> appleBox = (FruitBox<Apple>)box;

class Box<T extends Fruit) {
	void add(T t) {
		...
	}
}

class Box {
	void add(Fruit t) {
		....
	}
}

T get(int i) {
	return list.get(i);
}

Fruit get(int i) {
	return (Fruit)list.get(i);
}