자바(Java)는 대표적인 정적 타입 언어로, 컴파일 타임에 데이터 타입을 엄격하게 검사하여 안정적인 프로그램 실행을 보장한다. 하지만 다양한 타입의 데이터를 처리하는 코드를 작성하다 보면, 하나의 클래스나 메서드를 여러 타입에 맞게 재사용해야 할 상황이 빈번하게 발생한다. 이럴 때 코드의 재사용성은 높이면서도 타입 안전성을 유지할 수 있는 기능이 필요하다. 바로 이 문제를 해결하기 위해 도입된 것이 제네릭(Generic)이다.
제네릭은 자바 5부터 도입된 기능으로, 클래스나 메서드에서 사용할 데이터 타입을 파라미터화할 수 있게 해 준다. 이를 통해 하나의 코드 구조를 여러 타입에 대해 유연하게 활용할 수 있고, 컴파일 타임에 잘못된 타입 사용을 미리 차단할 수 있다. 덕분에 자바 개발자는 보다 안전하고 효율적인 코드를 작성할 수 있게 되었다.
그러나 제네릭은 단순히 문법을 익히는 것으로 끝나지 않는다. 타입 소거(Type Erasure)라는 개념을 기반으로 동작하기 때문에, 런타임에서는 제네릭 타입 정보가 사라진다는 점을 이해해야 하며, 이로 인해 발생하는 객체 생성 불가, 배열 생성 불가, instanceof 사용 불가 등의 제약도 함께 고려해야 한다. 실무에서는 제네릭을 잘못 사용하여 발생하는 문제들이 의외로 많고, 그로 인한 유지보수 비용도 적지 않다.
또한, 제네릭을 실질적으로 잘 활용하기 위해서는 단순한 클래스나 메서드 선언을 넘어, 타입 제한(Bounded Types), 와일드카드(?, ? extends, ? super), 그리고 PECS 원칙(Producer Extends, Consumer Super)과 같은 고급 개념까지 정확히 이해해야 한다. 이러한 개념들은 단순히 문법적 지식을 넘어, 설계 의도와 데이터 흐름을 어떻게 표현할지에 대한 중요한 도구가 된다.
제네릭(Generic)이란 무엇인가?
제네릭은 클래스, 인터페이스, 메서드를 선언할 때 타입 정보를 고정하지 않고, 나중에 실제 사용 시점에 지정할 수 있도록 만들어주는 기능이다. 즉, 타입을 코드 작성 시점에 결정하는 것이 아니라, 인스턴스를 생성하거나 메서드를 호출하는 시점에 명시적으로 지정할 수 있다는 뜻이다.
다음은 제네릭을 사용하지 않은 클래스 예시이다.
public class ObjectBox {
private Object value;
public void set(Object value) {
this.value = value;
}
public Object get() {
return value;
}
}
이 클래스는 다양한 타입을 저장할 수는 있지만, 데이터를 꺼낼 때는 형 변환(casting)이 필요하다.
ObjectBox box = new ObjectBox();
box.set("Hello");
String str = (String) box.get(); // 형변환 필요
위와 같이 형변환을 잘못하면 ClassCastException이 발생할 수 있고, 이는 런타임에서야 알 수 있는 오류이다.
제네릭을 사용하면 다음과 같이 코드의 안전성과 가독성이 향상된다.
public class Box<T> {
private T value;
public void set(T value) {
this.value = value;
}
public T get() {
return value;
}
}
이제 Box<String>처럼 명시적으로 타입을 지정하면, 컴파일러가 모든 타입 검사를 대신해주기 때문에 개발자는 안심하고 사용할 수 있다.
Box<String> stringBox = new Box<>();
stringBox.set("Hello");
String str = stringBox.get(); // 형변환 불필요
제네릭을 사용하는 이유
제네릭은 단지 코드 재사용성을 높이기 위한 문법이 아니다. 제네릭이 존재하는 가장 중요한 이유는 컴파일 타임에 타입 안정성(type safety)을 확보하기 위함이다. 개발자가 잘못된 타입을 다루는 실수를 했을 때, 컴파일러가 이를 미리 감지해주는 것이 핵심이다.
또한 제네릭은 자바에서 널리 사용되는 컬렉션 클래스(List, Set, Map 등)을 보다 안전하고 효율적으로 사용할 수 있게 해 준다. 예전에는 모든 데이터를 Object 타입으로 저장해야 했기 때문에, 항상 형 변환을 수반했고, 이로 인해 많은 오류가 발생했다.
제네릭을 사용함으로써 다음과 같은 이점을 얻을 수 있다:
- 컴파일 타임 타입 검사로 안정성 확보
- 불필요한 캐스팅 제거로 코드 간결화
- 다양한 타입을 수용하는 코드 재사용성 향상
- 라이브러리 사용자에게 명확한 타입 인터페이스 제공
예를 들어, 문자열 리스트를 만들 때 다음과 같이 선언하면,
List<String> list = new ArrayList<>();
list.add("Java");
String s = list.get(0); // 캐스팅 없이 바로 사용 가능
컴파일러는 list가 String 타입만 저장할 수 있도록 제한하고, 개발자가 list.add(123) 같은 실수를 했을 경우 컴파일 단계에서 바로 오류를 발생시킨다.
타입 소거(Type Erasure)
자바의 제네릭은 컴파일 타임 전용 문법이다. 즉, 런타임에는 제네릭 타입 정보가 모두 제거된다. 이를 타입 소거(Type Erasure)라고 부른다.
이 개념을 이해하면 다음과 같은 사실을 받아들일 수 있다:
List<String> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
System.out.println(list1.getClass() == list2.getClass()); // true
이 코드는 true를 출력한다. List<String>과 List<Integer>는 컴파일 타임에는 서로 다른 타입처럼 보이지만, 바이트코드로 컴파일된 후에는 동일한 ArrayList 클래스로 처리된다. 즉, 제네릭은 런타임 시점에는 존재하지 않는다.
이로 인해 다음과 같은 제약이 생긴다:
- 제네릭 타입으로 객체를 생성할 수 없다 (new T() 불가)
- 제네릭 타입의 배열 생성이 불가능하다 (new T[10] 불가)
- instanceof 연산자를 사용할 수 없다 (obj instanceof T 불가)
타입 소거는 자바가 하위 호환성을 유지하기 위해 채택한 전략이다. 과거에 작성된 제네릭이 없는 코드와도 함께 동작할 수 있어야 했기 때문이다.
제네릭 클래스 및 메서드 선언
제네릭은 클래스뿐 아니라 메서드에도 적용할 수 있다. 제네릭 클래스는 타입 매개변수를 클래스 선언부에 포함시키고, 제네릭 메서드는 메서드 선언 앞에 <T>를 붙여 사용한다.
제네릭 클래스 예시
public class Container<T> {
private T data;
public void set(T data) {
this.data = data;
}
public T get() {
return data;
}
}
사용 시점에 타입을 지정할 수 있다:
Container<String> stringContainer = new Container<>();
stringContainer.set("Generic");
Container<Integer> intContainer = new Container<>();
intContainer.set(42);
제네릭 메서드 예시
public class Utility {
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.println(element);
}
}
}
메서드 내부에서 타입에 독립적인 처리가 가능해진다:
String[] strArray = { "Java", "Kotlin" };
Integer[] intArray = { 1, 2, 3 };
Utility.printArray(strArray);
Utility.printArray(intArray);
다중 타입 매개변수 선언
자바 제네릭은 두 개 이상의 타입 매개변수를 동시에 사용할 수 있다. 일반적으로 Map<K, V>와 같이 키-값 구조를 다룰 때 자주 사용된다.
public class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
}
사용 예시:
Pair<String, Integer> pair = new Pair<>("Age", 30);
System.out.println(pair.getKey() + " = " + pair.getValue());
다중 제네릭 매개변수는 각각의 타입을 독립적으로 다룰 수 있게 해주며, API 설계 시 매우 유용하다.
extends를 이용한 타입 제한
제네릭 타입 매개변수는 기본적으로 모든 클래스 타입을 수용하지만, 때로는 특정 타입 계층 내에서만 제한적으로 사용해야 할 필요가 있다. 이를 가능하게 하는 것이 상한 제한(Bounded Type Parameters)이며, 자바에서는 extends 키워드를 사용한다.
public class Calculator<T extends Number> {
public double add(T a, T b) {
return a.doubleValue() + b.doubleValue();
}
}
위 코드는 T가 Number 클래스를 상속받은 클래스만 허용하도록 제한한다. 덕분에 Integer, Double, Float 등의 객체를 사용할 수 있으며, 내부에서 doubleValue() 같은 메서드를 안전하게 호출할 수 있다.
사용 예시
Calculator<Integer> intCalc = new Calculator<>();
System.out.println(intCalc.add(10, 20));
Calculator<Double> doubleCalc = new Calculator<>();
System.out.println(doubleCalc.add(3.14, 2.71));
컴파일 오류 발생 예시
Calculator<String> strCalc = new Calculator<>(); // 컴파일 오류
이처럼 T extends SomeType 형태는 제네릭 타입이 특정 클래스 또는 인터페이스를 반드시 상속하거나 구현하도록 강제할 수 있는 방법이다. 이 방식은 타입 안정성 유지뿐 아니라, 코드 내부에서 안전하게 해당 타입의 기능을 사용할 수 있게 해 준다.
와일드카드: ?, ? extends, ? super
기본 와일드카드 ?
와일드카드 ?는 제네릭 타입을 불특정 타입으로 일반화할 수 있게 해 준다. 예를 들어, 어떤 타입의 리스트든 받아서 출력만 하고자 할 때 다음과 같이 작성한다.
public void printList(List<?> list) {
for (Object obj : list) {
System.out.println(obj);
}
}
이 메서드는 List<String>, List<Integer>, List<Object> 등 어떤 타입의 리스트든 받아서 처리할 수 있다. 단, list.add(...)는 허용되지 않는다. 왜냐하면 ?는 구체적인 타입을 알 수 없기 때문에, 타입 안전성을 보장할 수 없기 때문이다.
상한 제한 와일드카드 ? extends T
? extends T는 T 또는 그 하위 타입을 허용한다. 주로 읽기 전용(read-only) 컬렉션을 인자로 받을 때 사용한다.
public double sumList(List<? extends Number> list) {
double sum = 0;
for (Number num : list) {
sum += num.doubleValue();
}
return sum;
}
이 메서드는 List<Integer>, List<Double>, List<Float> 등 Number 하위 타입의 리스트를 받아서 합계를 계산할 수 있다. 그러나 이 리스트에 새로운 값을 추가할 수는 없다.
list.add(123); // 컴파일 오류
이유는 컴파일러가 실제 리스트의 구체적인 타입을 알 수 없기 때문에, 타입 안전성을 위협할 수 있다고 판단하기 때문이다.
하한 제한 와일드카드 ? super T
? super T는 T 또는 그 상위 타입을 허용한다. 주로 쓰기 전용(write-only) 컬렉션을 처리할 때 사용한다.
public void addIntegers(List<? super Integer> list) {
list.add(1);
list.add(2);
}
이 코드는 List<Integer>, List<Number>, List<Object>와 같이 Integer의 상위 타입을 사용하는 리스트에 안전하게 값을 추가할 수 있다. 다만, 리스트에서 값을 꺼낼 때는 Object 타입으로만 접근할 수 있다.
PECS 원칙: Producer Extends, Consumer Super
자바 제네릭의 와일드카드를 사용할 때 혼란스러운 부분을 정리해주는 명확한 가이드라인이 바로 PECS 원칙이다. 이는 Josh Bloch가 『Effective Java』에서 제안한 개념으로 다음과 같이 요약된다:
- Producer ⇒ extends
- 데이터를 제공(produce)하는 객체라면 ? extends T 사용
- Consumer ⇒ super
- 데이터를 소비(consume)하는 객체라면 ? super T 사용
예시: extends (읽기 전용)
public void printAll(List<? extends CharSequence> list) {
for (CharSequence cs : list) {
System.out.println(cs);
}
}
이 메서드는 List<String>, List<StringBuilder> 등 다양한 하위 타입을 받아서 안전하게 출력만 할 수 있다.
예시: super (쓰기 전용)
public void addNumbers(List<? super Integer> list) {
list.add(10);
list.add(20);
}
이 메서드는 Integer 값을 리스트에 안전하게 추가할 수 있으며, List<Number>나 List<Object>를 인자로 받을 수 있다.
제네릭 관련 제한 사항
자바의 제네릭은 매우 유용하지만, 다음과 같은 제한 사항이 존재한다. 이들은 모두 타입 소거라는 개념에서 비롯된다.
1. 제네릭 타입으로 객체 생성 불가
public class Factory<T> {
public T create() {
return new T(); // 컴파일 오류
}
}
우회 전략: Class 객체 사용
public class Factory<T> {
private Class<T> clazz;
public Factory(Class<T> clazz) {
this.clazz = clazz;
}
public T create() throws Exception {
return clazz.getDeclaredConstructor().newInstance();
}
}
2. 제네릭 타입으로 배열 생성 불가
T[] array = new T[10]; // 컴파일 오류
이 제한은 타입 정보가 런타임에 존재하지 않기 때문에 발생한다.
우회 전략 1: Object 배열로 생성 후 캐스팅
@SuppressWarnings("unchecked")
T[] array = (T[]) new Object[10];
우회 전략 2: Array.newInstance() 사용
T[] array = (T[]) Array.newInstance(clazz, 10);
Array.newInstance()는 리플렉션 기반으로 타입 정보를 유지할 수 있는 안전한 방법이다.
3. 제네릭 타입에 instanceof 사용 불가
if (obj instanceof T) { ... } // 컴파일 오류
우회 전략: Class 객체 사용
if (clazz.isInstance(obj)) {
T casted = clazz.cast(obj);
}
4. static 멤버에 제네릭 타입 사용 불가
public class Container<T> {
private static T value; // 컴파일 오류
}
제네릭 타입은 인스턴스 수준에서만 유효하며, static 영역에서는 사용할 수 없다.
해결 방법: static 제네릭 메서드로 분리
public static <T> void print(T data) {
System.out.println(data);
}
제네릭(Generic)은 자바(Java)라는 언어가 가지는 타입 안정성과 유연성을 동시에 충족시키기 위해 만들어진 구조적 장치다. 코드를 더욱 안전하고 견고하게 만드는 동시에, 다양한 타입에 유연하게 대응할 수 있는 설계를 가능하게 해주는 도구이기도 하다. 이번 시리즈를 통해 우리는 제네릭이 단지 <> 기호를 사용하는 문법 요소가 아니라, 자바가 지향하는 타입 시스템의 본질과 밀접하게 연결되어 있다는 사실을 확인할 수 있었다.
특히 타입 소거(Type Erasure)를 통해 제네릭의 타입 정보가 컴파일 후에는 사라진다는 점은, 제네릭이 가진 여러 제한 사항들을 설명하는 핵심 개념이다. new T()나 T[]와 같은 제네릭 타입 기반의 인스턴스 생성을 할 수 없는 이유도 바로 이 때문이다. 그리고 이러한 제약은 단점처럼 보일 수 있지만 하위 호환성과 안정성을 동시에 추구했던 자바 언어의 철학에서 비롯된 설계 결정이라는 점도 이해할 수 있었다.
이와 함께 제네릭 클래스와 메서드를 정의하고 활용하는 방법을 익혔고 두 개 이상의 타입 매개변수를 활용하여 구조적인 데이터를 효과적으로 다룰 수 있는 방식도 확인해 보았다. 또한 extends를 이용한 상한 제한, ? 와일드카드를 이용한 타입 유연성 확보, 그리고 PECS 원칙(Producer Extends, Consumer Super)을 통해 데이터 흐름에 맞는 설계를 어떻게 구현할 수 있는지를 살펴보았다.
제네릭의 설계 한계로 인해 발생하는 여러 가지 불편함, 예를 들어 instanceof T 불가, static 영역에서의 타입 매개변수 사용 제한 등 은 실무에서 자주 마주치는 문제이기도 하다. 하지만 이를 회피하거나 무시하는 것이 아니라 Class<T>를 이용한 인스턴스 생성 우회, Array.newInstance()를 통한 배열 생성, 리플렉션과의 결합 등을 통해 얼마든지 효과적으로 극복할 수 있다.
