Generics

지네릭스는 다양한 타입의 객체들을 다루는 메서드나 컬렉션 클래스의 컴파일 시의 타입 체크(compile - time type check)를 해주는 기능이다. 객체의 타입을 컴파일 시에 체크하기 때문에 객체의 타입 안정성을 높이고 형변환의 번거로움이 줄어든다.

지네릭 클래스의 선언

class Box{
	Object item;

	void setItem(Object item) {this.item = item;}
	Object getItem() { return item;}
}

위와 같은 클래스가 있을 때 이를 지네릭 클래스로 변경하면 클래스 옆에 <T>를 붙여주고 ‘Ojbect’를 모두 T로 바꾸면 된다.

class Box<T>{
	T item;

	void setItem(T item) {this.item = item;}
	T getItem() { return item;}
}

무조건 T를 쓸 필요 없고, 다른 문자를 사용할 수 있다. 또한 Map처럼 타입 변수가 두개인 경우에는 Map<K, V>이런식으로 ’,’ 를 통해 구분이 가능하다.

위와 같이 지네릭 클래스를 선언하면 < >를 사용하여 타입을 지정할 수 있다.

Box<String> b = new Box<String>();
b.setItem(new Object()); // 에러 발생 : 타입을 String으로 선언했기 때문
b.setItem("ABC"); // String 타입이므로 선언이 가능하다.

위와 같이 <String>으로 선언을 하면 이는 지네릭 타입 T 대신에 String이 들어간 것과 같다.

지네릭스의 용어 및 제한

class Box<T>{}
// Box<T> : 지네릭 클래스, T Box 라고 읽음
// T : 타입변수 또는 타입 매개변수(T는 타입 문자)
// Box : 원시 타입 (raw type)

지네릭 클래스는 모든 객체에 동일하게 동작해야하는 static멤버의 타입 변수 T를 사용할 수 없다.

• T또한 static멤버의 변수로 선언한다면 서로 다른 타입의 static 변수 선언시 문제 발생

지네릭 타입의 배열 변수를 선언하는 것이 불가하다. ex) new T[10] 불가

• new연산자 때문인데 new는 컴파일 시점에 타입 T가 무엇인지 알아야한다. 하지만 Box<T>를 컴파일 하면 이때 T가 어떤 타입인지 정확히 알 수 없기 때문이다.
• 배열 대신 ArrayList를 사용해서 여러 객체를 저장할 수 있다.

지네릭 클래스의 객체 생성

아래의 예시를 보며 어떻게 사용하는지 쉽게 알 수 있다.

import java.util.ArrayList;
class Fruite { public String toString() { return "Fruit"; }}
class Apple extends Fruit { public String toString() { return "Apple"; }}
class Grape extends Fruit { public String toString() { return "Grape"; }}
class Toy { public String toString() { return "Toy"; }}

class FruitBoxEx1{
	public static void main(String[] args){
		Box<Fruit> fruitBox = new Box<Fruit>();
		Box<Apple> appleBox = new Box<Apple>();
		Box<Toy> toyBox = new Box<Toy>();
		// Box<Grape> grapeBox = new Box<Apple>(); // 에러 타입 불일치

		fruitBox.add(new Fruit());
		fruitBox.add(new Apple()); // add함수가 Fruit item인 상태이기에 가능

		appleBox.add(new Apple());
		//appleBox.add(new Toy()); // 에러  Box<Apple>에는 Apple만 담을 수 있음

	}
	class Box<T>{
		ArrayList<T> list = new ArrayList<T>();
		void add(T item) { list.add(item); }
		T get(int i) { return list.get(i); }
		int size() { return list.size(); }
		public String toString() { return list.toString(); }
	}
}

• 지네릭클래스의 객체는 <타입>을 추가해주고 new 연산자를 통해 생성할 수 있다.
• 부모를 상속하여 구현한 클래스의 부모의 경우, 다형성에서 배운 것처럼 자식도 부모에 add할 수 있다.

지네릭 클래스와 extends, 와일드카드

extends

지네릭 타입에 ‘extends’를 사용하면, 특정 타입의 자손들만 대입할 수 있게 제한할 수 있다.

class FruitBox<T extends Fruit>{ // Fruit의 자손만 타입으로 지정가능
	ArrayList<T> list = new ArrayList<T>();
}

인터페이스를 구현해야 할 때 제약이 필요할 때도 extends를 사용한다.

interface Eatable{}
class FruitBox<T extends Eatable> {...}
// 다음과 같이 & 연산자를 사용해서 여러 조건을 걸어줄 수 도 있다.
class FruitBox<T extends Fruit & Eatable> {...} //Fruit의 자손이면서 Eatable도 구현해야한다.

와일드카드

지네릭 타입이 다른 것만으로는 오버로딩이 성립하지 않는다 ex)

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

static Juice makeJuice(FruitBox<Apple> box){}

위의 두 함수는 지네릭 타입만 다르기 때문에 오버로딩이 성립하지 않아 컴파일 에러가 발생한다.

-> 따라서 이럴때 사용하기위해 고안된 것이 와일드 카드이며 ’?’로 표현한다

<? extends T> : 와일드 카드의 상한 제한. T와 그 자손들은 가능
<? super T> : 와일드 카드의 하한 제한. T와 그 조상들만 가능
<?> : 제한없이 모든 타입이 가능 <? extends Object>와 동일

sort 함수와 와일드 카드

Collections.sort()의 선언부는 다음과 같다

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

여기서 sort함수는 정렬할 방법이 정의된 Comparator가 있다. 클래스 Fruit를 상속한게 Apple, Grape라고 하면

class AppleComp implements Comparator<Apple>{
	public int compare(Apple t1, Apple t2){
		return t2.weight - t1.weight;
	}
}
class GrapeComp implements Comparator<Grape>{
	public int compare(Grape t1, Grape t2){
		return t2.weight - t1.weight;
	}
}

위의 두 함수는 완전히 같지만, Fruit의 자손이 생길 때마다 위와 같은 코드를 반복해서 만들어야하는 불편함이 있다. -> 다음과 같이 선언하면 자손이 생겨도 한번에 처리할 수 있다.

class FruitComp implements Comparator<Fruit>{
	public int compare(Fruit t1, Fruit t2){
		return t1.weight - t2.weight;
	}
}

Comparator<? super Apple>, Comparator<? super Grape>로 되어있기 때문에 결국 Comparator에(sort함수의 두번째 파라미터에)Comparator, Comparator, Comparator