Generics ve Type Erasure — Derleyicinin Bildiği, JVM'in Unuttuğu

1
public interface Repository<T extends Identifiable<ID>, ID> {
2

3
    T save(T entity);
4

5
    Optional<T> findById(ID id);
6

7
    List<T> findAll();
8
}
9

10
interface Identifiable<ID> {
11
    ID id();
12
}

1
public class InMemoryRepository<T extends Identifiable<ID>, ID> implements Repository<T, ID> {
2

3
    private final Map<ID, T> rows = new ConcurrentHashMap<>();
4

5
    @Override
6
    public T save(T entity) {
7
        rows.put(entity.id(), entity);     // possible only because T is bounded by Identifiable
8
        return entity;
9
    }
10

11
    @Override
12
    public Optional<T> findById(ID id) {
13
        return Optional.ofNullable(rows.get(id));
14
    }
15

16
    @Override
17
    public List<T> findAll() {
18
        return List.copyOf(rows.values());
19
    }
20
}

1
public final class Copies {
2

3
    private Copies() {}
4

5
    // Producer Extends, Consumer Super.
6
    // from: anything that PRODUCES T (List<Account>, List<SavingsAccount>…)
7
    // to:   anything that ACCEPTS T  (List<Account>, List<Object>…)
8
    public static <T> void copy(List<? extends T> from, List<? super T> to) {
9
        for (T item : from) to.add(item);
10
    }
11

12
    // Reads only: extends is enough, and the method now accepts List<Integer>, List<Long>, …
13
    public static double sum(Collection<? extends Number> numbers) {
14
        double total = 0;
15
        for (Number n : numbers) total += n.doubleValue();
16
        return total;
17
    }
18
}

1
public class JsonStore {
2

3
    private final ObjectMapper json = new ObjectMapper();
4

5
    // `new T()` or `T.class` does not compile: T is erased at runtime.
6
    // The caller hands over the Class object, which survives erasure.
7
    public <T> T read(Path file, Class<T> type) throws IOException {
8
        return json.readValue(file.toFile(), type);
9
    }
10

11
    // For generic types (List<Account>) a Class is not enough: List.class has no element type.
12
    // A TypeReference captures it in an anonymous subclass's signature.
13
    public List<Account> readAccounts(Path file) throws IOException {
14
        return json.readValue(file.toFile(), new TypeReference<List<Account>>() {});
15
    }
16
}

1
public class Main {
2

3
    public static void main(String[] args) {
4
        // Account is keyed by its IBAN; SavingsAccount extends Account with an interest rate.
5
        Repository<Account, String> accounts = new InMemoryRepository<>();
6
        accounts.save(new Account("TR330006100519786457841326", new BigDecimal("1250.40")));
7
        accounts.save(new SavingsAccount("TR320010009999901234567890", new BigDecimal("50000"),
8
                new BigDecimal("0.42")));                    // subtype is fine
9

10
        List<Object> audit = new ArrayList<>();
11
        Copies.copy(accounts.findAll(), audit);       // List<Account> -> List<Object>: PECS at work
12
        System.out.println(audit.size());             // 2
13

14
        System.out.println(Copies.sum(List.of(1, 2, 3)));      // 6.0  (List<Integer>)
15
        System.out.println(Copies.sum(List.of(1.5, 2.5)));     // 4.0  (List<Double>)
16

17
        List<String> ibans = new ArrayList<>();
18
        List<Integer> customerNos = new ArrayList<>();
19
        System.out.println(ibans.getClass() == customerNos.getClass()); // true — both are just ArrayList at runtime
20
    }
21
}