와일드 카드
1. 와일드 카드란?
- Juicer라는 클래스가 존재하고 static 메서드로 makeJuice()가 있다고 가정해보자.
class Juicer{
static Juice makeJuice(FruitBox<Fruit> box) { // <Fruit>으로 지정
String tmp = "";
for(Fruit f : box.getList()) tmp += f + " ";
return new Juice(tmp);
}
}
( Juice 클래스는 지네릭 클래스가 아닌데다, 지네릭 클래스라고 해도 static 메서드에는 타입 매개변수 T를 매개변수에
사용할 수 없으므로 아예 지네릭스를 적용하지 않던가, 위와 같이 같이 <Fruit>로 지정해줘야 한다. )
( 그래서 아래와 같이 fruitBox는 컴파일이 잘 되지만, appleBox에 대해서는 컴파일 에러가 발생한다. )
FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
FruitBox<Apple> appleBox = new FruitBox<Apple>();
Juicer.makeJuice(fruitBox);
// 컴파일 정상
Juicer.makeJuice(appleBox);
// 컴파일 에러
( 그렇게 되면, 우리는 또 아래의 코드처럼 static 메서드를 생성해야 한다. )
class Juicer{
static Juice makeJuice(FruitBox<Fruit> box) { // <Fruit>으로 지정
String tmp = "";
for(Fruit f : box.getList()) tmp += f + " ";
return new Juice(tmp);
}
static Juice makeJuice(FruitBox<Apple> box) { // <Fruit>으로 지정
String tmp = "";
for(Fruit f : box.getList()) tmp += f + " ";
return new Juice(tmp);
}
}
( 그러나, 위와같이 오버로딩하면, 컴파일 에러가 발생한다. )
( 지네릭 타입이 다른 것만으로 오버로딩이 성립하지 않기 때문이다. )
( 그 이유는 지네릭 타입은 컴파일러가 컴파일할 때만 사용하고 제거하므로, 메서드 중복 정의로 간주되기 때문이다. )
( 이럴 때 사용하기 위해 고안된 것이 바로 '와일드 카드' 이다. )
( 와일드 카드는 기호 "?"로 표현하는데, 어떠한 타입도 될 수 있다. )
( "?" 만으로는 Object 타입과 다를 게 없으므로, 'extends'와 'super'로 상한과 하한을 제한할 수 있다. )
| "?" 표현방식 | 설명 |
| <? extends T> | 와일드 카드의 상한 제한. T와 그 자손들만 가능. |
| <? super T> | 와일드 카드의 하한 제한. T와 그 조상들만 가능. |
| <?> | 제한 없음. 모든 타입이 가능. <? extends Object> 와 동일함. |
( 그러므로, 와일드 카드를 사용하면 아래의 코드가 나오게 된다. )
class Juicer{
static Juice makeJuice(FruitBox<? extends Fruit> box) { // <Fruit>으로 지정
String tmp = "";
for(Fruit f : box.getList()) tmp += f + " ";
return new Juice(tmp);
}
}
( 또한 아래의 코드처럼 <? extends Object>를 수행할 수 있다. )
class Juicer{
static Juice makeJuice(FruitBox<? extends Object> box) { // <Fruit>으로 지정
String tmp = "";
for(Fruit f : box.getList()) tmp += f + " ";
return new Juice(tmp);
}
}
( 그러나 이렇게 되면 for문 안에 있는 Fruit가 에러일 수 있다. )
( 그 이유는 FruitBox의 모든 객체가 사용할 수 있기 때문이다. )
( 그러나, 실제로 컴파일을 해보면 에러가 발생하지 않는다. )
( 왜냐하면 FruitBox에서 이미 클래스에 <T extends Fruit>을 썻기 때문이다. )
( 그러므로, 이미 Fruit의 자손만 가능하므로 컴파일 에러가 발생하지 않는 것이다. )
1-1. 와일드 카드를 이해하기 위한 예제(1)
: 위에서 했던 코드들을 합친 예제이다.
import java.util.ArrayList;
public class Exercise003 {
public static void main(String[] args){
Fruit3Box3<Fruit3> Fruit3Box3 = new Fruit3Box3<Fruit3>();
Fruit3Box3<Apple3> Apple3Box3 = new Fruit3Box3<Apple3>();
Fruit3Box3.add(new Apple3());
Fruit3Box3.add(new Grape3());
Apple3Box3.add(new Apple3());
Apple3Box3.add(new Apple3());
System.out.println(Juicer.makeJuice(Fruit3Box3));
System.out.println(Juicer.makeJuice(Apple3Box3));
}
}
class Fruit3 { public String toString() { return "Fruit3";}}
class Apple3 extends Fruit3 { public String toString() { return "Apple3";}}
class Grape3 extends Fruit3 { public String toString() { return "Grape3";}}
class Juice {
String name;
Juice(String name) { this.name = name + "Juice"; }
public String toString() { return name; }
}
class Juicer {
static Juice makeJuice(Fruit3Box3<? extends Fruit3> Box3) {
String tmp = "";
for(Fruit3 f : Box3.getList())
tmp += f + " ";
return new Juice(tmp);
}
}
class Fruit3Box3<T extends Fruit3> extends Box3<T> {}
class Box3<T> {
//class Fruit3Box3<T extends Fruit3> {
ArrayList<T> list = new ArrayList<T>();
void add(T item) { list.add(item); }
T get(int i) { return list.get(i); }
ArrayList<T> getList() { return list; }
int size() { return list.size(); }
public String toString() { return list.toString();}
}
1-2. 와일드 카드를 이해하기 위한 예제(2)
: 'super'로 와일드 카드의 하한을 사용하여 제한하는 예제이다.
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Exercise004 {
public static void main(String[] args){
Fruit4Box4<Apple4> Apple4Box4 = new Fruit4Box4<Apple4>();
Fruit4Box4<Grape4> Grape4Box4 = new Fruit4Box4<Grape4>();
Apple4Box4.add(new Apple4("GreenApple4", 300));
Apple4Box4.add(new Apple4("GreenApple4", 100));
Apple4Box4.add(new Apple4("GreenApple4", 200));
Grape4Box4.add(new Grape4("GreenGrape4", 400));
Grape4Box4.add(new Grape4("GreenGrape4", 300));
Grape4Box4.add(new Grape4("GreenGrape4", 200));
Collections.sort(Apple4Box4.getList(), new Apple4Comp());
Collections.sort(Grape4Box4.getList(), new Grape4Comp());
System.out.println(Apple4Box4);
System.out.println(Grape4Box4);
System.out.println();
Collections.sort(Apple4Box4.getList(), new Fruit4Comp());
Collections.sort(Grape4Box4.getList(), new Fruit4Comp());
System.out.println(Apple4Box4);
System.out.println(Grape4Box4);
}
}
class Fruit4 {
String name;
int weight;
Fruit4(String name, int weight) {
this.name = name;
this.weight = weight;
}
public String toString() { return name+"("+weight+")";}
}
class Apple4 extends Fruit4 {
Apple4(String name, int weight) {
super(name, weight);
}
}
class Grape4 extends Fruit4 {
Grape4(String name, int weight) {
super(name, weight);
}
}
class Apple4Comp implements Comparator<Apple4> {
public int compare(Apple4 t1, Apple4 t2) {
return t2.weight - t1.weight;
}
}
class Grape4Comp implements Comparator<Grape4> {
public int compare(Grape4 t1, Grape4 t2) {
return t2.weight - t1.weight;
}
}
class Fruit4Comp implements Comparator<Fruit4> {
public int compare(Fruit4 t1, Fruit4 t2) {
return t1.weight - t2.weight;
}
}
class Fruit4Box4<T extends Fruit4> extends Box4<T> {}
class Box4<T> {
ArrayList<T> list = new ArrayList<T>();
void add(T item) {
list.add(item);
}
T get(int i) {
return list.get(i);
}
ArrayList<T> getList() { return list; }
int size() {
return list.size();
}
public String toString() {
return list.toString();
}
}
( Collections.sort()를 사용하여 정렬하였는데, 이 메서드의 선언부는 아래와 같다. )
static <T> void sort(List<T> list, Comparator<? super T> c)
( 위와 같이 정의된 <T> 메서드를 '지네릭 메서드' 라고 부른다. )
( 위의 코드에서 'super'로 정의한 이유는 코드 중복에 대한 문제를 방지하기 위해서이다. )
( 만약 우리가 sort()에 super라는 것이 없었더라면, 위 예제에서처럼 Fruit에 대한 자손들인 Apple과 Grape를
정렬하기 위해서는 각각의 AppleComp과 GrapeComp를 만들어 정렬하였을 것이다. )
( 그러나, 이런식으로 Fruit의 자손이 생길때마다 Comp에 대한 코드를 계속 추가해야하는 문제가 발생하게 된다. )
( 그러나, Comparator<? super T>를 정의하였기 때문에, 손쉽게 FruitComp만 정의해주면 굳이 추가적으로
각각의 Comp를 만들어줄 필요가 없는 것이다. )
( 아래의 예시를 보고 이해하자. )
< Collections.sort()의 호출 >
sort(appleBox.getList(), new FruitComp());
< 실제 sort() 메서드 >
static <Apple> void sort(List<Apple> list, Comparator<? super Apple> c);| Comparator<? super T> | 올 수 있는 Comparator<> |
| Comparator<? super Apple> | Comparator<Apple>, Comparator<Fruit>, Comparator<Object> |
| Comparaotr<? super Grape> | Comparator<Grape>, Comparator<Fruit>, Comparator<Object> |