generics — type parameter আর wildcard দিয়ে টাইপ-নিরাপদ কোড

১ · সমস্যা — সবকিছুর ঝুড়ি আর অনেক দূরে গিয়ে crash

পর্ব ১৩-এ array দেখেছেন: String[]-এ শুধু String রাখা যায়, অন্য কিছু রাখতে চাইলে compiler আপত্তি করে। কিন্তু array-এর আকার স্থির। দরকার মতো বড় হয় এমন তালিকা — ArrayList — Java-তে শুরু থেকেই ছিল। প্রশ্ন হলো, সেই তালিকা কোন টাইপের জিনিস রাখবে? String-এর জন্য একটি StringList, Integer-এর জন্য IntegerList, Student-এর জন্য StudentList — এভাবে লিখলে একই কোড শতবার কপি করতে হতো।

Java 5 (২০০৪)-এর আগে সমাধান ছিল একটিই: তালিকা রাখবে Object. Java-তে সব class-ই Object-এর subclass, তাই যেকোনো জিনিস ঢোকানো যায়। কিন্তু বের করার সময় আপনি পান শুধু একটি Object, আর সেটাকে নিজের হাতে আসল টাইপে cast করতে হয়। নিচের কোডটি আজকের Java-তেও compile হয় (একটি সতর্কবার্তাসহ), তাই পুরোনো ধাঁচটা নিজের চোখে দেখা যায়:

import java.util.*;
class Main {
    public static void main(String[] args) {
        List names = new ArrayList();       // কোন টাইপ? কেউ জানে না
        names.add("Rahim");
        names.add(42);                      // ভুল — কিন্তু compiler চুপ
        for (Object o : names) {
            String s = (String) o;          // এখানে crash
            System.out.println(s.length());
        }
    }
}

Note: Main.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

5
Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
	at Main.main(Main.java:8)

খেয়াল করুন তিনটি জিনিস। প্রথমত, compiler শুধু একটি অস্পষ্ট “Note” দিল, কোনো error নয় — প্রোগ্রাম তৈরি হয়ে গেল। দ্বিতীয়ত, প্রথম নাম “Rahim”-এর দৈর্ঘ্য ৫ ঠিকঠাক ছাপা হলো; ভুলটা ধরা পড়ল লুপের পরের ধাপে। তৃতীয়ত, stack trace আঙুল তুলছে লাইন ৮-এর দিকে, যেখানে cast হচ্ছে — অথচ আসল ভুল লাইন ৬-এ, যেখানে 42 ঢোকানো হয়েছিল। ছোট প্রোগ্রামে দুটো লাইন পাশাপাশি। বড় প্রোগ্রামে add হয়তো এক ফাইলে, এক সপ্তাহ আগে লেখা, আর crash হয় অন্য মডিউলে, গ্রাহকের সামনে।

লেবেলসহ একই কোড — List<String> — লিখলে কী হয়, দেখুন:

List<String> names = new ArrayList<>();   // লাইন ৪
names.add("Rahim");
names.add(42);                              // লাইন ৬

Main.java:6: error: incompatible types: int cannot be converted to String
        names.add(42);
                  ^
Note: Some messages have been simplified; recompile with -Xdiags:verbose to get full output
1 error

ভুলটা এখন ঠিক যেখানে করা হয়েছে, সেখানেই ধরা পড়ল — চলার সময় নয়, compile-এর সময়। আর বের করার সময় cast লাগবে না: String s = names.get(0); লিখলেই চলে, কারণ compiler জানে এই তালিকায় শুধু String আছে। এটাই generics-এর মূল কথা: একটি class বা method একবার লিখুন, অনেক টাইপের সাথে নিরাপদে ব্যবহার করুন, আর টাইপ মিলছে কি না সেটা compiler-কে যাচাই করতে দিন। পর্ব ২০-এ যে parametric polymorphism-এর নাম শুনেছিলেন, Java-তে তার রূপ এটাই।

২ · Generic class — টাইপ যখন একটি parameter

Method-এর parameter একটি মান-এর জায়গা ধরে রাখে: area(double r) — r কত, তা ডাকার সময় ঠিক হয়। Generic class-এ একই কাজ হয় টাইপ-এর জন্য। সবচেয়ে ছোট উদাহরণ — একটি বাক্স, যাতে একটি জিনিস রাখা যায়:

class Box<T> {                      // T = এখনো অজানা কোনো টাইপ
    private T value;
    void set(T value) { this.value = value; }
    T get() { return value; }
}

Box<String> name = new Box<>();    // এখানে T = String
name.set("Ayesha");
String s = name.get();             // cast নেই

Box<Integer> roll = new Box<>();   // এখানে T = Integer
roll.set(17);

Class-এর নামের পরে কৌণিক বন্ধনীর ভেতরের T হলো type parameter — একটি নাম, যা এখনো কোনো আসল টাইপ নয়। ব্যবহার করার সময় যে আসল টাইপ বসানো হয় (String, Integer), তাকে বলে type argument. ঠিক যেমন method-এ “parameter” আর “argument” আলাদা শব্দ। Box<T>-এর মতো class-কে বলে generic class. Box<String>-এ name.set(42) লিখলে আগের মতোই error: incompatible types: int cannot be converted to String.

দুটি type parameter — Pair আর Cache

একটি method থেকে দুটি মান ফেরত দিতে চান — যেমন পরীক্ষার নম্বরের সর্বনিম্ন আর সর্বোচ্চ। পর্ব ২৫-এর record-কেও generic বানানো যায়:

record Pair<A, B>(A first, B second) { }

Pair<Integer, Integer> range = new Pair<>(65, 88);
Pair<String, Double> item  = new Pair<>("চা", 15.0);

একই কাঠামোতে একটি ছোট, টাইপ-নিরাপদ cache — ভেতরে একটি HashMap, বাইরে নিজের নিয়ম (পরে এখানে সীমা, মেয়াদ বা লগ যোগ করা যাবে, বাকি কোড না বদলেই):

class Cache<K, V> {
    private final Map<K, V> map = new HashMap<>();
    V get(K key) { return map.get(key); }
    void put(K key, V value) { map.put(key, value); }
}

Cache<String, Integer> prices = new Cache<>();
prices.put("tea", 15);
prices.put(15, "tea");          // লাইন ১১ — উল্টো ক্রম

Main.java:11: error: incompatible types: int cannot be converted to String
        prices.put(15, "tea");
                   ^
Note: Some messages have been simplified; recompile with -Xdiags:verbose to get full output
1 error

Key আর value উল্টে ফেলা খুব সাধারণ ভুল, আর Object-ভিত্তিক cache-এ এটা নীরবে ঢুকে যেত — পরে get("tea") শুধু null দিত, কেউ বুঝত না কেন।

নামের রীতি — এক অক্ষর, বড় হাতের

Type parameter-এর নাম যেকোনো identifier হতে পারে, কিন্তু Java-র রীতি হলো একটি বড় হাতের অক্ষর — যাতে কোডে দেখেই বোঝা যায় এটা আসল class নয়, একটি parameter:

৩ · Generic method, type inference আর diamond

পুরো class generic না করেও একটিমাত্র method-কে generic করা যায়। Type parameter-টি বসে return টাইপের আগে:

static <T> T firstOrDefault(T[] arr, T def) {
    return arr.length > 0 ? arr[0] : def;
}

String  name = firstOrDefault(new String[0], "অতিথি");     // T = String → "অতিথি"
Integer roll = firstOrDefault(new Integer[]{7, 9}, 0);     // T = Integer → 7

<T> ঘোষণা করে “এই method-এর জন্য একটি টাইপের নাম T”; তারপর T ফেরত দেয়, আর parameter-ও T. এমন method-কে বলে generic method. ডাকার সময় আপনি কোথাও লেখেননি T = String — compiler argument-গুলো দেখে নিজেই বের করে নিয়েছে। একে বলে type inference. দরকার হলে স্পষ্ট করেও বলা যায়, নামের আগে: Main.<String>firstOrDefault(arr, "অতিথি"). বাস্তবে প্রায় কখনো লাগে না।

Generic method আসলে আপনি আগেই ব্যবহার করেছেন: List.of(72, 88, 65), Arrays.asList(...), Collections.max(...) — সবই generic method, আর প্রতিবার compiler টাইপ অনুমান করে নেয়।

Diamond <> — একই কথা দুবার নয়

Java 5-এ লিখতে হতো Map<String, List<Integer>> marks = new HashMap<String, List<Integer>>(); — বাঁ দিকে যা, ডান দিকেও হুবহু তাই। Java 7 থেকে ডান দিকে শুধু ফাঁকা কৌণিক বন্ধনী দিলেই চলে: new HashMap<>(). দেখতে হীরার মতো বলে নাম diamond operator; বাঁ দিকের ঘোষণা থেকে compiler টাইপ বসিয়ে নেয়। Java 10-এর var-এর সাথে মেশালে সাবধান: var list = new ArrayList<>(); লিখলে অনুমান করার মতো কিছু নেই, তাই টাইপ হয় ArrayList<Object> — প্রায় কখনোই যা চান তা নয়। var ব্যবহার করলে ডান দিকে টাইপ লিখুন: var list = new ArrayList<String>();.

৪ · Bounded type — “যেকোনো টাইপ নয়, শুধু যারা তুলনা করা যায়”

এবার একটি max() লিখতে চাই, যা পরীক্ষার নম্বর, পণ্যের দাম বা নামের তালিকা — সবার জন্য চলবে। প্রথম চেষ্টা:

static <T> T max(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;     // লাইন ৩
}

Main.java:3: error: cannot find symbol
        return a.compareTo(b) >= 0 ? a : b;
                ^
  symbol:   method compareTo(T)
  location: variable a of type T
  where T is a type-variable:
    T extends Object declared in method <T>max(T,T)

শেষ লাইনটি পড়ুন: T extends Object. Compiler-এর কাছে শুধু <T> মানে “যেকোনো object” — আর যেকোনো object-এর compareTo থাকে না। আমাদের দরকার শর্ত জুড়ে দেওয়া: “T এমন টাইপ, যাকে নিজের সাথে তুলনা করা যায়।” পর্ব ২৩-এর Comparable interface ঠিক এই প্রতিশ্রুতি দেয়:

static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;     // এখন বৈধ
}

<T extends Comparable<T>> হলো একটি bounded type parameter. এখানে extends শব্দটি class আর interface দুই ক্ষেত্রেই ব্যবহার হয় (implements নয়), আর অর্থ “এর subtype হতে হবে”। লাভ দুই দিকে: ভেতরে compareTo ডাকা যায়, আর বাইরে কেউ তুলনা করা যায় না এমন টাইপ দিলে compiler আটকায়। কয়েকটি রূপ:

• <T extends Number> — ভেতরে doubleValue(), intValue() ডাকা যায়; Integer, Double, Long সবাই চলে, String নয়।
• <T extends Number & Comparable<T>> — একাধিক শর্ত, & দিয়ে জোড়া। নিয়ম: class (যদি থাকে) প্রথমে, তারপর interface-গুলো।
• <T extends Comparable<T>> — টাইপটি নিজের নাম দিয়েই নিজের শর্ত লিখছে। একে বলে recursive bound; JDK-র Enum<E extends Enum<E>>-ও এমন।

এবার পুরো ছবি — একটি generic max(), যা তিন ধরনের তালিকায় চলে, আর একটি generic Pair, যা দিয়ে method দুটি মান ফেরত দেয়। চালিয়ে দেখুন:

import java.util.List;
record Pair<A, B>(A first, B second) { }

class Main {
    static <T extends Comparable<T>> T max(List<T> items) {
        T best = items.get(0);
        for (T x : items)
            if (x.compareTo(best) > 0) best = x;
        return best;
    }
    static Pair<Integer, Integer> minMax(List<Integer> marks) {
        int lo = marks.get(0), hi = marks.get(0);
        for (int m : marks) { lo = Math.min(lo, m); hi = Math.max(hi, m); }
        return new Pair<>(lo, hi);
    }
    public static void main(String[] args) {
        List<Integer> marks = List.of(72, 88, 65);
        System.out.println(max(marks));
        System.out.println(max(List.of(120.5, 99.0, 250.0)));
        System.out.println(max(List.of("Karim", "Rahim", "Ayesha")));
        Pair<Integer, Integer> r = minMax(marks);
        System.out.println("min=" + r.first() + ", max=" + r.second());
        System.out.println(new Pair<>("চা", 15.0));
    }
}

শুধু reference টাইপ — List<int> কেন নেই

ওপরের কোডে List<Integer> লেখা, List<int> নয়। চেষ্টা করলে:

Main.java:4: error: unexpected type
        List<int> marks = new ArrayList<>();
             ^
  required: reference
  found:    int
1 error

Type argument হতে পারে শুধু reference type — class, interface, array বা record. int, double-এর মতো primitive type নয়। কারণটি অংশ ৭-এ পরিষ্কার হবে: compile-এর পর T হয়ে যায় Object, আর Object-এর জায়গায় একটি কাঁচা int বসতে পারে না। তাই primitive-এর জন্য তার wrapper class (Integer, Double) ব্যবহার হয়, আর পর্ব ০৬-এর autoboxing marks.add(72)-কে নিজে থেকে Integer.valueOf(72) বানিয়ে দেয়।

৫ · Invariance — List<Integer> একটি List<Number> নয়

Integer একটি Number — পর্ব ১৯-এর inheritance অনুযায়ী Number n = 5; সম্পূর্ণ বৈধ। তাহলে স্বাভাবিকভাবেই মনে হয়, পূর্ণসংখ্যার তালিকাও একটি সংখ্যার তালিকা। Compiler কিন্তু রাজি নয়:

List<Integer> ints = new ArrayList<>();
List<Number> nums = ints;             // লাইন ৫

Main.java:5: error: incompatible types: List<Integer> cannot be converted to List<Number>
        List<Number> nums = ints;
                            ^
1 error

অর্থাৎ Integer আর Number-এর মধ্যে যে সম্পর্ক, List<Integer> আর List<Number>-এর মধ্যে সেটা নেই। Type argument আলাদা হলেই দুটি generic টাইপ সম্পর্কহীন — এই নিয়মের নাম invariance. শুনতে বাড়াবাড়ি মনে হয়, কিন্তু অনুমতি দিলে কী হতো, ধাপে ধাপে দেখুন:

1List<Integer> ints = new ArrayList<>();2ints.add(72);3List<Number> nums = ints;   // ধরি বৈধ4nums.add(3.14);              // Number তো!5Integer x = ints.get(1);     // ?6List<? extends Number> ro = ints;7Number n = ro.get(0);8ro.add(3.14);

Array কেন অন্যরকম — covariance আর তার দাম

মজার ব্যাপার হলো, array-তে Java ঠিক উল্টো সিদ্ধান্ত নিয়েছিল। Integer[] একটি Number[] হিসেবে মেনে নেওয়া হয় — এর নাম array covariance (পর্ব ১৩)। ফলে ওপরের ছিদ্রটি array-তে সত্যিই আছে, আর তা ধরা পড়ে চলার সময়:

Number[] nums = new Integer[2];     // compile হয়
nums[0] = 3.14;                     // লাইন ৪

Exception in thread "main" java.lang.ArrayStoreException: java.lang.Double
	at Main.main(Main.java:4)

Array নিজের আসল টাইপ (Integer[]) চলার সময়েও মনে রাখে, তাই প্রতিটি লেখার সময় JVM পরীক্ষা করে আর ভুল হলে ArrayStoreException ছোড়ে। Generic তালিকা চলার সময় নিজের type argument মনে রাখে না (অংশ ৭), তাই এমন পরীক্ষা সম্ভব নয় — সেজন্য পুরো নিরাপত্তা compile-এর সময়েই নিশ্চিত করতে হয়। Java-র নকশাকারদের ভাষায়: array-এর ভুল ধরা পড়ে দেরিতে, generics-এর ভুল আগে।

৬ · Wildcard আর PECS — কে দেয়, কে নেয়

প্রশ্নচিহ্ন ?-কে বলে wildcard — “কোনো একটি টাইপ, নাম জানার দরকার নেই।” তিন রূপে আসে:

? super T থেকে পড়তে গেলে কী হয়, সেটাও compiler স্পষ্ট বলে। List<? super Integer> sink = new ArrayList<Number>();-এ sink.add(5) চলে, কিন্তু Integer x = sink.get(0); লিখলে: error: incompatible types: CAP#1 cannot be converted to Integer — কারণ তালিকাটা List<Object>-ও হতে পারত। আর List<?>-এ add("x") দিলে একই ধাঁচের error: String cannot be converted to CAP#1. এই CAP#1-কে বলে wildcard capture — compiler প্রতিটি ?-কে একটি নামহীন, নির্দিষ্ট কিন্তু অজানা টাইপ হিসেবে ধরে।

JDK-র Collections.copy-এর signature ঠিক এই নিয়মে লেখা: static <T> void copy(List<? super T> dest, List<? extends T> src). আমাদের নিজের একটি ছোট copy দিয়ে দেখি — পূর্ণসংখ্যার তালিকা থেকে সাধারণ সংখ্যার তালিকায়:

static <T> void copy(List<? super T> dst,
                     List<? extends T> src)
ডাক: copy(all, marks)
marks : List<Integer>   all : List<Number>

T = Integer
src : List<Integer>  ✔ Integer extends Integer
dst : List<Number>   ✔ Number  super   Integer

for (T item : src)
src-এর আসল টাইপ যা-ই হোক (Integer বা তার subtype),
বের হওয়া জিনিস অন্তত একটি T — পড়া নিরাপদ

dst.add(item);
dst-এর আসল টাইপ List<Integer>, List<Number> বা List<Object> —
তিনটিতেই একটি Integer রাখা বৈধ — লেখা নিরাপদ

List<? super T> src   → পড়লে শুধু Object, T নয়   ✗
List<? extends T> dst → add(item) বাতিল (CAP#1)  ✗
তাই: Producer Extends, Consumer Super

এবার চালিয়ে দেখুন — একটি printAll, যা পূর্ণসংখ্যা, দশমিক বা মেশানো যেকোনো সংখ্যার তালিকা নেয়, আর ওপরের copy:

import java.util.ArrayList;
import java.util.List;
class Main {
    static void printAll(List<? extends Number> nums) {   // producer
        double total = 0;
        for (Number n : nums) total += n.doubleValue();
        System.out.println(nums + " total=" + total);
    }
    static <T> void copy(List<? super T> dst, List<? extends T> src) {
        for (T item : src) dst.add(item);                // src পড়ি, dst-এ লিখি
    }
    public static void main(String[] args) {
        List<Integer> marks = List.of(72, 88, 65);
        List<Double> prices = List.of(120.5, 99.0);
        printAll(marks);
        printAll(prices);
        List<Number> all = new ArrayList<>();
        copy(all, marks);
        copy(all, prices);
        printAll(all);
        List<Object> log = new ArrayList<>();
        copy(log, marks);
        System.out.println(log);
    }
}

কোথায় wildcard নয়

• Return টাইপে নয়। List<? extends Number> load() ফেরত দিলে যে ডাকে, সে তালিকায় কিছু যোগ করতে পারে না, আর প্রতিটি ব্যবহারে wildcard টেনে বেড়াতে হয়। Wildcard হলো parameter-এর নমনীয়তা, ফলের নয় — ফেরত দিন List<Number> বা List<T>.
• পড়া ও লেখা দুটোই করলে নয়। যে method একই তালিকা থেকে পড়ে আবার সেখানেই লেখে (যেমন সাজানো বা দুই ঘর অদলবদল), তার জন্য List<T>.
• সহজ নিয়ম: কোনো type parameter যদি method-এর ঘোষণায় মাত্র একবার আসে, তাকে wildcard দিয়ে বদলানো যায় — <T extends Number> double sum(List<T> x)-এর চেয়ে double sum(List<? extends Number> x) পড়তে সহজ।

৭ · Type erasure — চলার সময় generics আর থাকে না

এতক্ষণ যা দেখলেন, তার প্রায় সবটাই compiler-এর কাজ। javac সব টাইপ যাচাই করার পর generic তথ্যগুলো মুছে ফেলে, আর bytecode-এ রেখে যায় সাধারণ, Object-ভিত্তিক কোড। এই কৌশলের নাম type erasure. ধাপে ধাপে দেখুন Box<String>-এর কী হয়:

class Box<T> {
    private T value;
    void set(T v) { value = v; }
    T get() { return value; }
}
Box<String> b = new Box<>();
b.set("চা");
String s = b.get();

b.set("চা");   ✔ String → T=String
b.set(42);     ✗ int cannot be converted to String
String s = b.get();  ✔ T=String → String

class Box {
    private Object value;
    void set(Object v) { value = v; }
    Object get() { return value; }
}
(<T extends Number> হলে T → Number)

Box b = new Box();
b.set("চা");
String s = (String) b.get();
← আপনি লেখেননি, compiler বসিয়েছে

new ArrayList<String>().getClass() ==
new ArrayList<Integer>().getClass()   → true
getClass().getName()                  → java.util.ArrayList
একটিই class ফাইল, সব type argument-এর জন্য

Erasure-এর পরিণতি — যা লেখা যায় না

চলার সময় T-এর পরিচয় নেই, তাই যে কাজে চলার সময় টাইপ জানা দরকার, তা generic কোডে নিষেধ। প্রতিটির আসল compiler বার্তা:

যে টাইপের পুরো তথ্য চলার সময়েও থাকে (String, int[], List<?>, raw List), তাকে বলে reifiable type; List<String> reifiable নয়। ওপরের প্রায় সব নিষেধের মূলে এই একটি পার্থক্য।

Raw type আর unchecked warning

অংশ ১-এর List names = new ArrayList(); — type argument ছাড়া generic টাইপের নাম — একে বলে raw type. এটি Java-তে রাখা হয়েছে শুধু ২০০৪-এর আগের কোড যাতে আজও compile হয়। নতুন কোডে কখনো নয়। ডিফল্টে compiler শুধু সেই দুই লাইনের “Note” দেয়; বিস্তারিত দেখতে -Xlint:unchecked দিয়ে compile করুন:

javac -Xlint:unchecked Main.java

Main.java:5: warning: [unchecked] unchecked call to add(E) as a member of the raw type List
        names.add("Rahim");
                 ^
  where E is a type-variable:
    E extends Object declared in interface List
Main.java:6: warning: [unchecked] unchecked call to add(E) as a member of the raw type List
        names.add(42);
                 ^
  where E is a type-variable:
    E extends Object declared in interface List
2 warnings

এমন সতর্কবার্তাকে বলে unchecked warning: “এখানে আমি টাইপ যাচাই করতে পারিনি — ধাপ ৪-এর cast যে নিরাপদ, সেই নিশ্চয়তা আর দিতে পারছি না।” Raw তালিকাকে generic ভ্যারিয়েবলে বসালেও একই সতর্কতা আসে: List<String> names = raw; → warning: [unchecked] unchecked conversion. প্রতিটি unchecked warning হলো একটি সম্ভাব্য ClassCastException-এর ঠিকানা। এগুলো ঠিক করুন; চাপা দেওয়ার কথা পরের অংশের AI টেবিলে।

Heap pollution আর @SafeVarargs (সংক্ষেপে)

যখন List<String> টাইপের কোনো ভ্যারিয়েবল আসলে এমন object দেখায় যাতে String নয় এমন জিনিস আছে, সেই অবস্থাকে বলে heap pollution. Raw type এর একটি পথ; আরেকটি পথ generic varargs. T... items আসলে একটি array, আর T-এর array চলার সময় তৈরি করা যায় না — তাই compiler Object[]-ধাঁচের array বানায় এবং সতর্ক করে:

Main.java:3: warning: [unchecked] Possible heap pollution from parameterized vararg type T
    static <T> List<T> listOf(T... items) {
                                   ^
  where T is a type-variable:
    T extends Object declared in method <T>listOf(T...)
1 warning

Method যদি সেই array-তে কিছু না লেখে আর array-টি বাইরে না পাঠায়, তাহলে লেখক @SafeVarargs annotation দিয়ে প্রতিশ্রুতি দিতে পারেন: “এটা নিরাপদ।” এটি বসানো যায় শুধু static, final বা private method আর constructor-এ। মনে রাখবেন, @SafeVarargs একটি প্রতিশ্রুতি — compiler তা প্রমাণ করে না। List.of(...), Arrays.asList(...) এমন annotation-যুক্ত JDK method.

৮ · Generic interface আর JDK-র signature পড়া

Interface-ও generic হতে পারে, আর JDK-র সবচেয়ে ব্যবহৃত দুটি interface ঠিক তাই। Comparable<T> বলে “আমাকে একটি T-এর সাথে তুলনা করা যায়” — class Student implements Comparable<Student> লিখলে compareTo(Student other) লিখতে হয়, Object নিয়ে cast করার দরকার নেই। Comparator<T> হলো বাইরের একটি তুলনার নিয়ম: Comparator<Student> byGpa. দুটির পার্থক্য আর ব্যবহার বিস্তারিত পর্ব ৩৩-এ; এখানে শুধু এটুকু দেখুন যে টাইপ parameter থাকায় ভুল টাইপের সাথে তুলনা compile-ই হয় না। তালিকা নিয়ে আরও গভীরে যাবেন পর্ব ৩০-এ।

এবার সেই signature, যা দেখে অনেকেই প্রথমবার ঘাবড়ে যান — Collections.sort:

public static <T extends Comparable<? super T>> void sort(List<T> list)

এক টুকরো করে পড়ি:

? super T সত্যিই কতটা দরকারি, তা যাচাই করা যায়। অংশ ৪-এর কঠোর <T extends Comparable<T>> max(List<T>)-কে একটি List<LocalDate> দিলে:

Main.java:7: error: method max in class Main cannot be applied to given types;
        max(days);
        ^
  required: List<T>
  found:    List<LocalDate>
  reason: inference variable T has incompatible equality constraints ChronoLocalDate,LocalDate
  where T is a type-variable:
    T extends Comparable<T> declared in method <T>max(List<T>)
1 error

Bound বদলে <T extends Comparable<? super T>> করলেই একই তালিকায় max কাজ করে, আর Collections.sort(days)-ও। আরও এক ধাপ জটিল উদাহরণ: Collections.max-এর signature হলো <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll). ওই আপাত-অর্থহীন Object & আছে erasure-এর কারণে: প্রথম bound Object হওয়ায় erasure-এর পর method-টি Object ফেরত দেয়, ঠিক Java 5-এর আগের max-এর মতো — ফলে পুরোনো compile করা কোড ভাঙেনি।

৯ · AI-এর যুগে — unchecked warning চাপা নয়, পড়ুন

Generics-এ AI-এর ভুলগুলো চেনা যায় সহজে, কারণ প্রায় সবই একটি প্রবণতা থেকে আসে: “compile হলেই হলো।” সবচেয়ে বিপজ্জনকটি হলো সতর্কবার্তা চাপা দেওয়া। নিচের কোডটি কোনো warning ছাড়াই compile হয়, কারণ @SuppressWarnings("unchecked") সেটা লুকিয়ে ফেলেছে:

import java.util.*;
class Main {
    @SuppressWarnings("unchecked")
    static List<String> load() {
        List raw = new ArrayList();
        raw.add(7);                         // আসল ভুল — লাইন ৬
        return raw;
    }
    public static void main(String[] args) {
        List<String> names = load();
        System.out.println(names.size());
        String first = names.get(0);        // crash — লাইন ১২
    }
}

1
Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
	at Main.main(Main.java:12)

লাইন ১২-তে কোনো cast লেখা নেই, তবু ClassCastException — এটা অংশ ৭-এর ধাপ ৪-এর লুকানো cast. size() ঠিকঠাক ১ দিল; তালিকাটা “দূষিত” অবস্থায় ঘুরে বেড়াল যতক্ষণ না কেউ ভেতরের জিনিস String হিসেবে বের করল। Stack trace দেখাচ্ছে লাইন ১২, ভুল লাইন ৬-এ — একটি @SuppressWarnings-এর দাম।

AI-এর generic কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• -Xlint:unchecked দিয়ে compile করে শূন্য warning পেয়েছি
• কোথাও raw type নেই (List, Map, Comparable — সবার পাশে type argument)
• প্রতিটি @SuppressWarnings-এর পাশে নিরাপত্তার যুক্তি লেখা, আর সেটা সবচেয়ে ছোট পরিসরে
• প্রতিটি wildcard parameter-এর জন্য বলতে পারি সেটা পড়ার না লেখার
• কোনো public method-এর return টাইপে wildcard নেই
• new T(), generic array বা instanceof List<String>-এর মতো কৌশল ঘুরপথে (cast দিয়ে) করা হয়নি