MACRO NEPAL
Generics Introduction in Java
awiskar acharya
October 30, 2025
9:43 am

Table of Contents

  1. What are Generics?
  2. Why Use Generics?
  3. Generic Classes
  4. Generic Methods
  5. Generic Interfaces
  6. Type Parameters Naming Conventions
  7. Bounded Type Parameters
  8. Wildcards
  9. Type Erasure
  10. Best Practices
  11. Common Examples
  12. Complete Examples

What are Generics?

Generics enable types (classes and interfaces) to be parameters when defining classes, interfaces, and methods. They provide stronger type checks at compile time and eliminate the need for casting.

Before Generics (Java 1.4 and earlier):

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); // Requires explicit casting

With Generics (Java 5+):

List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0); // No casting needed

Why Use Generics?

Benefits:

  1. Type Safety: Compile-time type checking
  2. Eliminates Casting: No need for explicit type casting
  3. Code Reusability: Write once, use with different types
  4. Better Readability: Clear about what type of objects are stored

Problem Without Generics:

import java.util.*;
public class WithoutGenerics {
public static void main(String[] args) {
// Without generics - can add any type
List list = new ArrayList();
list.add("String");
list.add(123); // Integer
list.add(new Date()); // Date object
// Runtime ClassCastException possible
String str = (String) list.get(1); // Throws ClassCastException!
}
}

Solution With Generics:

import java.util.*;
public class WithGenerics {
public static void main(String[] args) {
// With generics - type safe
List<String> list = new ArrayList<>();
list.add("String");
// list.add(123); // Compile-time error!
// list.add(new Date()); // Compile-time error!
String str = list.get(0); // No casting needed
}
}

Generic Classes

Basic Generic Class:

// Generic class with single type parameter
class Box<T> {
private T content;
public void setContent(T content) {
this.content = content;
}
public T getContent() {
return content;
}
@Override
public String toString() {
return "Box containing: " + content;
}
}
public class GenericClassExample {
public static void main(String[] args) {
// Box for String
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello Generics!");
System.out.println(stringBox);
// Box for Integer
Box<Integer> integerBox = new Box<>();
integerBox.setContent(42);
System.out.println(integerBox);
// Box for custom object
Box<Date> dateBox = new Box<>();
dateBox.setContent(new Date());
System.out.println(dateBox);
}
}

Output:

Box containing: Hello Generics!
Box containing: 42
Box containing: Wed Jan 10 14:30:00 IST 2024

Multiple Type Parameters:

// Generic class with multiple type parameters
class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
public void setKey(K key) { this.key = key; }
public void setValue(V value) { this.value = value; }
@Override
public String toString() {
return "Pair{key=" + key + ", value=" + value + "}";
}
}
public class MultipleTypeParameters {
public static void main(String[] args) {
// String-Integer pair
Pair<String, Integer> nameAge = new Pair<>("Alice", 25);
System.out.println(nameAge);
// Integer-String pair
Pair<Integer, String> idName = new Pair<>(101, "Bob");
System.out.println(idName);
// String-String pair
Pair<String, String> countryCapital = new Pair<>("France", "Paris");
System.out.println(countryCapital);
// Custom types
Pair<String, List<Integer>> scores = new Pair<>("Math", Arrays.asList(85, 90, 78));
System.out.println(scores);
}
}

Output:

Pair{key=Alice, value=25}
Pair{key=101, value=Bob}
Pair{key=France, value=Paris}
Pair{key=Math, value=[85, 90, 78]}

Generic Methods

Basic Generic Methods:

public class GenericMethods {
// Generic method in non-generic class
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.print(element + " ");
}
System.out.println();
}
// Generic method with multiple type parameters
public static <T, U> void printPair(T first, U second) {
System.out.println("First: " + first + ", Second: " + second);
}
// Generic method returning generic type
public static <T> T getFirstElement(T[] array) {
if (array == null || array.length == 0) {
return null;
}
return array[0];
}
public static void main(String[] args) {
// Using generic methods with different types
Integer[] intArray = {1, 2, 3, 4, 5};
String[] strArray = {"A", "B", "C", "D"};
Double[] doubleArray = {1.1, 2.2, 3.3};
System.out.print("Integer array: ");
printArray(intArray);
System.out.print("String array: ");
printArray(strArray);
System.out.print("Double array: ");
printArray(doubleArray);
// Using multiple type parameters
printPair("Hello", 42);
printPair(3.14, "Pi");
printPair(true, new Date());
// Getting first element
System.out.println("First string: " + getFirstElement(strArray));
System.out.println("First integer: " + getFirstElement(intArray));
}
}

Output:

Integer array: 1 2 3 4 5 
String array: A B C D 
Double array: 1.1 2.2 3.3 
First: Hello, Second: 42
First: 3.14, Second: Pi
First: true, Second: Wed Jan 10 14:30:00 IST 2024
First string: A
First integer: 1

Generic Interfaces

Generic Interface Examples:

// Generic interface
interface Repository<T> {
void save(T entity);
T findById(int id);
List<T> findAll();
void delete(int id);
}
// Implementation for User
class UserRepository implements Repository<User> {
private List<User> users = new ArrayList<>();
private int nextId = 1;
@Override
public void save(User user) {
user.setId(nextId++);
users.add(user);
}
@Override
public User findById(int id) {
return users.stream()
.filter(user -> user.getId() == id)
.findFirst()
.orElse(null);
}
@Override
public List<User> findAll() {
return new ArrayList<>(users);
}
@Override
public void delete(int id) {
users.removeIf(user -> user.getId() == id);
}
}
// Implementation for Product
class ProductRepository implements Repository<Product> {
private Map<Integer, Product> products = new HashMap<>();
private int nextId = 1;
@Override
public void save(Product product) {
product.setId(nextId);
products.put(nextId++, product);
}
@Override
public Product findById(int id) {
return products.get(id);
}
@Override
public List<Product> findAll() {
return new ArrayList<>(products.values());
}
@Override
public void delete(int id) {
products.remove(id);
}
}
// Supporting classes
class User {
private int id;
private String name;
private String email;
public User(String name, String email) {
this.name = name;
this.email = email;
}
// Getters and setters
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getName() { return name; }
public String getEmail() { return email; }
@Override
public String toString() {
return String.format("User{id=%d, name='%s', email='%s'}", id, name, email);
}
}
class Product {
private int id;
private String name;
private double price;
public Product(String name, double price) {
this.name = name;
this.price = price;
}
// Getters and setters
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getName() { return name; }
public double getPrice() { return price; }
@Override
public String toString() {
return String.format("Product{id=%d, name='%s', price=$%.2f}", id, name, price);
}
}
public class GenericInterfaceExample {
public static void main(String[] args) {
// User repository
Repository<User> userRepo = new UserRepository();
userRepo.save(new User("Alice", "[email protected]"));
userRepo.save(new User("Bob", "[email protected]"));
System.out.println("All users:");
userRepo.findAll().forEach(System.out::println);
// Product repository
Repository<Product> productRepo = new ProductRepository();
productRepo.save(new Product("Laptop", 999.99));
productRepo.save(new Product("Mouse", 25.99));
System.out.println("\nAll products:");
productRepo.findAll().forEach(System.out::println);
// Find by ID
System.out.println("\nUser with ID 1: " + userRepo.findById(1));
System.out.println("Product with ID 2: " + productRepo.findById(2));
}
}

Output:

All users:
User{id=1, name='Alice', email='[email protected]'}
User{id=2, name='Bob', email='[email protected]'}
All products:
Product{id=1, name='Laptop', price=$999.99}
Product{id=2, name='Mouse', price=$25.99}
User with ID 1: User{id=1, name='Alice', email='[email protected]'}
Product with ID 2: Product{id=2, name='Mouse', price=$25.99}

Type Parameters Naming Conventions

Standard Naming Conventions:

  • E - Element (used extensively by Java Collections Framework)
  • K - Key
  • N - Number
  • T - Type
  • V - Value
  • S, U, V - 2nd, 3rd, 4th types

Examples:

// Following naming conventions
class Container<T> { }                    // Single type
class Pair<K, V> { }                     // Key-Value pair
class Calculator<N extends Number> { }   // Number type
class Processor<E> { }                   // Element type
// Self-referential generic type
class Node<T> {
private T data;
private Node<T> next;  // Same type parameter
public Node(T data) {
this.data = data;
}
public T getData() { return data; }
public Node<T> getNext() { return next; }
public void setNext(Node<T> next) { this.next = next; }
}

Bounded Type Parameters

Upper Bounded Type Parameters:

import java.util.*;
// Bounded type parameter - only accepts Number and its subclasses
class Statistics<T extends Number> {
private List<T> numbers;
public Statistics() {
numbers = new ArrayList<>();
}
public void addNumber(T number) {
numbers.add(number);
}
public double getAverage() {
if (numbers.isEmpty()) {
return 0.0;
}
double sum = 0.0;
for (T number : numbers) {
sum += number.doubleValue(); // Can call Number methods
}
return sum / numbers.size();
}
public T getMax() {
if (numbers.isEmpty()) {
return null;
}
T max = numbers.get(0);
for (T number : numbers) {
if (number.doubleValue() > max.doubleValue()) {
max = number;
}
}
return max;
}
public List<T> getNumbers() {
return new ArrayList<>(numbers);
}
}
public class BoundedTypesExample {
public static void main(String[] args) {
// Works with Integer (subclass of Number)
Statistics<Integer> intStats = new Statistics<>();
intStats.addNumber(10);
intStats.addNumber(20);
intStats.addNumber(30);
System.out.println("Integer stats: " + intStats.getNumbers());
System.out.println("Average: " + intStats.getAverage());
System.out.println("Max: " + intStats.getMax());
// Works with Double (subclass of Number)
Statistics<Double> doubleStats = new Statistics<>();
doubleStats.addNumber(15.5);
doubleStats.addNumber(25.7);
doubleStats.addNumber(35.2);
System.out.println("\nDouble stats: " + doubleStats.getNumbers());
System.out.println("Average: " + doubleStats.getAverage());
System.out.println("Max: " + doubleStats.getMax());
// Won't compile - String is not a subclass of Number
// Statistics<String> stringStats = new Statistics<>(); // Compile error!
}
}

Output:

Integer stats: [10, 20, 30]
Average: 20.0
Max: 30
Double stats: [15.5, 25.7, 35.2]
Average: 25.466666666666665
Max: 35.2

Multiple Bounds:

interface Loggable {
void log();
}
interface Serializable {
void serialize();
}
class Document implements Loggable, Serializable {
private String content;
public Document(String content) {
this.content = content;
}
@Override
public void log() {
System.out.println("Logging document: " + content);
}
@Override
public void serialize() {
System.out.println("Serializing document: " + content);
}
@Override
public String toString() {
return "Document: " + content;
}
}
// Multiple bounds - T must implement both interfaces
class Processor<T extends Loggable & Serializable> {
private T item;
public Processor(T item) {
this.item = item;
}
public void process() {
item.log();
item.serialize();
System.out.println("Processing: " + item);
}
}
public class MultipleBoundsExample {
public static void main(String[] args) {
Document doc = new Document("Important data");
Processor<Document> processor = new Processor<>(doc);
processor.process();
}
}

Output:

Logging document: Important data
Serializing document: Important data
Processing: Document: Important data

Wildcards

Upper Bounded Wildcards:

import java.util.*;
public class UpperBoundedWildcards {
// Accepts List of any type that is Number or subclass of Number
public static double sumOfList(List<? extends Number> list) {
double sum = 0.0;
for (Number number : list) {
sum += number.doubleValue();
}
return sum;
}
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3, 4.4, 5.5);
List<Float> floats = Arrays.asList(1.1f, 2.2f, 3.3f);
System.out.println("Sum of integers: " + sumOfList(integers));
System.out.println("Sum of doubles: " + sumOfList(doubles));
System.out.println("Sum of floats: " + sumOfList(floats));
// Won't compile - String is not a Number
// List<String> strings = Arrays.asList("A", "B", "C");
// System.out.println(sumOfList(strings)); // Compile error!
}
}

Output:

Sum of integers: 15.0
Sum of doubles: 16.5
Sum of floats: 6.6000001430511475

Lower Bounded Wildcards:

import java.util.*;
public class LowerBoundedWildcards {
// Accepts List of Integer or superclasses of Integer
public static void addNumbers(List<? super Integer> list) {
for (int i = 1; i <= 5; i++) {
list.add(i);
}
}
public static void main(String[] args) {
List<Integer> integerList = new ArrayList<>();
List<Number> numberList = new ArrayList<>();
List<Object> objectList = new ArrayList<>();
addNumbers(integerList);
addNumbers(numberList);
addNumbers(objectList);
System.out.println("Integer list: " + integerList);
System.out.println("Number list: " + numberList);
System.out.println("Object list: " + objectList);
// Won't compile - String is not a superclass of Integer
// List<String> stringList = new ArrayList<>();
// addNumbers(stringList); // Compile error!
}
}

Output:

Integer list: [1, 2, 3, 4, 5]
Number list: [1, 2, 3, 4, 5]
Object list: [1, 2, 3, 4, 5]

Unbounded Wildcards:

import java.util.*;
public class UnboundedWildcards {
// Accepts List of any type
public static void printList(List<?> list) {
for (Object element : list) {
System.out.print(element + " ");
}
System.out.println();
}
public static int countElements(List<?> list) {
return list.size();
}
public static void main(String[] args) {
List<String> strings = Arrays.asList("A", "B", "C");
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
System.out.print("Strings: ");
printList(strings);
System.out.print("Integers: ");
printList(integers);
System.out.print("Doubles: ");
printList(doubles);
System.out.println("Count of strings: " + countElements(strings));
System.out.println("Count of integers: " + countElements(integers));
System.out.println("Count of doubles: " + countElements(doubles));
}
}

Output:

Strings: A B C 
Integers: 1 2 3 4 5 
Doubles: 1.1 2.2 3.3 
Count of strings: 3
Count of integers: 5
Count of doubles: 3

Type Erasure

How Generics Work at Runtime:

import java.util.*;
import java.lang.reflect.*;
public class TypeErasureExample {
public static void main(String[] args) {
// At compile time - different types
List<String> stringList = new ArrayList<>();
List<Integer> integerList = new ArrayList<>();
// At runtime - both are just List (type erasure)
System.out.println("stringList class: " + stringList.getClass());
System.out.println("integerList class: " + integerList.getClass());
System.out.println("Same class? " + 
(stringList.getClass() == integerList.getClass()));
// Type information is not available at runtime
try {
Method addMethod = ArrayList.class.getMethod("add", Object.class);
System.out.println("Method parameter type: " + 
addMethod.getParameterTypes()[0]);
} catch (Exception e) {
e.printStackTrace();
}
}
}

Output:

stringList class: class java.util.ArrayList
integerList class: class java.util.ArrayList
Same class? true
Method parameter type: class java.lang.Object

Best Practices

1. Use Generic Types Instead of Raw Types:

// ✅ Good - type safe
List<String> names = new ArrayList<>();
Map<String, Integer> scores = new HashMap<>();
// ❌ Bad - raw types
List names = new ArrayList(); // Raw type warning
Map scores = new HashMap();   // Raw type warning

2. Prefer Generic Methods:

// ✅ Good - generic method
public static <T> T getFirst(List<T> list) {
return list.isEmpty() ? null : list.get(0);
}
// ❌ Bad - uses raw types
public static Object getFirstRaw(List list) {
return list.isEmpty() ? null : list.get(0);
}

3. Use Bounded Wildcards for Maximum Flexibility:

// ✅ Good - accepts any List of Number or subclass
public static double sum(List<? extends Number> numbers) {
return numbers.stream().mapToDouble(Number::doubleValue).sum();
}
// ❌ Less flexible - only accepts exact List<Number>
public static double sumExact(List<Number> numbers) {
return numbers.stream().mapToDouble(Number::doubleValue).sum();
}

4. Avoid Using Generic Array Creation:

// ❌ Bad - generic array creation
// T[] array = new T[10]; // Compile error!
// ✅ Good - use ArrayList or other collection
List<T> list = new ArrayList<>();
// ✅ Alternative - use Array.newInstance with Class<T>
public static <T> T[] createArray(Class<T> clazz, int size) {
@SuppressWarnings("unchecked")
T[] array = (T[]) Array.newInstance(clazz, size);
return array;
}

Common Examples

1. Generic Stack Implementation:

import java.util.*;
class GenericStack<T> {
private List<T> elements;
public GenericStack() {
elements = new ArrayList<>();
}
public void push(T element) {
elements.add(element);
}
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;
}
}
public class StackExample {
public static void main(String[] args) {
// String stack
GenericStack<String> stringStack = new GenericStack<>();
stringStack.push("First");
stringStack.push("Second");
stringStack.push("Third");
System.out.println(stringStack);
System.out.println("Popped: " + stringStack.pop());
System.out.println("Top: " + stringStack.peek());
System.out.println(stringStack);
// Integer stack
GenericStack<Integer> intStack = new GenericStack<>();
intStack.push(10);
intStack.push(20);
intStack.push(30);
System.out.println("\n" + intStack);
System.out.println("Popped: " + intStack.pop());
System.out.println("Size: " + intStack.size());
}
}

Output:

Stack: [First, Second, Third]
Popped: Third
Top: Second
Stack: [First, Second]
Stack: [10, 20, 30]
Popped: 30
Size: 2

2. Generic Utility Methods:

import java.util.*;
public class GenericUtilities {
// Swap elements in an array
public static <T> void swap(T[] array, int i, int j) {
T temp = array[i];
array[i] = array[j];
array[j] = temp;
}
// Find maximum element in collection
public static <T extends Comparable<T>> T findMax(Collection<T> collection) {
if (collection.isEmpty()) {
throw new IllegalArgumentException("Collection is empty");
}
T max = null;
for (T element : collection) {
if (max == null || element.compareTo(max) > 0) {
max = element;
}
}
return max;
}
// Convert array to list
public static <T> List<T> arrayToList(T[] array) {
return new ArrayList<>(Arrays.asList(array));
}
// Check if array contains element
public static <T> boolean contains(T[] array, T element) {
for (T item : array) {
if (Objects.equals(item, element)) {
return true;
}
}
return false;
}
public static void main(String[] args) {
// Swap test
Integer[] numbers = {1, 2, 3, 4, 5};
System.out.println("Before swap: " + Arrays.toString(numbers));
swap(numbers, 1, 3);
System.out.println("After swap: " + Arrays.toString(numbers));
// Find max test
List<Integer> numberList = Arrays.asList(5, 2, 8, 1, 9, 3);
System.out.println("Max number: " + findMax(numberList));
List<String> stringList = Arrays.asList("apple", "zebra", "banana", "cherry");
System.out.println("Max string: " + findMax(stringList));
// Array to list test
String[] stringArray = {"A", "B", "C"};
List<String> convertedList = arrayToList(stringArray);
System.out.println("Converted list: " + convertedList);
// Contains test
System.out.println("Contains 'B': " + contains(stringArray, "B"));
System.out.println("Contains 'X': " + contains(stringArray, "X"));
}
}

Output:

Before swap: [1, 2, 3, 4, 5]
After swap: [1, 4, 3, 2, 5]
Max number: 9
Max string: zebra
Converted list: [A, B, C]
Contains 'B': true
Contains 'X': false

Complete Examples

Complete Working Example:

import java.util.*;
import java.util.function.Predicate;
public class GenericsCompleteExample {
public static void main(String[] args) {
System.out.println("=== Generics Complete Example ===\n");
// Example 1: Generic Container
genericContainerExample();
// Example 2: Generic Repository Pattern
genericRepositoryExample();
// Example 3: Generic Algorithms
genericAlgorithmsExample();
// Example 4: Advanced - Generic Builder
genericBuilderExample();
}
public static void genericContainerExample() {
System.out.println("1. Generic Container Example:");
// Generic container for different types
Container<String> stringContainer = new Container<>("Hello World");
Container<Integer> intContainer = new Container<>(42);
Container<Date> dateContainer = new Container<>(new Date());
System.out.println("String container: " + stringContainer);
System.out.println("Integer container: " + intContainer);
System.out.println("Date container: " + dateContainer);
// Generic pair
Pair<String, Integer> nameAge = new Pair<>("Alice", 25);
Pair<Integer, String> idName = new Pair<>(101, "Bob");
System.out.println("Name-Age pair: " + nameAge);
System.out.println("ID-Name pair: " + idName);
System.out.println();
}
public static void genericRepositoryExample() {
System.out.println("2. Generic Repository Pattern:");
// User repository
CrudRepository<User> userRepo = new InMemoryCrudRepository<>();
userRepo.save(new User(1, "Alice", "[email protected]"));
userRepo.save(new User(2, "Bob", "[email protected]"));
userRepo.save(new User(3, "Charlie", "[email protected]"));
System.out.println("All users:");
userRepo.findAll().forEach(System.out::println);
System.out.println("User with ID 2: " + userRepo.findById(2));
// Product repository
CrudRepository<Product> productRepo = new InMemoryCrudRepository<>();
productRepo.save(new Product(1, "Laptop", 999.99));
productRepo.save(new Product(2, "Mouse", 25.99));
System.out.println("\nAll products:");
productRepo.findAll().forEach(System.out::println);
System.out.println();
}
public static void genericAlgorithmsExample() {
System.out.println("3. Generic Algorithms Example:");
// Filter example
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> evenNumbers = filter(numbers, n -> n % 2 == 0);
System.out.println("Even numbers: " + evenNumbers);
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
List<String> longNames = filter(names, name -> name.length() > 4);
System.out.println("Long names: " + longNames);
// Map example
List<String> upperCaseNames = map(names, String::toUpperCase);
System.out.println("Uppercase names: " + upperCaseNames);
List<Integer> squaredNumbers = map(numbers, n -> n * n);
System.out.println("Squared numbers: " + squaredNumbers);
System.out.println();
}
public static void genericBuilderExample() {
System.out.println("4. Generic Builder Example:");
// Build different types of objects
Person person = new PersonBuilder()
.withName("John Doe")
.withAge(30)
.withEmail("[email protected]")
.build();
Product product = new ProductBuilder()
.withName("Smartphone")
.withPrice(699.99)
.withCategory("Electronics")
.build();
System.out.println("Built person: " + person);
System.out.println("Built product: " + product);
}
// Generic filter method
public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
List<T> result = new ArrayList<>();
for (T item : list) {
if (predicate.test(item)) {
result.add(item);
}
}
return result;
}
// Generic map method
public static <T, R> List<R> map(List<T> list, java.util.function.Function<T, R> mapper) {
List<R> result = new ArrayList<>();
for (T item : list) {
result.add(mapper.apply(item));
}
return result;
}
}
// Supporting generic classes and interfaces
// 1. Generic Container
class Container<T> {
private T value;
public Container(T value) {
this.value = value;
}
public T getValue() { return value; }
public void setValue(T value) { this.value = value; }
@Override
public String toString() {
return "Container{" + value + "}";
}
}
// 2. Generic Pair
class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
@Override
public String toString() {
return "Pair{" + key + "=" + value + "}";
}
}
// 3. Generic Repository
interface CrudRepository<T> {
void save(T entity);
T findById(int id);
List<T> findAll();
void delete(int id);
}
class InMemoryCrudRepository<T> implements CrudRepository<T> {
private Map<Integer, T> storage = new HashMap<>();
private int nextId = 1;
@Override
public void save(T entity) {
// In real implementation, we'd use reflection to set ID
// For demo, we'll assume entity has setId method
storage.put(nextId++, entity);
}
@Override
public T findById(int id) {
return storage.get(id);
}
@Override
public List<T> findAll() {
return new ArrayList<>(storage.values());
}
@Override
public void delete(int id) {
storage.remove(id);
}
}
// 4. Entity classes
class User {
private int id;
private String name;
private String email;
public User(int id, String name, String email) {
this.id = id;
this.name = name;
this.email = email;
}
// Getters
public int getId() { return id; }
public String getName() { return name; }
public String getEmail() { return email; }
@Override
public String toString() {
return String.format("User{id=%d, name='%s', email='%s'}", id, name, email);
}
}
class Product {
private int id;
private String name;
private double price;
private String category;
public Product(int id, String name, double price) {
this.id = id;
this.name = name;
this.price = price;
}
public Product(int id, String name, double price, String category) {
this.id = id;
this.name = name;
this.price = price;
this.category = category;
}
// Getters
public int getId() { return id; }
public String getName() { return name; }
public double getPrice() { return price; }
public String getCategory() { return category; }
@Override
public String toString() {
return String.format("Product{id=%d, name='%s', price=$%.2f, category='%s'}", 
id, name, price, category);
}
}
// 5. Generic Builder pattern
class Person {
private String name;
private int age;
private String email;
private Person(String name, int age, String email) {
this.name = name;
this.age = age;
this.email = email;
}
@Override
public String toString() {
return String.format("Person{name='%s', age=%d, email='%s'}", name, age, email);
}
// Builder
static class PersonBuilder {
private String name;
private int age;
private String email;
public PersonBuilder withName(String name) {
this.name = name;
return this;
}
public PersonBuilder withAge(int age) {
this.age = age;
return this;
}
public PersonBuilder withEmail(String email) {
this.email = email;
return this;
}
public Person build() {
return new Person(name, age, email);
}
}
}
class ProductBuilder {
private String name;
private double price;
private String category;
public ProductBuilder withName(String name) {
this.name = name;
return this;
}
public ProductBuilder withPrice(double price) {
this.price = price;
return this;
}
public ProductBuilder withCategory(String category) {
this.category = category;
return this;
}
public Product build() {
return new Product(0, name, price, category); // ID would be set by repository
}
}

Expected Output:

=== Generics Complete Example ===
1. Generic Container Example:
String container: Container{Hello World}
Integer container: Container{42}
Date container: Container{Wed Jan 10 14:30:00 IST 2024}
Name-Age pair: Pair{Alice=25}
ID-Name pair: Pair{101=Bob}
2. Generic Repository Pattern:
All users:
User{id=1, name='Alice', email='[email protected]'}
User{id=2, name='Bob', email='[email protected]'}
User{id=3, name='Charlie', email='[email protected]'}
User with ID 2: User{id=2, name='Bob', email='[email protected]'}
All products:
Product{id=1, name='Laptop', price=$999.99, category='null'}
Product{id=2, name='Mouse', price=$25.99, category='null'}
3. Generic Algorithms Example:
Even numbers: [2, 4, 6, 8, 10]
Long names: [Alice, Charlie, David]
Uppercase names: [ALICE, BOB, CHARLIE, DAVID, EVE]
Squared numbers: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
4. Generic Builder Example:
Built person: Person{name='John Doe', age=30, email='[email protected]'}
Built product: Product{id=0, name='Smartphone', price=$699.99, category='Electronics'}

Key Takeaways

  1. Type Safety: Generics provide compile-time type checking
  2. Code Reusability: Write generic code that works with different types
  3. No Casting: Eliminate explicit type casting
  4. Bounded Types: Restrict types that can be used with generics
  5. Wildcards: Provide flexibility with ? extends and ? super
  6. Type Erasure: Generic type information is removed at runtime
  7. Best Practices: Use generic types, avoid raw types, prefer bounded wildcards

Generics are fundamental to modern Java programming and are extensively used in Collections Framework, making code safer, more readable, and reusable.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper