Java Programming#
Lecture 38: Generics in Java#
GTU Diploma in Computer Engineering#
layout: two-cols#
Learning Objectives#
After this lecture, you will be able to:
- Understand the concept and benefits of Generics in Java
- Create generic classes, interfaces, and methods
- Work with bounded type parameters and wildcards
- Implement type erasure concepts
- Use generic collections effectively
- Apply generic programming best practices
::right::
Lecture Overview#
- Introduction to Generics
- Generic Classes and Interfaces
- Generic Methods
- Bounded Type Parameters
- Wildcards in Generics
- Type Erasure
- Generic Collections
- Best Practices
- Hands-on Exercises
What are Generics?#
Generics enable type safety at compile time and eliminate the need for casting.
// Without Generics (Java < 5)
List list = new ArrayList();
list.add("Hello");
String s = (String) list.get(0); // Cast required
// With Generics (Java 5+)
List<String> list = new ArrayList<String>();
list.add("Hello");
String s = list.get(0); // No cast needed
Benefits of Generics#
- Type Safety: Compile-time type checking
- Elimination of Casting: No explicit casting needed
- Code Clarity: Code is more readable and self-documenting
- Performance: No boxing/unboxing overhead
Generic Classes#
Generic classes allow you to create classes that work with different types.
// Generic class definition
public class Container<T> {
private T item;
public void set(T item) {
this.item = item;
}
public T get() {
return item;
}
public boolean isEmpty() {
return item == null;
}
}
// Using generic class
public class GenericClassDemo {
public static void main(String[] args) {
// Container for String
Container<String> stringContainer = new Container<String>();
stringContainer.set("Hello World");
String value = stringContainer.get();
// Container for Integer
Container<Integer> intContainer = new Container<Integer>();
intContainer.set(42);
Integer number = intContainer.get();
System.out.println("String: " + value);
System.out.println("Integer: " + number);
}
}
Multiple Type Parameters#
Classes can have multiple generic type parameters.
public class Pair<T, U> {
private T first;
private U second;
public Pair(T first, U second) {
this.first = first;
this.second = second;
}
public T getFirst() { return first; }
public U getSecond() { return second; }
public void setFirst(T first) { this.first = first; }
public void setSecond(U second) { this.second = second; }
@Override
public String toString() {
return "(" + first + ", " + second + ")";
}
}
public class PairDemo {
public static void main(String[] args) {
Pair<String, Integer> nameAge = new Pair<>("Alice", 25);
Pair<Integer, String> idName = new Pair<>(101, "Bob");
System.out.println("Name-Age: " + nameAge);
System.out.println("ID-Name: " + idName);
// Accessing elements
String name = nameAge.getFirst();
Integer age = nameAge.getSecond();
System.out.println(name + " is " + age + " years old");
}
}
Generic Interfaces#
Interfaces can also be generic.
// Generic interface
public interface Repository<T> {
void save(T entity);
T findById(int id);
List<T> findAll();
boolean delete(T entity);
}
// Implementing generic interface
public class StudentRepository implements Repository<Student> {
private List<Student> students = new ArrayList<>();
@Override
public void save(Student student) {
students.add(student);
}
@Override
public Student findById(int id) {
return students.stream()
.filter(s -> s.getId() == id)
.findFirst()
.orElse(null);
}
@Override
public List<Student> findAll() {
return new ArrayList<>(students);
}
@Override
public boolean delete(Student student) {
return students.remove(student);
}
}
Generic Methods#
Methods can be generic independently of their class.
public class GenericMethods {
// Generic method to swap array elements
public static <T> void swap(T[] array, int i, int j) {
if (i >= 0 && i < array.length && j >= 0 && j < array.length) {
T temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
// Generic method to find element in array
public static <T> boolean contains(T[] array, T element) {
for (T item : array) {
if (item != null && item.equals(element)) {
return true;
}
}
return false;
}
// Generic method to convert array to list
public static <T> List<T> arrayToList(T[] array) {
List<T> list = new ArrayList<>();
for (T element : array) {
list.add(element);
}
return list;
}
}
Generic Method Usage#
public class GenericMethodDemo {
public static void main(String[] args) {
// String array operations
String[] names = {"Alice", "Bob", "Charlie", "Diana"};
System.out.println("Original: " + Arrays.toString(names));
GenericMethods.swap(names, 0, 2);
System.out.println("After swap: " + Arrays.toString(names));
boolean found = GenericMethods.contains(names, "Bob");
System.out.println("Contains 'Bob': " + found);
// Integer array operations
Integer[] numbers = {1, 2, 3, 4, 5};
GenericMethods.swap(numbers, 1, 3);
System.out.println("Numbers after swap: " + Arrays.toString(numbers));
List<Integer> numberList = GenericMethods.arrayToList(numbers);
System.out.println("Converted to list: " + numberList);
// Generic method with return type
String max = findMax("hello", "world");
Integer maxNum = findMax(10, 20);
System.out.println("Max string: " + max);
System.out.println("Max number: " + maxNum);
}
public static <T extends Comparable<T>> T findMax(T a, T b) {
return a.compareTo(b) > 0 ? a : b;
}
}
Bounded Type Parameters#
You can restrict the types that can be used as type arguments.
// Bounded by class (extends)
public class NumberContainer<T extends Number> {
private T number;
public NumberContainer(T number) {
this.number = number;
}
public double getDoubleValue() {
return number.doubleValue(); // Number method available
}
public boolean isPositive() {
return number.doubleValue() > 0;
}
public T getNumber() {
return number;
}
}
// Bounded by interface
public class ComparableContainer<T extends Comparable<T>> {
private List<T> items = new ArrayList<>();
public void add(T item) {
items.add(item);
}
public T findMax() {
if (items.isEmpty()) return null;
T max = items.get(0);
for (T item : items) {
if (item.compareTo(max) > 0) {
max = item;
}
}
return max;
}
public T findMin() {
if (items.isEmpty()) return null;
T min = items.get(0);
for (T item : items) {
if (item.compareTo(min) < 0) {
min = item;
}
}
return min;
}
}
Multiple Bounds#
A type parameter can have multiple bounds.
// Interface for objects that can be serialized
interface Serializable {
String serialize();
}
// Interface for objects that can be compared
interface Comparable<T> {
int compareTo(T other);
}
// Class with multiple bounds
public class DataProcessor<T extends Number & Serializable & Comparable<T>> {
private List<T> data = new ArrayList<>();
public void addData(T item) {
data.add(item);
}
public String serializeAll() {
StringBuilder sb = new StringBuilder();
for (T item : data) {
sb.append(item.serialize()).append("\n");
}
return sb.toString();
}
public T findMaximum() {
if (data.isEmpty()) return null;
T max = data.get(0);
for (T item : data) {
if (item.compareTo(max) > 0) {
max = item;
}
}
return max;
}
public double getSum() {
return data.stream()
.mapToDouble(Number::doubleValue)
.sum();
}
}
Wildcards in Generics#
Wildcards represent unknown types in generics.
Unbounded Wildcard (?)#
public class WildcardDemo {
// Method that accepts list of any type
public static void printList(List<?> list) {
for (Object item : list) {
System.out.println(item);
}
}
public static int getListSize(List<?> list) {
return list.size();
}
public static void main(String[] args) {
List<String> stringList = Arrays.asList("A", "B", "C");
List<Integer> intList = Arrays.asList(1, 2, 3);
printList(stringList); // Works
printList(intList); // Works
System.out.println("String list size: " + getListSize(stringList));
System.out.println("Integer list size: " + getListSize(intList));
}
}
Upper Bounded Wildcards#
Use ? extends Type for reading from a generic collection.
public class UpperBoundedWildcard {
// Method that calculates sum of numbers
public static double calculateSum(List<? extends Number> numbers) {
double sum = 0.0;
for (Number num : numbers) {
sum += num.doubleValue();
}
return sum;
}
// Method to find maximum number
public static double findMax(List<? extends Number> numbers) {
if (numbers.isEmpty()) {
throw new IllegalArgumentException("List cannot be empty");
}
double max = numbers.get(0).doubleValue();
for (Number num : numbers) {
if (num.doubleValue() > max) {
max = num.doubleValue();
}
}
return max;
}
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
List<Double> doubles = Arrays.asList(1.5, 2.7, 3.9);
List<Float> floats = Arrays.asList(1.1f, 2.2f, 3.3f);
System.out.println("Sum of integers: " + calculateSum(integers));
System.out.println("Sum of doubles: " + calculateSum(doubles));
System.out.println("Sum of floats: " + calculateSum(floats));
System.out.println("Max integer: " + findMax(integers));
System.out.println("Max double: " + findMax(doubles));
System.out.println("Max float: " + findMax(floats));
}
}
Lower Bounded Wildcards#
Use ? super Type for writing to a generic collection.
public class LowerBoundedWildcard {
// Method to add integers to a collection
public static void addNumbers(List<? super Integer> numbers) {
numbers.add(1);
numbers.add(2);
numbers.add(3);
}
// Method to copy from source to destination
public static <T> void copy(List<? extends T> source,
List<? super T> destination) {
for (T item : source) {
destination.add(item);
}
}
public static void main(String[] args) {
// Lower bounded wildcard example
List<Number> numbers = new ArrayList<>();
List<Object> objects = new ArrayList<>();
addNumbers(numbers); // Integer is subtype of Number
addNumbers(objects); // Integer is subtype of Object
System.out.println("Numbers: " + numbers);
System.out.println("Objects: " + objects);
// Copy example
List<String> source = Arrays.asList("A", "B", "C");
List<Object> destination = new ArrayList<>();
copy(source, destination);
System.out.println("Destination: " + destination);
// Another copy example
List<Integer> intSource = Arrays.asList(1, 2, 3);
List<Number> numberDest = new ArrayList<>();
copy(intSource, numberDest);
System.out.println("Number destination: " + numberDest);
}
}
PECS Principle#
Producer Extends, Consumer Super - A guideline for using wildcards.
public class PECSDemo {
// Producer - use extends (reading from collection)
public static double sumAll(List<? extends Number> numbers) {
double sum = 0;
for (Number n : numbers) { // Reading/Producing
sum += n.doubleValue();
}
return sum;
}
// Consumer - use super (writing to collection)
public static void addIntegers(List<? super Integer> numbers) {
numbers.add(1); // Writing/Consuming
numbers.add(2);
numbers.add(3);
}
// Complex example: copying with PECS
public static <T> void copy(List<? extends T> source, // Producer
List<? super T> destination) { // Consumer
for (T element : source) { // Reading from source (Producer)
destination.add(element); // Writing to destination (Consumer)
}
}
public static void main(String[] args) {
// Producer example
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
System.out.println("Sum of integers: " + sumAll(integers));
System.out.println("Sum of doubles: " + sumAll(doubles));
// Consumer example
List<Number> numbers = new ArrayList<>();
List<Object> objects = new ArrayList<>();
addIntegers(numbers);
addIntegers(objects);
System.out.println("Numbers: " + numbers);
System.out.println("Objects: " + objects);
}
}
Type Erasure#
Java implements generics through type erasure - generic type information is removed at runtime.
public class TypeErasureDemo {
public static void demonstrateTypeErasure() {
List<String> stringList = new ArrayList<String>();
List<Integer> integerList = new ArrayList<Integer>();
// At runtime, both lists have the same class
System.out.println("String list class: " + stringList.getClass());
System.out.println("Integer list class: " + integerList.getClass());
// Both print: class java.util.ArrayList
System.out.println("Are classes equal? " +
stringList.getClass().equals(integerList.getClass()));
}
// Generic method
public static <T> void genericMethod(T parameter) {
System.out.println("Parameter type at runtime: " +
parameter.getClass().getName());
}
public static void main(String[] args) {
demonstrateTypeErasure();
genericMethod("Hello"); // String
genericMethod(42); // Integer
genericMethod(3.14); // Double
// Demonstrating limitations of type erasure
List<String> list = new ArrayList<>();
// This won't work - cannot check parameterized type
// if (list instanceof List<String>) { } // Compilation error
// This works - raw type check
if (list instanceof List) {
System.out.println("list is a List");
}
}
}
Generic Collections in Practice#
Using generics with Java Collections Framework.
import java.util.*;
public class GenericCollectionsDemo {
public static void main(String[] args) {
// Generic List
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");
System.out.println("Fruits: " + fruits);
// Generic Set
Set<Integer> uniqueNumbers = new HashSet<>();
uniqueNumbers.add(1);
uniqueNumbers.add(2);
uniqueNumbers.add(1); // Duplicate - won't be added
System.out.println("Unique numbers: " + uniqueNumbers);
// Generic Map
Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 25);
ages.put("Bob", 30);
ages.put("Charlie", 35);
System.out.println("Ages: " + ages);
// Iterating with enhanced for loop
System.out.println("\nIterating through collections:");
for (String fruit : fruits) {
System.out.println("Fruit: " + fruit);
}
for (Integer number : uniqueNumbers) {
System.out.println("Number: " + number);
}
for (Map.Entry<String, Integer> entry : ages.entrySet()) {
System.out.println(entry.getKey() + " is " + entry.getValue() + " years old");
}
}
}
Advanced Generic Collections#
Working with nested generics and complex types.
public class AdvancedGenericCollections {
public static void main(String[] args) {
// List of Lists
List<List<String>> matrix = new ArrayList<>();
matrix.add(Arrays.asList("A1", "A2", "A3"));
matrix.add(Arrays.asList("B1", "B2", "B3"));
matrix.add(Arrays.asList("C1", "C2", "C3"));
System.out.println("Matrix:");
for (List<String> row : matrix) {
System.out.println(row);
}
// Map of Lists
Map<String, List<Integer>> studentGrades = new HashMap<>();
studentGrades.put("Alice", Arrays.asList(85, 90, 88));
studentGrades.put("Bob", Arrays.asList(75, 80, 85));
studentGrades.put("Charlie", Arrays.asList(95, 92, 98));
System.out.println("\nStudent Grades:");
for (Map.Entry<String, List<Integer>> entry : studentGrades.entrySet()) {
String student = entry.getKey();
List<Integer> grades = entry.getValue();
double average = grades.stream().mapToInt(Integer::intValue).average().orElse(0);
System.out.println(student + ": " + grades + " (Average: " + average + ")");
}
// Set of Maps
Set<Map<String, String>> records = new HashSet<>();
Map<String, String> record1 = new HashMap<>();
record1.put("name", "Alice");
record1.put("age", "25");
records.add(record1);
Map<String, String> record2 = new HashMap<>();
record2.put("name", "Bob");
record2.put("age", "30");
records.add(record2);
System.out.println("\nRecords:");
for (Map<String, String> record : records) {
System.out.println(record);
}
}
}
Generic Best Practices#
1. Use Meaningful Type Parameter Names#
// Poor naming
public class Container<T, U, V> { }
// Better naming
public class DatabaseConnection<Entity, Key, Result> { }
// Common conventions
// T - Type
// E - Element (used by collections)
// K - Key (used by maps)
// V - Value (used by maps)
// N - Number
2. Favor Generic Types Over Raw Types#
// Avoid raw types
List list = new ArrayList(); // Raw type
list.add("Hello");
String s = (String) list.get(0); // Cast required
// Use generic types
List<String> list = new ArrayList<String>();
list.add("Hello");
String s = list.get(0); // No cast needed
More Best Practices#
3. Use Bounded Wildcards for Flexibility#
// Too restrictive
public void processNumbers(List<Number> numbers) { }
// More flexible
public void processNumbers(List<? extends Number> numbers) { }
4. Eliminate Unchecked Warnings#
// Causes unchecked warning
Set<String> set = new HashSet();
// Clean - no warnings
Set<String> set = new HashSet<String>();
// Java 7+ Diamond operator
Set<String> set = new HashSet<>();
5. Prefer Lists to Arrays for Type Safety#
// Arrays are covariant - can cause runtime errors
Number[] numbers = new Integer[10];
numbers[0] = 1.5; // Compiles but throws ArrayStoreException at runtime
// Lists with generics are safer
List<Number> numbers = new ArrayList<Integer>(); // Compilation error - caught early
Real-World Generic Example: Repository Pattern#
// Generic repository interface
public interface Repository<T, ID> {
T save(T entity);
Optional<T> findById(ID id);
List<T> findAll();
void deleteById(ID id);
boolean existsById(ID id);
}
// Generic abstract implementation
public abstract class AbstractRepository<T, ID> implements Repository<T, ID> {
protected Map<ID, T> storage = new HashMap<>();
@Override
public T save(T entity) {
ID id = getId(entity);
storage.put(id, entity);
return entity;
}
@Override
public Optional<T> findById(ID id) {
return Optional.ofNullable(storage.get(id));
}
@Override
public List<T> findAll() {
return new ArrayList<>(storage.values());
}
@Override
public void deleteById(ID id) {
storage.remove(id);
}
@Override
public boolean existsById(ID id) {
return storage.containsKey(id);
}
protected abstract ID getId(T entity);
}
Repository Implementation Example#
// Student entity
public class Student {
private Long id;
private String name;
private String email;
public Student(Long id, String name, String email) {
this.id = id;
this.name = name;
this.email = email;
}
// Getters and setters
public Long getId() { return id; }
public String getName() { return name; }
public String getEmail() { return email; }
@Override
public String toString() {
return "Student{id=" + id + ", name='" + name + "', email='" + email + "'}";
}
}
// Concrete repository implementation
public class StudentRepository extends AbstractRepository<Student, Long> {
@Override
protected Long getId(Student entity) {
return entity.getId();
}
// Additional specific methods
public List<Student> findByName(String name) {
return storage.values().stream()
.filter(student -> student.getName().equalsIgnoreCase(name))
.collect(Collectors.toList());
}
public Optional<Student> findByEmail(String email) {
return storage.values().stream()
.filter(student -> student.getEmail().equalsIgnoreCase(email))
.findFirst();
}
}
Using the Generic Repository#
public class RepositoryDemo {
public static void main(String[] args) {
StudentRepository repository = new StudentRepository();
// Save students
Student alice = repository.save(new Student(1L, "Alice", "alice@email.com"));
Student bob = repository.save(new Student(2L, "Bob", "bob@email.com"));
Student charlie = repository.save(new Student(3L, "Charlie", "charlie@email.com"));
System.out.println("All students:");
repository.findAll().forEach(System.out::println);
// Find by ID
Optional<Student> found = repository.findById(2L);
if (found.isPresent()) {
System.out.println("\nFound student: " + found.get());
}
// Find by name (custom method)
List<Student> bobs = repository.findByName("Bob");
System.out.println("\nStudents named Bob: " + bobs);
// Find by email (custom method)
Optional<Student> studentByEmail = repository.findByEmail("alice@email.com");
if (studentByEmail.isPresent()) {
System.out.println("\nStudent with email alice@email.com: " + studentByEmail.get());
}
// Check existence
boolean exists = repository.existsById(1L);
System.out.println("\nStudent with ID 1 exists: " + exists);
// Delete student
repository.deleteById(2L);
System.out.println("\nAfter deleting student with ID 2:");
repository.findAll().forEach(System.out::println);
}
}
Hands-on Exercise 1: Generic Stack Implementation#
Create a generic Stack class with the following requirements:
public class GenericStack<T> {
// TODO: Implement using ArrayList internally
// TODO: Implement push method
public void push(T item) {
// Your implementation
}
// TODO: Implement pop method
public T pop() {
// Your implementation
// Throw EmptyStackException if stack is empty
}
// TODO: Implement peek method
public T peek() {
// Your implementation
// Throw EmptyStackException if stack is empty
}
// TODO: Implement isEmpty method
public boolean isEmpty() {
// Your implementation
}
// TODO: Implement size method
public int size() {
// Your implementation
}
// TODO: Override toString method
@Override
public String toString() {
// Your implementation
}
}
Test your implementation with different data types.
Hands-on Exercise 2: Generic Utility Methods#
Implement the following generic utility methods:
public class GenericUtils {
// TODO: Implement method to reverse any array
public static <T> void reverse(T[] array) {
// Your implementation
}
// TODO: Implement method to find element in array
public static <T> int indexOf(T[] array, T element) {
// Your implementation
// Return -1 if not found
}
// TODO: Implement method to get maximum element
public static <T extends Comparable<T>> T max(T[] array) {
// Your implementation
// Throw IllegalArgumentException if array is empty
}
// TODO: Implement method to filter list based on predicate
public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
// Your implementation
// Use Predicate functional interface
}
}
Create test cases for each method with different data types.
Hands-on Exercise 3: Generic Cache Implementation#
Create a generic LRU (Least Recently Used) cache:
public class LRUCache<K, V> {
private final int capacity;
// TODO: Use appropriate data structures
// Hint: Consider using LinkedHashMap or implement with HashMap + doubly linked list
public LRUCache(int capacity) {
// TODO: Initialize cache with given capacity
}
public V get(K key) {
// TODO: Get value and mark as recently used
// Return null if key doesn't exist
}
public void put(K key, V value) {
// TODO: Put key-value pair
// If at capacity, remove least recently used item
}
public int size() {
// TODO: Return current size
}
public boolean containsKey(K key) {
// TODO: Check if key exists
}
public void clear() {
// TODO: Clear all entries
}
// TODO: Override toString for debugging
}
Test your cache with different key-value types and verify LRU behavior.
Exercise Solutions: Generic Stack#
import java.util.*;
public class GenericStack<T> {
private List<T> elements;
public GenericStack() {
elements = new ArrayList<>();
}
public void push(T item) {
elements.add(item);
}
public T pop() {
if (isEmpty()) {
throw new EmptyStackException();
}
return elements.remove(elements.size() - 1);
}
public T peek() {
if (isEmpty()) {
throw new EmptyStackException();
}
return elements.get(elements.size() - 1);
}
public boolean isEmpty() {
return elements.isEmpty();
}
public int size() {
return elements.size();
}
@Override
public String toString() {
return "Stack{" + elements + "}";
}
}
Exercise Solutions: Generic Utilities#
import java.util.*;
import java.util.function.Predicate;
public class GenericUtils {
public static <T> void reverse(T[] array) {
if (array == null) return;
int left = 0;
int right = array.length - 1;
while (left < right) {
T temp = array[left];
array[left] = array[right];
array[right] = temp;
left++;
right--;
}
}
public static <T> int indexOf(T[] array, T element) {
if (array == null) return -1;
for (int i = 0; i < array.length; i++) {
if (Objects.equals(array[i], element)) {
return i;
}
}
return -1;
}
public static <T extends Comparable<T>> T max(T[] array) {
if (array == null || array.length == 0) {
throw new IllegalArgumentException("Array cannot be null or empty");
}
T max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] != null && array[i].compareTo(max) > 0) {
max = array[i];
}
}
return max;
}
public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
List<T> result = new ArrayList<>();
for (T element : list) {
if (predicate.test(element)) {
result.add(element);
}
}
return result;
}
}
Performance Considerations#
Generic Collections Performance#
import java.util.*;
public class GenericPerformanceDemo {
public static void demonstrateAutoboxing() {
long startTime, endTime;
// Test with raw ArrayList (boxing overhead)
List rawList = new ArrayList();
startTime = System.nanoTime();
for (int i = 0; i < 1000000; i++) {
rawList.add(i); // Boxing: int -> Integer
}
endTime = System.nanoTime();
System.out.println("Raw list (with boxing): " + (endTime - startTime) + " ns");
// Test with generic ArrayList
List<Integer> genericList = new ArrayList<>();
startTime = System.nanoTime();
for (int i = 0; i < 1000000; i++) {
genericList.add(i); // Boxing: int -> Integer
}
endTime = System.nanoTime();
System.out.println("Generic list: " + (endTime - startTime) + " ns");
// Test with primitive array (no boxing)
int[] primitiveArray = new int[1000000];
startTime = System.nanoTime();
for (int i = 0; i < 1000000; i++) {
primitiveArray[i] = i; // No boxing
}
endTime = System.nanoTime();
System.out.println("Primitive array: " + (endTime - startTime) + " ns");
}
public static void main(String[] args) {
demonstrateAutoboxing();
}
}
Common Generic Pitfalls#
1. Generic Array Creation#
public class GenericPitfalls {
// This won't compile - cannot create generic arrays
// T[] array = new T[10]; // Compilation error
// Workaround 1: Use Object array and cast (unsafe)
@SuppressWarnings("unchecked")
public static <T> T[] createArray(int size) {
return (T[]) new Object[size];
}
// Workaround 2: Use reflection (safer but requires Class parameter)
public static <T> T[] createArrayReflection(Class<T> type, int size) {
return (T[]) Array.newInstance(type, size);
}
// Best practice: Use List instead of array
public static <T> List<T> createList(int initialCapacity) {
return new ArrayList<>(initialCapacity);
}
}
2. Static Context and Generics#
public class StaticGenericPitfall<T> {
// This won't compile - static context can't access type parameters
// private static T staticField; // Compilation error
// This works - static generic method
public static <U> void staticGenericMethod(U parameter) {
System.out.println("Parameter: " + parameter);
}
}
Summary#
Key Concepts Covered#
- Generic Classes and Interfaces: Type-safe containers and contracts
- Generic Methods: Methods that work with different types
- Bounded Type Parameters: Restricting generic types
- Wildcards: Flexible type handling with ?, extends, and super
- Type Erasure: Runtime behavior of generics
- PECS Principle: Producer Extends, Consumer Super
- Best Practices: Writing clean, safe generic code
Benefits of Generics#
- Type Safety: Compile-time error detection
- Code Reusability: Same code works with different types
- Performance: Elimination of casting overhead
- Clarity: Self-documenting code
When to Use Generics#
- Collections and data structures
- Utility methods that work with multiple types
- APIs that need type safety
- Framework and library development
Next Lecture Preview#
Lecture 39: Lambda Expressions and Functional Interfaces#
- Introduction to Functional Programming in Java
- Lambda Expression Syntax
- Method References
- Built-in Functional Interfaces
- Custom Functional Interfaces
- Functional Programming Patterns
Preparation#
- Review interfaces and anonymous classes
- Practice with generic collections
- Understand the concept of functions as first-class objects
Thank You!#
Questions and Discussion#
- How do generics improve code safety and maintainability?
- When would you choose wildcards over specific type parameters?
- What are the trade-offs between generic collections and arrays?
Resources for Further Learning#
- Oracle Java Generics Tutorial
- Effective Java by Joshua Bloch (Chapter on Generics)
- Practice generic programming with different data structures
Next: Lambda Expressions and Functional Programming