Java 제네릭 — 타입 소거, 와일드카드, PECS

List list = new ArrayList();
list.add("hello");
list.add(123); // 컴파일 에러 안 남
String s = (String) list.get(1); // 런타임에 ClassCastException

List<String> list = new ArrayList<>();
list.add("hello");
// list.add(123); // 컴파일 에러!
String s = list.get(0); // 캐스팅 불필요

public class Box<T> {
    private T item;

    public void set(T item) { this.item = item; }
    public T get() { return item; }
}

Box<String> box = new Box<>();
box.set("apple");
String fruit = box.get();

public class Util {
    public static <T> T getFirst(List<T> list) {
        return list.get(0);
    }
}

String first = Util.getFirst(List.of("a", "b", "c")); // 타입 추론

public interface Repository<T, ID> {
    T findById(ID id);
    void save(T entity);
}

public class UserRepository implements Repository<User, Long> {
    @Override
    public User findById(Long id) { /* ... */ }

    @Override
    public void save(User entity) { /* ... */ }
}

public <T extends Number> double sum(List<T> list) {
    return list.stream().mapToDouble(Number::doubleValue).sum();
}

public <T extends Comparable<T> & Serializable> T max(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;
}

// 소스 코드
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0);

// 바이트코드 (개념적)
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); // 컴파일러가 캐스팅 삽입

public class Factory<T> {
    public T create() {
        // return new T(); // 컴파일 에러! 타입 정보가 없어서 인스턴스 생성 불가
    }
}

public class Factory<T> {
    private final Class<T> type;

    public Factory(Class<T> type) { this.type = type; }

    public T create() throws Exception {
        return type.getDeclaredConstructor().newInstance();
    }
}

public <T> boolean isTypeOf(Object obj) {
    // return obj instanceof T; // 컴파일 에러
}

// T[] arr = new T[10]; // 컴파일 에러

// 이것도 안 됨
// List<String>[] arr = new List<String>[10]; // 컴파일 에러

// 컴파일 에러 — 소거 후 둘 다 process(List)가 됨
public void process(List<String> list) { }
public void process(List<Integer> list) { }

public void printAll(List<?> list) {
    for (Object item : list) {
        System.out.println(item);
    }
}

public double sum(List<? extends Number> list) {
    double total = 0;
    for (Number n : list) {
        total += n.doubleValue();
    }
    return total;
}

sum(List.of(1, 2, 3));       // List<Integer> OK
sum(List.of(1.1, 2.2, 3.3)); // List<Double> OK

public void addNumbers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
    list.add(3);
}

List<Number> numbers = new ArrayList<>();
addNumbers(numbers); // OK — Number는 Integer의 상위 타입

List<Object> objects = new ArrayList<>();
addNumbers(objects); // OK — Object도 Integer의 상위 타입

public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    for (int i = 0; i < src.size(); i++) {
        dest.set(i, src.get(i));
    }
}

List<Integer> ints = List.of(1, 2, 3);
List<Number> nums = new ArrayList<>(List.of(0.0, 0.0, 0.0));

Collections.copy(nums, ints); // Integer → Number로 복사

public class StringList extends ArrayList<String> { }

Type superclass = StringList.class.getGenericSuperclass();
if (superclass instanceof ParameterizedType) {
    ParameterizedType pt = (ParameterizedType) superclass;
    Type[] typeArgs = pt.getActualTypeArguments();
    System.out.println(typeArgs[0]); // class java.lang.String
}

Type type = new TypeToken<List<String>>() {}.getType();
List<String> list = gson.fromJson(json, type);

ResponseEntity<List<User>> response = restTemplate.exchange(
    "/api/users",
    HttpMethod.GET,
    null,
    new ParameterizedTypeReference<List<User>>() {}
);

public abstract class BaseRepository<T, ID> {
    private final Class<T> entityType;

    @SuppressWarnings("unchecked")
    protected BaseRepository() {
        ParameterizedType pt = (ParameterizedType)
            getClass().getGenericSuperclass();
        this.entityType = (Class<T>) pt.getActualTypeArguments()[0];
    }
}

// UserRepository extends BaseRepository<User, Long>
// → entityType은 자동으로 User.class

public class EventBus {
    private final Map<Class<?>, List<EventHandler<?>>> handlers
        = new HashMap<>();

    public <T extends Event> void register(
            Class<T> eventType, EventHandler<T> handler) {
        handlers.computeIfAbsent(eventType, k -> new ArrayList<>())
                .add(handler);
    }
}

public class StringBox implements Box<String> {
    @Override
    public String get() { return "hello"; }
}

// 컴파일러가 생성하는 브릿지 메서드
public Object get() {
    return get(); // String get()을 호출
}

public enum JsonParser implements Parser<JsonNode> {
    INSTANCE;

    @Override
    public JsonNode parse(String input) { /* ... */ }
}

public static <T extends Comparable<T>> T max(Collection<T> c) {
    Iterator<T> it = c.iterator();
    T result = it.next();
    while (it.hasNext()) {
        T t = it.next();
        if (t.compareTo(result) > 0) result = t;
    }
    return result;
}