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 T

  • setValue(T dt) โ†’ accepts any type

  • getValue() โ†’ 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 in new 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 type

  • getName() โ†’ 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

<? extends Type>

Type or subclass

Lower-bounded

<? super Type>

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