GENERICS (Java)
๐ง GENERICS (Java) โ MINI STUDY GUIDE
๐น 1. What are Generics?
Definition (simple lang):
Generics allow you to write flexible and reusable code that works with different data types.
๐ก This part is important kasi ito โyung pinaka-purpose ng generics.
๐ Instead of writing:
String, Integer, Double (separate codes)๐ You write ONE code that works for ALL types ๐ฏ
๐ง Real-Life Analogy:
Think of a container ๐ฆ
Without generics โ labeled for ONE type only
With generics โ can hold ANY type depending on need
๐น 2. Generic Types (Core Concept)
Generics use angle brackets < >
class Gen<T>๐ T = placeholder (type parameter)
๐ From page 1:
T represents any type
Actual type is assigned when object is created
๐ฅ Common Type Parameter Names
Symbol | Meaning |
|---|---|
T | Type |
E | Element |
K | Key |
V | Value |
N | Number |
๐ก In short: T is just a placeholder, parang variable name for types.
๐น 3. Generic Class Example
From page 1โ2:
class Gen<T> {
private T data;
public void setValue(T dt) {
data = dt;
}
public T getValue() {
return data;
}
}๐ง Breakdown (easy mode):
T dataโ data type depends on TsetValue(T dt)โ accepts any typegetValue()โ returns that same type
๐ Meaning:
If T = Integer โ everything becomes Integer
If T = String โ everything becomes String
๐น 4. Creating Generic Objects
Gen<Integer> iData = new Gen<>();
Gen<String> sData = new Gen<>();๐ From page 2:
Left side type is optional innew Gen<>()
โก Example Output Idea:
iData.setValue(1);
sData.setValue("One");๐ Works for different types using same code ๐ฅ
๐น 5. Multiple Type Parameters
You can use more than one type
class Gen<T, T2>๐ง Example:
Gen<Integer, String> mixData = new Gen<>();๐ Meaning:
T = Integer
T2 = String
๐ก Parang pair systemโdalawang data types in one class.
๐น 6. showType() Method (Type Checking)
From page 2:
data.getClass().getName()๐ Used to display actual type of T
๐ง Simple Explanation:
getClass()โ gets object typegetName()โ converts to string
๐ Output example:
Type of T is java.lang.Integer๐น 7. Wildcards (SUPER IMPORTANT ๐ฅ)
๐ Wildcards = unknown type
Symbol: ?
๐น 7.1 Unbounded Wildcard
List<?>๐ Accepts ANY type
๐ From page 3:
Works for all lists (Integer, String, etc.)
๐ก Example use:
Printing elements regardless of type
๐น 7.2 Upper-Bounded Wildcard
List<? extends Number>๐ Accepts:
Number
Subclasses (Integer, Double, etc.)
๐ก Use case:
When you ONLY want numbers
๐น 7.3 Lower-Bounded Wildcard
List<? super Integer>๐ Accepts:
Integer
Superclasses (Number, Object)
๐ From page 4:
Useful when inserting values
๐น 8. Wildcard Comparison
Type | Syntax | Meaning |
|---|---|---|
Unbounded |
| Any type |
Upper-bounded |
| Type or subclass |
Lower-bounded |
| Type or superclass |
๐น 9. Why Use Generics?
โ Advantages
Code reuse ๐
Type safety ๐
Less errors
Cleaner code
โ Without Generics
Need multiple versions of same code
More bugs
Hard to maintain
๐น 10. Real-Life Programming Insight
๐ Imagine:
Youโre building a system that handles:
Users
Orders
Products
Without generics:
โ Separate code for each
With generics:
โ
One reusable system
๐ก In short, generics = โwrite once, use everywhereโ
๐ง QUICK SUMMARY (Memory Mode)
๐ฅ Core Idea:
Generics = flexible code for different data types
๐งฉ Memory Tricks
1. T = Temporary Type
๐ Placeholder lang siya
2. 3 Types of Wildcards
๐ UE-SU Rule
Unbounded =
<?>Extends = upper bound
Super = lower bound
3. Generic Formula
๐ โClass + <T> = reusable codeโ
4. Main Benefit
๐ โWrite once, reuse foreverโ
๐ง FINAL RECAP (Super Simple)
๐ Generics = flexible classes
๐ T = placeholder type
๐ < > = defines type
๐ ? = unknown type
๐ extends = restrict to subclass
๐ super = restrict to superclass