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.