Java Generics Made Simple
Published by Brayan K
Learn how to write type-safe, reusable code with Java generics.
Master type safety, generic classes, methods, wildcards, and the PECS rule with clear examples
Java Generics can look confusing at first — angle brackets, wildcards, <T>, <E>, <K, V>, and strange errors like "incompatible types" that make your head spin.
But the truth is:
👉 Generics are one of the most powerful features in Java.
They help you write safer, cleaner, reusable code — and avoid runtime errors that would otherwise break your entire program.
1. What Are Java Generics?
Java Generics allow you to create classes, methods, and interfaces that work with any data type — while still keeping type safety.
Before Generics (Java 1.4 days):
List list = new ArrayList();
list.add("Hello");
list.add(123); // No compile error!You had no type checking. A list could store anything, leading to runtime errors:
String s = (String) list.get(1); // ClassCastException 💥List<String> names = new ArrayList<>();
names.add("Alice");
// names.add(123); ❌ compile-time error!Generics catch type errors early.
This makes your apps:
- ✔ More predictable
2. The Most Common Generic Types You'll See
Java doesn't force specific letters, but conventionally developers use:
| Symbol | Meaning |
|---|---|
| T | Type |
| E | Element |
| K | Key |
| V | Value |
| N | Number |
| R | Result |
These are just placeholders for actual types like:
- List<String>
- Map<String, Integer>
- Optional<Double>
3. Generic Classes (Simple Example)
Let's say we want a class that stores a pair of values: key + value.
class Pair {
Object key;
Object value;
}But this is unsafe — you must cast everything.
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; }
}Pair<String, Integer> age = new Pair<>("Boopie", 16);- ✔ No casting
- ✔ Reusable for many types
4. Generic Methods (Very Common in Real Projects)
You can add generics to individual methods:
public <T> void print(T item) {
System.out.println(item);
}Call it with any type:
print("Hello");
print(123);
print(new Date());The compiler automatically infers the type.
5. Wildcards (?) — The Most Confusing Part Made Easy
Wildcards help when you don't care about the exact type.
? means "I don't know the type, and I don't care."
List<?> list = new ArrayList<String>();You can read from the list but cannot add to it (except null).
1. Upper Bound – ? extends Type
Accepts Type or any of its subclasses.
List<? extends Number> numbers- List<Integer>
- List<Double>
Use it when you only need to read.
2. Lower Bound – ? super Type
Accepts Type or its superclasses.
List<? super Integer> ints- List<Number>
- List<Object>
Use it when you want to add items.
⭐ The Golden Rule (PECS)
Producer Extends, Consumer Super
- → If data is coming OUT → use extends
- → If data is going IN → use super
6. Real-World Examples of Generics
One of the biggest reasons generics exist:
List<String> users = new ArrayList<>();
Map<String, Integer> scores = new HashMap<>();To avoid null pointer exceptions:
Optional<User> userComparator<String>
Comparable<Integer>4. Custom data structures
Stacks, queues, trees, graphs — all use generics.
7. Common Mistakes Beginners Make
❌ Mistake 1: Using raw types
List list = new ArrayList(); // ❌ Don't do thisAlways avoid raw types. Use:
List<String> list = new ArrayList<>(); // ✅❌ Mistake 2: Thinking generics exist at runtime
Java uses type erasure:
- Generics exist only at compile-time
- JVM does not know about them
This is why you cannot do:
if (list instanceof List<String>) // ❌❌ Mistake 3: Overusing wildcards
Most beginners use ? too often.
If you can be specific, use:
List<String> // ✅List<?> // Use only when necessary8. Final Summary (Everything You Learned)
In just 8 minutes, you now understand:
- What generics are
- Why they make Java safer and cleaner
- How generic classes & methods work
- What wildcards mean (?, extends, super)
- Real-world uses (Collections, Optional, Comparators)
- Common mistakes to avoid
Generics can seem confusing at first, but once you grasp them, they transform the way you write Java — making your code more reusable, scalable, and professional.
Related articles
- Java Collections Framework: A Deep Dive — Master Lists, Sets, Maps, Queues and their real-world use cases. Learn ArrayList, HashMap, TreeSet, PriorityQueue, performance comparisons, and best practices.
- C++ vs Java: Which Should You Learn First? — A detailed comparison of C++ and Java to help you decide which language is the best fit for your goals and career path.