জেনেরিকস (Generics)

public class Main {
    // T is a placeholder — it can be ANY type
    static class Box<T> {
        private T item;

        void put(T item) {
            this.item = item;
            System.out.println("Put in: " + item);
        }

        T get() {
            return item;
        }

        boolean isEmpty() {
            return item == null;
        }
    }

    public static void main(String[] args) {
        // A box for Strings
        Box<String> nameBox = new Box<>();
        nameBox.put("Hello World");
        String name = nameBox.get();  // no casting needed!
        System.out.println("Got: " + name);

        // A box for Integers
        Box<Integer> numBox = new Box<>();
        numBox.put(42);
        int number = numBox.get();  // autoUnboxing
        System.out.println("Got: " + number);

        // A box for Doubles
        Box<Double> priceBox = new Box<>();
        priceBox.put(9.99);
        System.out.println("Got: " + priceBox.get());

        // numBox.put("oops");  // COMPILE ERROR! Type safety!
    }
}

Put in: Hello World
Got: Hello World
Put in: 42
Got: 42
Put in: 9.99
Got: 9.99

import java.util.Arrays;
import java.util.List;

public class Main {
    // Generic method — works with any array type
    static <T> void printArray(T[] array) {
        System.out.print("[ ");
        for (T item : array) {
            System.out.print(item + " ");
        }
        System.out.println("]");
    }

    // Bounded type — T must be a Number or subclass
    static <T extends Number> double sum(T[] numbers) {
        double total = 0;
        for (T num : numbers) {
            total += num.doubleValue();  // works because T is a Number
        }
        return total;
    }

    // Wildcard — accept list of any Number subtype
    static double sumList(List<? extends Number> list) {
        double total = 0;
        for (Number n : list) {
            total += n.doubleValue();
        }
        return total;
    }

    public static void main(String[] args) {
        String[] names = {"Anika", "Rafi", "Sadia"};
        Integer[] nums = {1, 2, 3, 4, 5};
        Double[] prices = {4.99, 2.50, 8.75};

        printArray(names);
        printArray(nums);
        printArray(prices);

        System.out.println("Sum of ints: " + sum(nums));
        System.out.println("Sum of doubles: " + sum(prices));

        // Wildcard in action
        List<Integer> intList = Arrays.asList(10, 20, 30);
        List<Double> dblList = Arrays.asList(1.5, 2.5, 3.5);
        System.out.println("Int list sum: " + sumList(intList));
        System.out.println("Dbl list sum: " + sumList(dblList));
    }
}

[ Anika Rafi Sadia ]
[ 1 2 3 4 5 ]
[ 4.99 2.50 8.75 ]
Sum of ints: 15.0
Sum of doubles: 16.24
Int list sum: 60.0
Dbl list sum: 7.5

public class Main {
    // A Pair holds two values of potentially different types
    static class Pair<K, V> {
        private K key;
        private V value;

        Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }

        K getKey() { return key; }
        V getValue() { return value; }

        @Override
        public String toString() {
            return key + " -> " + value;
        }
    }

    public static void main(String[] args) {
        Pair<String, Integer> age = new Pair<>("Anika", 25);
        Pair<String, String> color = new Pair<>("Sky", "Blue");
        Pair<Integer, Boolean> evenCheck = new Pair<>(7, false);

        System.out.println(age);
        System.out.println(color);
        System.out.println(evenCheck);

        // Type-safe access
        String name = age.getKey();
        int years = age.getValue();
        System.out.println(name + " is " + years + " years old");
    }
}

Anika -> 25
Sky -> Blue
7 -> false
Alice is 25 years old