타입 소거와 런타임 한계

자바 제네릭은 주로 컴파일 시점에 타입 안전성을 검사합니다.

타입 매개변수는 바이트코드에서 상한 또는 Object 관점으로 소거되고, 필요한 곳에 컴파일러가 캐스팅을 삽입합니다.

그래서 같은 제네릭 클래스 한 벌로 여러 타입을 사용할 수 있지만 런타임에 T 자체를 검사하거나 생성하는 데는 제한이 있습니다.

타입 소거와 생성 제한

이 예제는 Object로 받은 값을 T인지 검사하거나 T의 생성자를 직접 호출하려 하지만, T만으로는 그 런타임 정보를 얻을 수 없습니다.

T.class와 new T[]도 런타임 타입 정보가 필요한 연산이어서 제한됩니다. 별도로, 클래스의 타입 매개변수 T는 정적 문맥에서 참조할 수 없으므로 static T 필드를 선언할 수 없습니다.

public final class ErasedTypeOperationFailure<T> {
    public boolean matches(Object value) {
        return value instanceof T;
    }

    public T create() {
        return new T();
    }
}

error: Object cannot be safely cast to T
error: unexpected type
required: class
found: type parameter T

이 검사를 단순히 instanceof Object로 바꾸면 null이 아닌 모든 참조에 참이므로, 호출자가 의도한 타입 인자를 판별하지 못합니다.

컴파일러는 의미가 사라지는 연산을 허용하지 않습니다.

소거 후의 런타임 구조

Box<String>과 Box<Integer>는 서로 다른 소스 타입이지만 런타임 클래스 객체는 같습니다.

get 결과를 구체 타입으로 받는 지점에는 컴파일러가 안전하다고 검증한 캐스팅을 넣습니다.

public final class ErasureRuntimeObservation {
    public static void main(String[] args) {
        Box<String> titles = new Box<>("제네릭 질문");
        Box<Integer> viewCounts = new Box<>(13);

        System.out.println("same-class=" + (titles.getClass() == viewCounts.getClass()));
        String title = titles.get();
        Integer viewCount = viewCounts.get();
        System.out.println(title + "=" + viewCount);
    }

    private record Box<T>(T value) {
        T get() { return value; }
    }
}

same-class=true
제네릭 질문=13

제한 없는 T는 기본적으로 Object로 치환됩니다.

<T extends Animal>은 Animal 상한으로 치환되므로 구현은 Animal 메서드를 호출할 수 있습니다.

반환 지점에서 Dog가 필요하면 호출 코드에 Dog 캐스팅이 삽입됩니다.

정상적인 제네릭 사용에서는 컴파일러가 입력까지 검사했기 때문에 이 캐스팅이 안전합니다.

리플렉션 API가 필드·메서드 선언에 남은 generic signature 메타데이터를 일부 보여 주기도 하지만, 객체 하나가 Box<String>인지 Box<Integer>인지 완전히 재구성하는 실행 타입 표지는 아닙니다.

런타임 검증을 그 메타데이터에 막연히 의존하지 않습니다.

비매개변수화 타입과 힙 오염

소거가 안전하지 않은 것이 아니라 비매개변수화 타입과 unchecked 연산이 컴파일 검사를 우회하는 것이 문제입니다.

Box<String> 객체에 raw 참조로 Integer를 넣으면 힙의 실제 값과 정적 타입 약속이 달라집니다.

public final class RawGenericHeapPollutionFailure {
    public static void main(String[] args) {
        Box<String> strings = new Box<>();
        strings.set("safe");

        Box raw = strings;
        raw.set(13);

        String title = strings.get();
        System.out.println(title);
    }

    private static final class Box<T> {
        private T value;
        void set(T value) { this.value = value; }
        T get() { return value; }
    }
}

java.lang.ClassCastException:
class java.lang.Integer cannot be cast to class java.lang.String

실패는 컴파일러가 get 뒤 삽입한 String 캐스팅에서 나타납니다.

근본 원인은 raw 타입을 통한 set 호출입니다.

-Xlint:unchecked 경고를 실패로 취급하면 이런 경계를 일찍 발견할 수 있습니다.

외부 레거시 API가 raw 값을 돌려주면 한 어댑터에서 원소를 검사해 새 타입 안전 컬렉션으로 복사합니다.

런타임 타입 정보의 전달

T의 클래스 검사나 객체 생성을 해야 한다면 Class<T>, Supplier<T>, 전용 팩터리를 생성자 인수로 받습니다.

소거된 정보를 마법처럼 복원하는 것이 아니라 호출자가 알고 있는 런타임 전략을 명시적으로 전달합니다.

import java.util.function.Supplier;

public final class ClassTokenAndFactory {
    public static void main(String[] args) {
        TypedFactory<Post> factory = new TypedFactory<>(
                Post.class,
                () -> new Post("untitled", 1));

        System.out.println("matches=" + factory.matches(new Post("java", 40)));
        System.out.println("created=" + factory.create());
    }

    private record TypedFactory<T>(Class<T> type, Supplier<T> supplier) {
        boolean matches(Object value) { return type.isInstance(value); }
        T cast(Object value) { return type.cast(value); }
        T create() { return supplier.get(); }
    }

    private record Post(String title, int viewCount) { }
}

matches=true
created=Post[title=untitled, viewCount=1]

Class 토큰은 검사와 캐스팅, Supplier는 생성 방법을 담당합니다.

원래 main은 matches와 create만 호출하며 선언된 cast 메서드를 호출하지 않습니다. 별도 복사본의 main에 factory.matches(null), factory.cast(null) == null을 출력해 보면 각각 false와 true입니다. null이 없다는 업무 검증과 Class의 캐스팅 가능성은 같은 질문이 아닙니다.

같은 복사본에서 factory.matches("text")는 false이며 factory.cast("text")를 실제로 호출하면 ClassCastException입니다. Class.isInstance와 cast는 검사와 실패 방식을 각각 정의합니다. 타입 토큰 하나가 제목 길이나 조회 수 같은 Post의 업무 조건을 검사해 주는 것도 아닙니다.

기본 생성자를 리플렉션으로 강제하지 않으므로 검증된 생성자·팩터리도 전달할 수 있습니다.

중첩 제네릭 타입 전체가 필요하면 단순 Class 하나로 부족하므로 JSON 라이브러리의 TypeToken 같은 별도 타입 표현이 필요할 수 있습니다.

배열과 가변 인자의 소거 경계

배열은 런타임에 원소 타입을 검사하지만 제네릭은 소거됩니다.

그래서 new T[10]을 직접 만들 수 없고 List<String>[] 같은 제네릭 배열 생성도 금지됩니다.

두 모델을 섞으면 런타임 배열 검사와 컴파일 제네릭 검사가 서로 다른 정보를 가지게 됩니다.

제네릭 varargs는 내부적으로 배열을 만들기 때문에 힙 오염 위험이 있습니다.

메서드가 배열을 외부에 노출하거나 원소를 바꾸지 않고 안전하다는 것을 구현자가 증명한 경우에만 @SafeVarargs를 사용합니다.

경고를 숨기는 용도로 붙이지 않습니다.

가능하면 List<T>를 인수로 받는 API가 더 명확합니다.

오버로딩도 소거 뒤 시그니처가 같아질 수 있습니다.

process(List<String>)와 process(List<Integer>)는 둘 다 런타임에 process(List)가 되어 함께 선언할 수 없습니다.

메서드 이름을 역할별로 바꾸거나 하나의 제네릭 메서드로 관계를 표현합니다.

제네릭 설계 선택 기준

• 컴파일 단계의 입력·반환 관계가 목적: 타입 매개변수
• 실행 중 타입 검사: Class 토큰 또는 명시 식별자
• 실행 중 생성 전략: Supplier나 팩터리
• 읽기/쓰기 범위 확장: 와일드카드와 PECS
• raw 경계: 한곳에서 검증·복사하고 unchecked 범위 최소화
• 타입별 행동이 본질적으로 다름: 다형성·전략·도메인 타입

제네릭은 타입 관계가 분명할수록 강력합니다.

<A,B,C,D>가 서로 어떻게 연결되는지 설명하기 어렵다면 더 작은 객체나 이름 있는 중간 타입으로 나눕니다.

캐스팅을 숨기기 위해 unchecked helper를 만들기보다 공개 계약이 실제로 보장할 수 있는지 먼저 검토합니다.

연습 문제

체력이 큰 같은 유닛 타입을 반환하는 제네릭 메서드, BioUnit 하위 한 종류를 싣는 Shuttle, 어떤 Shuttle이든 출력하는 와일드카드 메서드를 작성하세요.

BioUnit은 name()·hp()를 제공하며 Marine은 name·hp·squad를 갖습니다. maxHp는 null이 아닌 두 유닛을 비교하고, 체력이 같으면 left를 반환합니다. Shuttle<T extends BioUnit>의 in(T)는 한 값을 보관하고 out()은 그 T를 반환합니다. 출력 전에 in을 호출해 비어 있지 않게 하며, 이번에는 교체 여부 외의 적재 용량 정책을 만들지 않습니다.

Marine M1/40/1과 M2/55/2로 비교한 값을 Shuttle<Marine>에 넣습니다. printUnit은 이름:체력을 출력하고 main은 원래 Marine 참조로 squad=번호를 출력합니다. 독립 조건에서 둘째 유닛의 체력만 40으로 바꾸면 두 출력 줄을 어떻게 예상하나요?

public final class GenericUnitToolkitExercise {
    public static void main(String[] args) {
        Marine first = new Marine("M1", 40, 1);
        Marine second = new Marine("M2", 55, 2);
        Marine stronger = maxHp(first, second);

        Shuttle<Marine> shuttle = new Shuttle<>();
        shuttle.in(stronger);
        printUnit(shuttle);
        System.out.println("squad=" + stronger.squad());
    }

    private static <T extends BioUnit> T maxHp(T left, T right) {
        return left.hp() >= right.hp() ? left : right;
    }

    private static void printUnit(Shuttle<? extends BioUnit> shuttle) {
        BioUnit unit = shuttle.out();
        System.out.println(unit.name() + ":" + unit.hp());
    }

    private static final class Shuttle<T extends BioUnit> {
        private T unit;
        void in(T unit) { this.unit = unit; }
        T out() { return unit; }
    }

    private interface BioUnit { String name(); int hp(); }
    private record Marine(String name, int hp, int squad) implements BioUnit { }
}

M2:55
squad=2