Table of Contents

1. Introduction to Type Erasure
2. How Type Erasure Works
3. Type Erasure Examples
4. Bridge Methods
5. Limitations and Challenges
6. Overcoming Type Erasure
7. Reifiable vs Non-Reifiable Types
8. Best Practices

Introduction to Type Erasure

Type erasure is the process where the Java compiler removes all type parameters and replaces them with their bounds or Object if unbounded. This ensures binary compatibility with pre-generics code.

Why Type Erasure?

• Backward Compatibility: Code compiled with generics can run on older JVMs
• Runtime Efficiency: No runtime type information for generics
• Simpler JVM: No changes needed to JVM instruction set

How Type Erasure Works

Basic Erasure Process

import java.util.*; public class TypeErasureProcess { // Generic class before erasure public static class GenericClass<T> { private T value; public void setValue(T value) { this.value = value; } public T getValue() { return value; } } // After erasure, it becomes: public static class GenericClassAfterErasure { private Object value; // T becomes Object public void setValue(Object value) { this.value = value; } public Object getValue() { return value; } } // Bounded generic class before erasure public static class BoundedGenericClass<T extends Number> { private T number; public void setNumber(T number) { this.number = number; } public T getNumber() { return number; } } // After erasure, it becomes: public static class BoundedGenericClassAfterErasure { private Number number; // T extends Number becomes Number public void setNumber(Number number) { this.number = number; } public Number getNumber() { return number; } } }

Erasure in Method Signatures

public class MethodErasure { // Before erasure public static <T> T firstElement(List<T> list) { return list.get(0); } // After erasure public static Object firstElement(List list) { return list.get(0); } // Bounded method before erasure public static <T extends Comparable<T>> T max(T a, T b) { return a.compareTo(b) > 0 ? a : b; } // After erasure public static Comparable max(Comparable a, Comparable b) { return a.compareTo(b) > 0 ? a : b; } }

Type Erasure Examples

Demonstration with Reflection

import java.util.*; import java.lang.reflect.*; public class TypeErasureDemonstration { public static void demonstrateErasure() { // Create different generic instances List<String> stringList = new ArrayList<>(); List<Integer> integerList = new ArrayList<>(); List<Double> doubleList = new ArrayList<>(); // All have the same class due to erasure System.out.println("stringList class: " + stringList.getClass()); System.out.println("integerList class: " + integerList.getClass()); System.out.println("doubleList class: " + doubleList.getClass()); System.out.println("All same class? " + (stringList.getClass() == integerList.getClass() && integerList.getClass() == doubleList.getClass())); // Check generic type parameters (they're erased!) TypeVariable<?>[] typeParams = stringList.getClass().getTypeParameters(); System.out.println("Type parameters: " + Arrays.toString(typeParams)); // Field type demonstration try { Field elementDataField = ArrayList.class.getDeclaredField("elementData"); System.out.println("ArrayList elementData field type: " + elementDataField.getType()); System.out.println("It's Object[] due to erasure!"); } catch (NoSuchFieldException e) { e.printStackTrace(); } } public static void instanceOfLimitation() { List<String> stringList = new ArrayList<>(); // This works but checks raw type only System.out.println("Is List? " + (stringList instanceof List)); // This doesn't compile - can't check generic type due to erasure // System.out.println("Is List<String>? " + (stringList instanceof List<String>)); // Workaround: check elements individually stringList.add("test"); if (!stringList.isEmpty()) { Object first = stringList.get(0); System.out.println("First element is String? " + (first instanceof String)); } } public static void arrayCreationIssue() { // This doesn't work - can't create generic arrays due to erasure // List<String>[] stringLists = new List<String>[10]; // Workaround 1: Use raw type (unsafe) @SuppressWarnings("unchecked") List<String>[] stringLists = new List[10]; stringLists[0] = new ArrayList<>(); // Workaround 2: Use ArrayList of lists List<List<String>> listOfLists = new ArrayList<>(); listOfLists.add(new ArrayList<>()); System.out.println("Created array of lists with workarounds"); } public static void main(String[] args) { System.out.println("=== Type Erasure Demonstration ==="); demonstrateErasure(); System.out.println("\n=== instanceof Limitation ==="); instanceOfLimitation(); System.out.println("\n=== Array Creation Issue ==="); arrayCreationIssue(); } }

Generic Class Erasure in Detail

import java.util.*; // Complex generic class to demonstrate erasure public class ComplexGenericClass<K extends Comparable<K>, V> { private K key; private V value; private List<Map<K, V>> data; public ComplexGenericClass(K key, V value) { this.key = key; this.value = value; this.data = new ArrayList<>(); } public void addData(Map<K, V> map) { data.add(map); } public K getKey() { return key; } public V getValue() { return value; } public List<Map<K, V>> getData() { return data; } // Generic method public <T extends Number> T process(T number) { return number; } } // What it looks like after erasure public class ComplexGenericClassAfterErasure { private Comparable key; // K extends Comparable<K> becomes Comparable private Object value; // V becomes Object private List data; // List<Map<K, V>> becomes List public ComplexGenericClassAfterErasure(Comparable key, Object value) { this.key = key; this.value = value; this.data = new ArrayList(); } public void addData(Map map) { data.add(map); } public Comparable getKey() { return key; } public Object getValue() { return value; } public List getData() { return data; } // Generic method after erasure public Number process(Number number) { return number; } } public class ComplexErasureDemo { public static void main(String[] args) { ComplexGenericClass<String, Integer> instance = new ComplexGenericClass<>("test", 42); System.out.println("Original class: " + instance.getClass()); System.out.println("Key: " + instance.getKey()); System.out.println("Value: " + instance.getValue()); // Show that generic information is erased TypeVariable<?>[] typeParams = instance.getClass().getTypeParameters(); System.out.println("Type parameters: " + Arrays.toString(typeParams)); for (TypeVariable<?> param : typeParams) { System.out.println("Parameter: " + param.getName()); System.out.println("Bounds: " + Arrays.toString(param.getBounds())); } } }

Bridge Methods

Understanding Bridge Methods

import java.util.*; import java.lang.reflect.*; // Generic class that will generate bridge methods public class BridgeMethodExample<T extends Comparable<T>> { private T value; public BridgeMethodExample(T value) { this.value = value; } public void setValue(T value) { this.value = value; } public T getValue() { return value; } } // Non-generic subclass public class StringContainer extends BridgeMethodExample<String> { public StringContainer(String value) { super(value); } // This overrides the generic method after erasure @Override public void setValue(String value) { System.out.println("Setting string value: " + value); super.setValue(value); } } public class BridgeMethodDemo { public static void demonstrateBridgeMethods() { StringContainer container = new StringContainer("hello"); // Get all methods including bridge methods Method[] methods = StringContainer.class.getDeclaredMethods(); System.out.println("Methods in StringContainer:"); for (Method method : methods) { System.out.println("Method: " + method.getName()); System.out.println(" Return type: " + method.getReturnType()); System.out.println(" Parameter types: " + Arrays.toString(method.getParameterTypes())); System.out.println(" Is bridge method: " + method.isBridge()); System.out.println(" Is synthetic: " + method.isSynthetic()); System.out.println(); } // Show what happens when we call setValue container.setValue("world"); // The bridge method ensures type safety try { // This would be called by polymorphic code expecting Object Method setValueMethod = StringContainer.class.getMethod("setValue", Object.class); if (setValueMethod.isBridge()) { System.out.println("Bridge method found: " + setValueMethod); setValueMethod.invoke(container, "bridge call"); } } catch (Exception e) { e.printStackTrace(); } } public static void main(String[] args) { demonstrateBridgeMethods(); } }

Bridge Method Generation

import java.lang.reflect.*; // Before erasure public class GenericNode<T> { public T data; public GenericNode(T data) { this.data = data; } public void setData(T data) { System.out.println("GenericNode.setData"); this.data = data; } } // After erasure, the compiler generates: public class GenericNodeAfterErasure { public Object data; public GenericNodeAfterErasure(Object data) { this.data = data; } public void setData(Object data) { System.out.println("GenericNode.setData"); this.data = data; } } // Subclass public class IntegerNode extends GenericNode<Integer> { public IntegerNode(Integer data) { super(data); } @Override public void setData(Integer data) { System.out.println("IntegerNode.setData"); super.setData(data); } // Bridge method generated by compiler: // public void setData(Object data) { // setData((Integer) data); // Type cast for safety // } } public class BridgeMethodGeneration { public static void showBridgeMethods() { IntegerNode node = new IntegerNode(5); System.out.println("All methods in IntegerNode:"); for (Method method : IntegerNode.class.getDeclaredMethods()) { System.out.println(" " + method + " [bridge: " + method.isBridge() + "]"); } // Demonstrate bridge method in action GenericNode rawNode = node; // Raw type assignment rawNode.setData("hello"); // This would fail at runtime due to bridge method // The bridge method ensures the cast happens: // rawNode.setData("hello") calls bridge method // bridge method calls setData((Integer)"hello") which throws ClassCastException } public static void main(String[] args) { showBridgeMethods(); // This will throw ClassCastException at runtime due to bridge method try { IntegerNode node = new IntegerNode(5); GenericNode rawNode = node; rawNode.setData("hello"); // Bridge method will cast to Integer } catch (ClassCastException e) { System.out.println("Caught ClassCastException: " + e.getMessage()); } } }

Limitations and Challenges

Common Limitations Due to Type Erasure

import java.util.*; public class TypeErasureLimitations { // 1. Cannot use instanceof with parameterized types public static void instanceOfLimitation() { List<String> stringList = new ArrayList<>(); // This doesn't compile // if (stringList instanceof List<String>) { } // Only raw types work if (stringList instanceof List) { System.out.println("It's a List (raw type)"); } } // 2. Cannot create arrays of parameterized types public static void arrayCreationLimitation() { // This doesn't compile // List<String>[] arrayOfLists = new List<String>[10]; // Workarounds: @SuppressWarnings("unchecked") List<String>[] arrayWithWarning = new List[10]; // Raw type array List<List<String>> listOfLists = new ArrayList<>(); // Use collection System.out.println("Used workarounds for generic arrays"); } // 3. Cannot overload methods with same erasure public static class OverloadingIssue { // These conflict after erasure (both become: public void process(List list)) // public void process(List<String> list) { } // public void process(List<Integer> list) { } // Workaround: use different method names public void processStrings(List<String> list) { } public void processIntegers(List<Integer> list) { } } // 4. Cannot catch instances of a generic class public static void catchGenericException() { // This doesn't work // try { // // some code // } catch (Exception<String> e) { // Can't parameterize catch // } } // 5. Cannot use primitive types as type parameters public static void primitiveTypeLimitation() { // This doesn't work - must use wrapper types // List<int> primitiveList = new ArrayList<>(); List<Integer> wrapperList = new ArrayList<>(); // Use wrapper } // 6. Cannot create new instance of type parameter public static class InstanceCreationIssue<T> { public T createInstance() { // This doesn't work due to erasure // return new T(); // Workaround: pass Class<T> as parameter return null; } // Workaround method public T createInstance(Class<T> clazz) throws Exception { return clazz.getDeclaredConstructor().newInstance(); } } // 7. Static context limitations public static class StaticContext<T> { // Cannot have static field of type T // private static T staticField; // But static methods can have their own type parameters public static <U> U staticMethod(U param) { return param; } } public static void main(String[] args) { instanceOfLimitation(); arrayCreationLimitation(); // Demonstrate instance creation workaround InstanceCreationIssue<String> creator = new InstanceCreationIssue<>(); try { String instance = creator.createInstance(String.class); System.out.println("Created instance: " + instance); } catch (Exception e) { e.printStackTrace(); } } }

Runtime Type Information Loss

import java.util.*; import java.lang.reflect.*; public class RuntimeTypeInformation { public static void demonstrateTypeLoss() { List<String> stringList = new ArrayList<>(); List<Integer> integerList = new ArrayList<>(); // At runtime, both have the same class System.out.println("stringList class: " + stringList.getClass()); System.out.println("integerList class: " + integerList.getClass()); System.out.println("Same class? " + (stringList.getClass() == integerList.getClass())); // Generic type parameters are not available at runtime ParameterizedType type = getGenericType(stringList); if (type != null) { System.out.println("Actual type arguments: " + Arrays.toString(type.getActualTypeArguments())); } else { System.out.println("No generic type information available at runtime"); } } // Helper method to try to get generic type (usually returns null due to erasure) private static ParameterizedType getGenericType(Object obj) { Type genericType = obj.getClass().getGenericSuperclass(); if (genericType instanceof ParameterizedType) { return (ParameterizedType) genericType; } return null; } // Demonstrating what information IS available public static void availableTypeInformation() { // Field types are available try { Field elementDataField = ArrayList.class.getDeclaredField("elementData"); System.out.println("ArrayList internal array type: " + elementDataField.getType()); } catch (NoSuchFieldException e) { e.printStackTrace(); } // Method parameter and return types are available (after erasure) Method[] methods = ArrayList.class.getDeclaredMethods(); for (Method method : methods) { if (method.getName().equals("get")) { System.out.println("ArrayList.get method return type: " + method.getReturnType()); System.out.println("ArrayList.get method parameter types: " + Arrays.toString(method.getParameterTypes())); } } } // The problem with varargs and generics public static <T> void varargsIssue(T... elements) { // Due to erasure, the array created is Object[] System.out.println("Varargs array type: " + elements.getClass()); System.out.println("Array component type: " + elements.getClass().getComponentType()); } public static void main(String[] args) { System.out.println("=== Runtime Type Information Loss ==="); demonstrateTypeLoss(); System.out.println("\n=== Available Type Information ==="); availableTypeInformation(); System.out.println("\n=== Varargs and Generics Issue ==="); varargsIssue("a", "b", "c"); varargsIssue(1, 2, 3); } }

Overcoming Type Erasure

Technique 1: Type Tokens

import java.util.*; import java.lang.reflect.*; public class TypeTokenTechnique { // Basic type token pattern public static class TypeSafeContainer<T> { private T value; private final Class<T> type; public TypeSafeContainer(Class<T> type) { this.type = type; } public TypeSafeContainer(Class<T> type, T value) { this.type = type; setValue(value); // Use setter for validation } public void setValue(T value) { // Runtime type checking if (value != null && !type.isInstance(value)) { throw new IllegalArgumentException( "Expected " + type.getName() + " but got " + value.getClass().getName()); } this.value = value; } public T getValue() { return value; } public Class<T> getType() { return type; } // Create array of the specific type @SuppressWarnings("unchecked") public T[] createArray(int size) { return (T[]) Array.newInstance(type, size); } // Create new instance public T newInstance() throws Exception { return type.getDeclaredConstructor().newInstance(); } } // Super type tokens for more complex generic types public abstract static class SuperTypeToken<T> { private final Type type; protected SuperTypeToken() { Type superclass = getClass().getGenericSuperclass(); if (superclass instanceof Class) { throw new RuntimeException("Missing type parameter"); } this.type = ((ParameterizedType) superclass).getActualTypeArguments()[0]; } public Type getType() { return type; } } // Using super type tokens public static class GenericRepository<T> { private final Type type; private final Map<String, T> storage = new HashMap<>(); public GenericRepository() { this.type = ((ParameterizedType) getClass().getGenericSuperclass()) .getActualTypeArguments()[0]; } public void save(String key, T value) { storage.put(key, value); } @SuppressWarnings("unchecked") public T find(String key) { return storage.get(key); } public Type getType() { return type; } } public static void main(String[] args) throws Exception { // Using basic type tokens TypeSafeContainer<String> stringContainer = new TypeSafeContainer<>(String.class, "Hello"); System.out.println("Container type: " + stringContainer.getType()); System.out.println("Container value: " + stringContainer.getValue()); String[] stringArray = stringContainer.createArray(5); System.out.println("Created array of type: " + stringArray.getClass().getComponentType()); // Using super type tokens GenericRepository<List<String>> listRepo = new GenericRepository<List<String>>() {}; System.out.println("Repository type: " + listRepo.getType()); // Demonstrate type safety try { TypeSafeContainer<Integer> intContainer = new TypeSafeContainer<>(Integer.class); intContainer.setValue(42); // OK // intContainer.setValue("hello"); // Throws IllegalArgumentException } catch (IllegalArgumentException e) { System.out.println("Type safety enforced: " + e.getMessage()); } } }

Technique 2: Type-Safe Heterogeneous Container

import java.util.*; import java.lang.reflect.*; public class TypeSafeHeterogeneousContainer { private Map<Class<?>, Object> container = new HashMap<>(); public <T> void put(Class<T> type, T instance) { if (type == null) { throw new NullPointerException("Type is null"); } container.put(type, type.cast(instance)); } public <T> T get(Class<T> type) { return type.cast(container.get(type)); } public <T> boolean contains(Class<T> type) { return container.containsKey(type); } public <T> void remove(Class<T> type) { container.remove(type); } // Advanced: Support for generic types using super type tokens private Map<Type, Object> genericContainer = new HashMap<>(); public <T> void putGeneric(TypeReference<T> typeReference, T instance) { genericContainer.put(typeReference.getType(), instance); } @SuppressWarnings("unchecked") public <T> T getGeneric(TypeReference<T> typeReference) { return (T) genericContainer.get(typeReference.getType()); } // Type reference for generic types public static abstract class TypeReference<T> { private final Type type; protected TypeReference() { Type superclass = getClass().getGenericSuperclass(); if (superclass instanceof Class) { throw new RuntimeException("Missing type parameter"); } this.type = ((ParameterizedType) superclass).getActualTypeArguments()[0]; } public Type getType() { return type; } } public static void main(String[] args) { TypeSafeHeterogeneousContainer container = new TypeSafeHeterogeneousContainer(); // Store different types safely container.put(String.class, "Hello World"); container.put(Integer.class, 42); container.put(List.class, Arrays.asList("A", "B", "C")); // Retrieve with type safety String str = container.get(String.class); Integer num = container.get(Integer.class); @SuppressWarnings("unchecked") List<String> list = container.get(List.class); System.out.println("String: " + str); System.out.println("Integer: " + num); System.out.println("List: " + list); // Generic type example container.putGeneric(new TypeReference<List<String>>() {}, Arrays.asList("X", "Y", "Z")); List<String> genericList = container.getGeneric(new TypeReference<List<String>>() {}); System.out.println("Generic List: " + genericList); // Type safety demonstration try { // This would throw ClassCastException if we tried wrong type // Integer wrong = container.get(String.class); } catch (ClassCastException e) { System.out.println("Type safety violation caught"); } } }

Technique 3: Runtime Type Checking

import java.util.*; import java.lang.reflect.*; public class RuntimeTypeChecking { // Method for runtime type checking public static <T> void checkType(T obj, Class<T> expectedType) { if (obj != null && !expectedType.isInstance(obj)) { throw new ClassCastException( "Expected " + expectedType.getName() + " but got " + obj.getClass().getName()); } } // Generic array creation with type safety public static <T> T[] createArray(Class<T> type, int size) { @SuppressWarnings("unchecked") T[] array = (T[]) Array.newInstance(type, size); return array; } // Safe generic array copy public static <T> T[] copyArray(T[] original, Class<T> type) { T[] copy = createArray(type, original.length); System.arraycopy(original, 0, copy, 0, original.length); return copy; } // Instance creation with reflection public static <T> T createInstance(Class<T> type) { try { return type.getDeclaredConstructor().newInstance(); } catch (Exception e) { throw new RuntimeException("Failed to create instance of " + type.getName(), e); } } // Generic method with runtime type validation public static <T> List<T> filterByType(List<?> list, Class<T> type) { List<T> result = new ArrayList<>(); for (Object obj : list) { if (type.isInstance(obj)) { result.add(type.cast(obj)); } } return result; } // Type-safe utility class public static class TypeSafeUtils { private static final Map<Class<?>, Object> DEFAULTS = new HashMap<>(); static { DEFAULTS.put(int.class, 0); DEFAULTS.put(long.class, 0L); DEFAULTS.put(double.class, 0.0); DEFAULTS.put(float.class, 0.0f); DEFAULTS.put(boolean.class, false); DEFAULTS.put(char.class, '\0'); DEFAULTS.put(byte.class, (byte) 0); DEFAULTS.put(short.class, (short) 0); } @SuppressWarnings("unchecked") public static <T> T getDefaultValue(Class<T> type) { return (T) DEFAULTS.get(type); } public static <T> boolean isDefaultValue(T value, Class<T> type) { if (value == null) return true; if (type.isPrimitive()) { return value.equals(getDefaultValue(type)); } return false; } } public static void main(String[] args) { // Runtime type checking try { checkType("hello", String.class); // OK checkType(123, String.class); // Throws exception } catch (ClassCastException e) { System.out.println("Type check failed: " + e.getMessage()); } // Safe array creation String[] stringArray = createArray(String.class, 5); System.out.println("Created array: " + Arrays.toString(stringArray)); // Instance creation try { String instance = createInstance(String.class); System.out.println("Created instance: '" + instance + "'"); } catch (Exception e) { System.out.println("Failed to create instance: " + e.getMessage()); } // Filter by type List<Object> mixedList = Arrays.asList("hello", 42, "world", 3.14); List<String> strings = filterByType(mixedList, String.class); System.out.println("Filtered strings: " + strings); // Default values System.out.println("Default int: " + TypeSafeUtils.getDefaultValue(int.class)); System.out.println("Default boolean: " + TypeSafeUtils.getDefaultValue(boolean.class)); } }

Reifiable vs Non-Reifiable Types

Understanding Reifiable Types

import java.util.*; import java.lang.reflect.*; public class ReifiableTypes { // Reifiable types - type information fully available at runtime public static void demonstrateReifiableTypes() { // Primitive types System.out.println("int.class: " + int.class); System.out.println("double.class: " + double.class); // Non-generic reference types System.out.println("String.class: " + String.class); System.out.println("Date.class: " + Date.class); // Raw types System.out.println("List.class: " + List.class); System.out.println("Map.class: " + Map.class); // Arrays (including arrays of parameterized types) System.out.println("String[].class: " + String[].class); System.out.println("List[].class: " + List[].class); // Unbounded wildcard types List<?> wildcardList = new ArrayList<>(); System.out.println("List<?> instance class: " + wildcardList.getClass()); } // Non-reifiable types - type information erased at runtime public static void demonstrateNonReifiableTypes() { // Parameterized types List<String> stringList = new ArrayList<>(); List<Integer> integerList = new ArrayList<>(); System.out.println("List<String> class: " + stringList.getClass()); System.out.println("List<Integer> class: " + integerList.getClass()); System.out.println("Same class? " + (stringList.getClass() == integerList.getClass())); // Type variables System.out.println("Type variables are non-reifiable"); // Bounded wildcard types List<? extends Number> numberList = new ArrayList<>(); System.out.println("List<? extends Number> class: " + numberList.getClass()); } // Consequences of non-reifiability public static void consequences() { System.out.println("=== Consequences of Non-Reifiable Types ==="); // 1. instanceof doesn't work with parameterized types List<String> list = new ArrayList<>(); System.out.println("list instanceof List: " + (list instanceof List)); // System.out.println("list instanceof List<String>: " + (list instanceof List<String>)); // Compile error // 2. Cannot create arrays of parameterized types // List<String>[] array = new List<String>[10]; // Compile error // 3. Varargs warnings genericMethod("a", "b", "c"); // Causes unchecked warning } @SafeVarargs public static <T> void genericMethod(T... elements) { System.out.println("Varargs array type: " + elements.getClass()); } // Working with reifiable types public static void workingWithReifiableTypes() { System.out.println("\n=== Working with Reifiable Types ==="); // Arrays are reifiable String[] stringArray = new String[5]; System.out.println("Array component type: " + stringArray.getClass().getComponentType()); // Class literals are reifiable Class<?> stringClass = String.class; System.out.println("Class: " + stringClass); // instanceof with reifiable types Object obj = "hello"; if (obj instanceof String) { String str = (String) obj; System.out.println("It's a String: " + str); } } public static void main(String[] args) { demonstrateReifiableTypes(); demonstrateNonReifiableTypes(); consequences(); workingWithReifiableTypes(); } }

Best Practices

Dealing with Type Erasure

import java.util.*; import java.lang.reflect.*; public class TypeErasureBestPractices { // 1. Always use generic types, avoid raw types public static void useGenerics() { // Good List<String> strings = new ArrayList<>(); // Bad @SuppressWarnings("rawtypes") List rawList = new ArrayList(); } // 2. Use bounded wildcards for maximum flexibility public static class FlexibleAPI { // Producer - use extends public static double sum(Collection<? extends Number> numbers) { return numbers.stream() .mapToDouble(Number::doubleValue) .sum(); } // Consumer - use super public static void addNumbers(Collection<? super Integer> numbers) { numbers.add(1); numbers.add(2); numbers.add(3); } } // 3. Use @SuppressWarnings judiciously and document why @SuppressWarnings("unchecked") public static <T> T[] createArray(Class<T> type, int size) { // We know this is safe because we're using Array.newInstance return (T[]) Array.newInstance(type, size); } // 4. Use type tokens when you need runtime type information public static class TypeAware<T> { private final Class<T> type; public TypeAware(Class<T> type) { this.type = Objects.requireNonNull(type, "Type cannot be null"); } public boolean isInstance(Object obj) { return type.isInstance(obj); } public T cast(Object obj) { return type.cast(obj); } public T newInstance() throws Exception { return type.getDeclaredConstructor().newInstance(); } } // 5. Avoid generic arrays - use collections instead public static void avoidGenericArrays() { // Instead of this (doesn't work): // List<String>[] arrayOfLists = new List<String>[10]; // Use this: List<List<String>> listOfLists = new ArrayList<>(); } // 6. Be careful with varargs and generics @SafeVarargs // Only add if you're sure the method is safe public static <T> List<T> asList(T... elements) { List<T> list = new ArrayList<>(); for (T element : elements) { list.add(element); } return list; } // 7. Use helper methods for type-safe operations public static class TypeSafeHelpers { public static <T> void checkType(T obj, Class<T> expectedType) { if (obj != null && !expectedType.isInstance(obj)) { throw new ClassCastException( "Expected " + expectedType.getName() + " but got " + obj.getClass().getName()); } } public static <T> List<T> filterByType(List<?> list, Class<T> type) { List<T> result = new ArrayList<>(); for (Object obj : list) { if (type.isInstance(obj)) { result.add(type.cast(obj)); } } return result; } } // 8. Document generic constraints and behavior /** * A type-safe container that preserves type information at runtime. * * @param <T> the type of elements in this container, must have a no-arg constructor */ public static class DocumentedContainer<T> { private final Class<T> type; private T value; /** * Creates a new container for the specified type. * * @param type the class object representing the type T * @throws NullPointerException if type is null */ public DocumentedContainer(Class<T> type) { this.type = Objects.requireNonNull(type, "Type cannot be null"); } /** * Sets the value, performing runtime type checking. * * @param value the value to set * @throws IllegalArgumentException if value is not an instance of T */ public void setValue(T value) { if (value != null && !type.isInstance(value)) { throw new IllegalArgumentException( "Value must be an instance of " + type.getName()); } this.value = value; } } // 9. Test generic code thoroughly public static class GenericTestUtils { public static <T extends Comparable<T>> void testComparable(T a, T b) { assert a.compareTo(b) != 0 : "Values should be different"; } public static <T> void testTypeSafety(Class<T> type, Object... testValues) { for (Object value : testValues) { try { type.cast(value); System.out.println("OK: " + value + " is instance of " + type); } catch (ClassCastException e) { System.out.println("FAIL: " + value + " is not instance of " + type); } } } } // 10. Consider performance implications public static class PerformanceConsiderations { // Reflection is slower than direct calls public static <T> T createWithReflection(Class<T> type) throws Exception { long start = System.nanoTime(); T instance = type.getDeclaredConstructor().newInstance(); long end = System.nanoTime(); System.out.println("Reflection creation took: " + (end - start) + " ns"); return instance; } // Type checking has a cost public static <T> void safeOperation(T value, Class<T> type) { long start = System.nanoTime(); TypeSafeHelpers.checkType(value, type); long end = System.nanoTime(); System.out.println("Type check took: " + (end - start) + " ns"); } } public static void main(String[] args) throws Exception { // Demonstrate best practices List<Number> numbers = Arrays.asList(1, 2.5, 3L); double sum = FlexibleAPI.sum(numbers); System.out.println("Sum: " + sum); // Type-aware usage TypeAware<String> stringAware = new TypeAware<>(String.class); System.out.println("Is 'hello' a String? " + stringAware.isInstance("hello")); // Type safety testing GenericTestUtils.testTypeSafety(String.class, "hello", 123, 45.67); // Performance consideration String instance = PerformanceConsiderations.createWithReflection(String.class); PerformanceConsiderations.safeOperation("test", String.class); } }

Summary

Key Takeaways:

1. Type Erasure Removes Generic Type Information at compile time
2. Bridge Methods Maintain Polymorphism and type safety
3. Runtime Type Checks Are Limited - cannot use instanceof with generics
4. Arrays and Generics Don't Mix Well - cannot create generic arrays
5. Workarounds Exist using type tokens, reflection, and careful design

Common Patterns to Overcome Erasure:

• Type Tokens: Pass Class<T> as parameter
• Super Type Tokens: Use anonymous subclasses to capture type information
• Type-Safe Containers: Store types with their instances
• Runtime Checks: Use instanceof and casting with careful validation

Remember:

• Generics provide compile-time type safety
• Type erasure ensures backward compatibility
• Design APIs with erasure in mind
• Use the techniques shown when runtime type information is needed

Type erasure is a fundamental aspect of Java generics that enables compatibility while providing type safety. Understanding it is crucial for writing robust generic code.