লিখিত ও মৌখিক (ভাইভা) প্রশ্ন — Java মডেল উত্তর ও কৌশল

JVM (Java Virtual Machine) হলো সেই প্রোগ্রাম, যা bytecode (.class ফাইল) চালায় — লোড করে, যাচাই করে, interpret বা JIT compile করে, আর মেমরি সামলায়। JRE (Java Runtime Environment) = JVM + standard library — প্রোগ্রাম চালাতে যা লাগে। JDK (Java Development Kit) = JRE-এর সবকিছু + ডেভেলপারের টুল (javac, jar, javadoc, jshell) — প্রোগ্রাম বানাতে যা লাগে।

javac Main.java     # JDK-এর compiler: Main.java → Main.class (bytecode)
java Main           # JVM চালু হয়ে Main.class চালায়

উপসংহার: সম্পর্কটি বাক্সের ভেতরে বাক্স: JDK ⊃ JRE ⊃ JVM. Java 11 থেকে Oracle আলাদা JRE ডাউনলোড দেওয়া বন্ধ করেছে; এখন সাধারণত JDK বসানো হয়, আর অ্যাপের সাথে ছোট runtime বানাতে jlink ব্যবহার হয়। ঝামেলার প্রশ্ন “JVM কি platform-independent?” — না; bytecode platform-independent, JVM প্রতিটি OS-এর জন্য আলাদা।

ঝালিয়ে নিন: পর্ব ০৩ · সেটআপ, পর্ব ০৫ · Java কীভাবে চলে

সংজ্ঞা: Java-র source code সরাসরি কোনো CPU-র machine code-এ নয়, বরং একটি মধ্যবর্তী ভাষা — bytecode — এ compile হয়। যেকোনো OS-এ সেই OS-এর JVM থাকলেই একই .class ফাইল চলে। এটিই “Write Once, Run Anywhere” — Sun Microsystems ১৯৯৫ সালে Java প্রকাশের সময় এই স্লোগান ব্যবহার করে।

• Class loader: দরকার অনুযায়ী .class ফাইল মেমরিতে আনে।
• Bytecode verifier: চালানোর আগে যাচাই করে কোডটি নিয়ম ভাঙছে কি না — নিরাপত্তার একটি স্তর।
• Interpreter: শুরুতে bytecode এক এক করে চালায় — দ্রুত শুরু, কিন্তু ধীর গতি।
• JIT compiler: বারবার চলা (“hot”) method-কে চলার সময় native machine code-এ compile করে — তাই দীর্ঘ সময় চলা Java প্রোগ্রাম অনেক দ্রুত হয়।

চিত্র: Main.java → javac → Main.class → (Windows-এর JVM / Linux-এর JVM / macOS-এর JVM) → সেই মেশিনের machine code.

উপসংহার: দাম আছে — JVM-এর শুরু হতে সময় লাগে আর কিছু মেমরি নেয়। এই কারণেই ছোট CLI টুলে বা serverless-এ কখনো কখনো GraalVM native image-এর মতো ahead-of-time compilation ব্যবহার হয়।

ঝালিয়ে নিন: পর্ব ০১ · Java কেন?, পর্ব ০৫ · JVM, bytecode, JIT আর GC

Java-তে ৮টি primitive type — byte, short, int, long, float, double, char, boolean. এগুলো সরাসরি মান রাখে, object নয়। প্রতিটির একটি wrapper class আছে — Integer, Double, Character ইত্যাদি — যা মানটিকে একটি object-এ মোড়ে।

Autoboxing (Java 5 থেকে): compiler নিজে int → Integer রূপান্তর বসায় (Integer.valueOf); উল্টোটা unboxing (intValue())। ফাঁদ: null wrapper unbox করলে NullPointerException.

Integer cache: Integer.valueOf −128 থেকে 127 পর্যন্ত মানের জন্য আগে থেকে বানানো একই object ফেরত দেয়। তাই Integer a = 127, b = 127; হলে a == b হলো true, কিন্তু 128-এ false (ডিফল্ট সেটিংসে; ওপরের সীমা JVM option দিয়ে বাড়ানো যায়)। শিক্ষা: wrapper-এ কখনো == নয়, equals.

ঝালিয়ে নিন: পর্ব ০৬ · primitive, wrapper আর var

String একটি immutable class — একবার তৈরি হলে তার অক্ষর আর বদলায় না; concat, toUpperCase সবাই নতুন String ফেরত দেয়। StringBuilder (Java 5) আর StringBuffer (Java 1.0) দুটিই mutable — একই object-এর ভেতরের buffer বদলায়।

String immutable কেন: (১) String pool — একই literal বহু জায়গায় ভাগ করা নিরাপদ হয়; (২) নিরাপত্তা — ফাইলের পথ বা URL যাচাইয়ের পর কেউ বদলাতে পারে না; (৩) hashCode একবার হিসাব করে রাখা যায়, তাই HashMap-এর key হিসেবে ভালো; (৪) thread-এর মধ্যে ভাগ করতে কোনো lock লাগে না।

উপসংহার: লুপে s += x লিখলে প্রতিবার নতুন String তৈরি হয় — n বার জুড়লে মোট কাজ O(n²)-এর দিকে যায়। লুপে StringBuilder ব্যবহার করুন। এক লাইনের "a" + b + "c" নিয়ে চিন্তার কিছু নেই — compiler নিজেই দক্ষ কোড বানায়।

ঝালিয়ে নিন: পর্ব ০৮ · String, StringBuilder আর immutability

উত্তর: Java সবসময় pass-by-value. method ডাকার সময় argument-এর মানের কপি যায়। primitive-এর ক্ষেত্রে মানটি সংখ্যা; object-এর ক্ষেত্রে মানটি একটি reference (ঠিকানার মতো কিছু)। তাই reference-এর কপি দিয়ে object-এর ভেতর বদলানো যায়, কিন্তু ডাকার জায়গার ভ্যারিয়েবলকে নতুন object-এ পাঠানো যায় না।

static void addBonus(int salary)        { salary += 500; }          // কপি বদলাল
static void addItem(List<String> cart)  { cart.add("tea"); }        // একই object বদলাল
static void replace(List<String> cart)  { cart = new ArrayList<>(); } // শুধু কপি নতুন দিকে

int s = 1000;              addBonus(s);   // s এখনো 1000
List<String> c = new ArrayList<>();
addItem(c);                               // c = [tea]
replace(c);                               // c এখনো [tea]

চিত্র: c ──► [ArrayList object] আর method-এর cart ──► [একই object]. cart = new … করলে শুধু cart-এর তীর ঘোরে, c-এর নয়।

উপসংহার: C++-এর int&-এর মতো আসল pass-by-reference Java-তে নেই। দুটি মান “swap” করার method তাই Java-তে লেখা যায় না; দরকার হলে array বা object-এর ভেতরের field বদলাতে হয়। ভাইভায় এক বাক্যে: “Java pass-by-value; object-এর ক্ষেত্রে reference-টি value হিসেবে যায়।”

ঝালিয়ে নিন: পর্ব ১২ · method — overloading, varargs আর pass-by-value

পদ্ধতি: palindrome মানে সামনে-পেছনে একই। দুটি সূচক — একটি শুরু থেকে, একটি শেষ থেকে — ভেতরের দিকে আসবে (two-pointer). অক্ষর বা অঙ্ক নয় এমন কিছু এড়িয়ে যাবে, আর তুলনা করবে ছোট হাতের রূপে। নতুন String বানাতে হয় না, তাই মেমরি O(1), সময় O(n).

class Main {
    static boolean isPalindrome(String s) {
        int i = 0, j = s.length() - 1;
        while (i < j) {
            char a = s.charAt(i), b = s.charAt(j);
            if (!Character.isLetterOrDigit(a)) { i++; continue; }
            if (!Character.isLetterOrDigit(b)) { j--; continue; }
            if (Character.toLowerCase(a) != Character.toLowerCase(b)) return false;
            i++;
            j--;
        }
        return true;
    }

    public static void main(String[] args) {
        String[] tests = {"madam", "Was it a car or a cat I saw?", "Java", "", "12321"};
        for (String t : tests) {
            System.out.println("\"" + t + "\" -> " + isPalindrome(t));
        }
    }
}

ঝালিয়ে নিন: পর্ব ০৮ · String, পর্ব ১১ · লুপ

পদ্ধতি: দুই প্রান্তের ফাঁকা trim() দিয়ে বাদ, তারপর split("\\s+") — এক বা একাধিক whitespace দিয়ে ভাগ। এরপর শেষ থেকে শুরুর দিকে শব্দ জুড়ুন। লাইব্রেরি দিয়েও দেখানো হলো — খাতায় দুটি পদ্ধতি দিলে পরীক্ষক দেখেন আপনি দুই স্তরেই ভাবতে পারেন।

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

class Main {
    // পদ্ধতি ১: হাতে লুপ, StringBuilder দিয়ে জোড়া
    static String reverseWords(String s) {
        String[] words = s.trim().split("\\s+");
        StringBuilder sb = new StringBuilder();
        for (int i = words.length - 1; i >= 0; i--) {
            sb.append(words[i]);
            if (i > 0) sb.append(' ');
        }
        return sb.toString();
    }

    // পদ্ধতি ২: লাইব্রেরি দিয়ে
    static String reverseWordsLib(String s) {
        List<String> words = new ArrayList<>(Arrays.asList(s.trim().split("\\s+")));
        Collections.reverse(words);
        return String.join(" ", words);
    }

    public static void main(String[] args) {
        String input = "  Java   is fun to learn ";
        System.out.println("[" + reverseWords(input) + "]");
        System.out.println("[" + reverseWordsLib(input) + "]");
        System.out.println("[" + reverseWords("") + "]");
    }
}

ঝালিয়ে নিন: পর্ব ০৮ · String, পর্ব ১৩ · array

পদ্ধতি: F(0) = 0, F(1) = 1, F(n) = F(n−1) + F(n−2). সরাসরি recursion একই মান বারবার হিসাব করে — F(n−2) দুই শাখাতেই আসে — তাই ডাকের সংখ্যা সূচকীয় হারে বাড়ে। Iterative সমাধান শুধু শেষ দুটি মান মনে রাখে: O(n) সময়, O(1) মেমরি। Memoization recursion রেখেই প্রতিটি ফল একবার হিসাব করে map-এ রাখে: O(n) সময়, O(n) মেমরি।

import java.util.HashMap;
import java.util.Map;

class Main {
    static long fibIter(int n) {                 // O(n) সময়, O(1) মেমরি
        long a = 0, b = 1;
        for (int i = 0; i < n; i++) {
            long next = a + b;
            a = b;
            b = next;
        }
        return a;
    }

    static final Map<Integer, Long> memo = new HashMap<>();
    static long fibMemo(int n) {                 // O(n) সময়, O(n) মেমরি
        if (n < 2) return n;
        Long cached = memo.get(n);
        if (cached != null) return cached;
        long value = fibMemo(n - 1) + fibMemo(n - 2);
        memo.put(n, value);
        return value;
    }

    static int calls = 0;
    static long fibNaive(int n) { calls++; return n < 2 ? n : fibNaive(n - 1) + fibNaive(n - 2); }

    public static void main(String[] args) {
        for (int i = 0; i <= 10; i++) System.out.print(fibIter(i) + " ");
        System.out.println();
        System.out.println("fib(50): " + fibIter(50) + " = " + fibMemo(50));
        System.out.println("naive fib(25) = " + fibNaive(25) + ", calls = " + calls);
    }
}

ঝালিয়ে নিন: পর্ব ১২ · method, পর্ব ৫৪ · অ্যালগরিদম ও কনটেস্টে Java

Regular expression হলো লেখার আকৃতি বর্ণনার একটি ছোট ভাষা। Java-তে এর দুটি মূল class: Pattern — একবার compile করা নকশা (immutable, thread-safe), আর Matcher — একটি লেখার ওপর একটি খোঁজা (thread-safe নয়)।

static final Pattern BD_MOBILE = Pattern.compile("(?:\\+?880|0)1[3-9]\\d{8}");

static boolean isMobile(String s) {
    return s != null && BD_MOBILE.matcher(s).matches();   // যাচাইয়ে matches(), find() নয়
}
// "01712345678" → true, "+8801712345678" → true, "01212345678" → false

নকশার ব্যাখ্যা: (?:\+?880|0) — শুরুতে +880, 880 অথবা 0 (non-capturing group); তারপর 1; [3-9] — অপারেটরের অঙ্ক ৩ থেকে ৯; শেষে \d{8} — ঠিক আটটি অঙ্ক। matches() পুরো লেখা চায়, তাই আলাদা ^/$ লাগেনি; find() দিলে “আমার নম্বর 01712345678” পুরো বাক্যটিও পাস করত।

backslash দুবার কেন: অনুবাদ হয় দুই স্তরে। Java compiler আগে string literal পড়ে — সেখানে \ নিজেই escape শুরু করে, আর \d নামে কোনো Java escape নেই, তাই "\d" লিখলে compile error “illegal escape character”. "\\d" লিখলে মেমরিতে থাকে দুই অক্ষর \d, যা regex engine পড়ে “একটি অঙ্ক” হিসেবে। text block-এও একই নিয়ম; Java-তে raw string নেই।

উপসংহার: যাচাইয়ে matches(), তথ্য তুলতে while (m.find()) আর group(); নকশা static final Pattern. মনে রাখুন, \d আর \w ডিফল্টে শুধু ASCII — বাংলা অঙ্ক ধরতে UNICODE_CHARACTER_CLASS লাগে।

ঝালিয়ে নিন: পর্ব ১৪ · regular expression, পর্ব ০৮ · String

সংজ্ঞা: Object-oriented programming হলো প্রোগ্রামকে object দিয়ে সাজানো — প্রতিটি object নিজের ডেটা (field) আর সেই ডেটার ওপর কাজ (method) একসাথে রাখে। এর চারটি স্তম্ভ:

• Encapsulation: ডেটা private রেখে শুধু নিয়ন্ত্রিত method দিয়ে বদলাতে দেওয়া। class Account { private long balance; void deposit(long t) { if (t <= 0) throw …; balance += t; } } — বাইরে থেকে কেউ balance ঋণাত্মক করতে পারে না।
• Abstraction: ভেতরের জটিলতা লুকিয়ে সহজ চেহারা দেওয়া। list.add(x) ডাকলেই হয় — array বড় করা বা node জোড়া নিয়ে ভাবতে হয় না। interface আর abstract class এর প্রধান হাতিয়ার।
• Inheritance: একটি class আরেকটির field ও method নিয়ে নতুন class বানানো — “is-a” সম্পর্ক। class SavingsAccount extends Account { }
• Polymorphism: একই ডাক, ভিন্ন কাজ। Compile-time — method overloading; run-time — overriding: Payment p = new Bkash(); p.fee(500); চালায় Bkash-এর নিয়ম।

উপসংহার: চারটি স্তম্ভ উপায়, লক্ষ্য নয়। লক্ষ্য হলো এমন কোড, যা বদলানো সহজ — নতুন পেমেন্ট পদ্ধতি (Nagad) যোগ করতে পুরোনো কোড না ভেঙে শুধু একটি নতুন class লেখা। “চারটি স্তম্ভ” কথাটি পড়ানোর সুবিধার জন্য প্রচলিত একটি ভাগ; কিছু বইয়ে abstraction-কে আলাদা ধরা হয় না।

ঝালিয়ে নিন: পর্ব ০২ · object দিয়ে ভাবা, পর্ব ১৭, পর্ব ২০

Class হলো নকশা — কোন কোন field আর method থাকবে তার বর্ণনা। Object হলো সেই নকশা থেকে new দিয়ে heap-এ বানানো একটি আসল নমুনা, যার নিজের field-এর মান আছে। একটি “Student” class থেকে হাজার জন ছাত্রের object.

উপসংহার: একটি constructor-ও নিজে লিখলে default constructor আর আপনাআপনি তৈরি হয় না — তখন new Student() compile error. একই class-এর একটি constructor থেকে আরেকটি ডাকতে this(…), আর সেটি অবশ্যই প্রথম লাইনে।

ঝালিয়ে নিন: পর্ব ১৫ · class ও object, পর্ব ১৬ · constructor আর this

Access modifier ঠিক করে একটি class, field বা method কোথা থেকে ব্যবহার করা যাবে। শব্দ তিনটি (private, protected, public), আর কিছু না লিখলে চতুর্থটি — package-private.

উপসংহার: নিয়ম — যতটা সম্ভব কম খোলা (least privilege). field প্রায় সবসময় private; বাইরের দরকারি কাজ public method-এ। top-level class শুধু public বা package-private হতে পারে। ফাঁদের প্রশ্ন: “protected কি শুধু subclass-এর জন্য?” — না, একই package-এর সব class-ও দেখে।

ঝালিয়ে নিন: পর্ব ১৭ · encapsulation আর access modifier

static মানে “class-এর, কোনো একটি object-এর নয়”। static field-এর পুরো প্রোগ্রামে একটিই কপি (সব object ভাগ করে); static method object ছাড়াই ClassName.method() দিয়ে ডাকা যায়, আর তার ভেতরে this নেই — তাই সরাসরি instance field ছোঁয়া যায় না। main static, কারণ JVM কোনো object বানানোর আগেই তাকে ডাকে।

নাম কাছাকাছি হলেও নিচের তিনটি সম্পূর্ণ আলাদা জিনিস:

উপসংহার: final reference মানে reference বদলাবে না, object-এর ভেতর নয় — final List<String> xs-এ xs.add(…) চলে। finally চলে না শুধু চরম ক্ষেত্রে, যেমন System.exit() বা JVM নিজেই বন্ধ হয়ে গেলে। finalize কখন চলবে, আদৌ চলবে কি না — কোনো নিশ্চয়তা ছিল না; সেটাই তার বাদ পড়ার কারণ।

ঝালিয়ে নিন: পর্ব ১৮ · static আর final, পর্ব ১৬, পর্ব ২৯

int area(int side)               { return side * side; }      // overloading
double area(double w, double h)  { return w * h; }

class Payment { long fee(long amount) { return 0; } }
class Bkash extends Payment {
    @Override long fee(long amount) { return amount * 185 / 10_000; }  // overriding
}

উপসংহার: override করার সময় সবসময় @Override লিখুন — নাম বা parameter-এ টাইপো হলে compiler ধরবে; না লিখলে ভুলটি নীরবে একটি নতুন overload হয়ে যায়।

ঝালিয়ে নিন: পর্ব ১২ · overloading, পর্ব ২০ · polymorphism আর dynamic dispatch

Abstract class হলো abstract চিহ্নিত class, যার object বানানো যায় না; তাতে abstract method (শরীর নেই) আর সাধারণ method, field, constructor — সবই থাকতে পারে। Interface হলো একটি চুক্তি — কোন কোন method থাকতে হবে তার তালিকা; class implements করে সেই চুক্তি পূরণ করে।

interface Payable { long fee(long amount); }                // চুক্তি

abstract class Shape {                                       // আংশিক নকশা
    private final String name;                               // state
    Shape(String name) { this.name = name; }                 // constructor
    abstract double area();                                  // subclass লিখবে
    String describe() { return name + ": " + area(); }       // ভাগের কোড
}

উপসংহার: Java 8-এর default method-এর পর interface-এও কোড থাকে, কিন্তু মূল পার্থক্য রয়ে গেছে — interface-এ instance state আর constructor নেই। প্রচলিত পরামর্শ: চুক্তির জন্য আগে interface; একই পরিবারের class-গুলোর মধ্যে state ও কোড ভাগ করতে হলে abstract class (প্রায়ই interface-এর একটি আংশিক বাস্তবায়ন হিসেবে, যেমন AbstractList).

ঝালিয়ে নিন: পর্ব ২১ · abstract class আর interface

কারণ — diamond problem: B আর C দুটিই A থেকে এসেছে আর দুজনেই hello() override করেছে। D যদি B ও C দুটিকেই extend করত, d.hello() কোনটি চালাবে? আর A-র field কি দুই কপি থাকবে? C++ এর জন্য virtual inheritance-এর মতো জটিল নিয়ম রাখে। Java-র নকশাকারেরা ভাষা সরল রাখতে class-এ একটিমাত্র parent রেখেছেন (single inheritance), কিন্তু interface অনেকগুলো নেওয়া যায় — কারণ পুরোনো interface-এ state বা কোড ছিল না।

Java 8-এর পর: দুটি interface-এ একই default method থাকলে compiler বাধ্য করে class-টিকে নিজে override করতে, আর চাইলে নির্দিষ্ট একটিকে ডাকতে:

interface Camera { default String info() { return "camera"; } }
interface Phone  { default String info() { return "phone"; } }

class SmartPhone implements Camera, Phone {
    @Override public String info() {           // না লিখলে compile error
        return Phone.super.info() + " + " + Camera.super.info();
    }
}

নিয়মের ক্রম: (১) class-এর নিজের বা superclass-এর method সবসময় জেতে; (২) তারপর বেশি নির্দিষ্ট interface (sub-interface); (৩) তাতেও মীমাংসা না হলে class-কে নিজে override করতে হয়। state নেই বলে field-এর দুই কপির সমস্যা ওঠে না।

ঝালিয়ে নিন: পর্ব ১৯ · inheritance, পর্ব ২১

সংজ্ঞা: Inheritance হলো “is-a” — SavingsAccount একটি Account. Composition হলো “has-a” — একটি Car-এর একটি Engine আছে; Car-এর ভেতরে Engine-এর একটি field, আর Car কাজ পাঠায় সেই object-কে।

• Inheritance-এর ঝুঁকি: subclass parent-এর ভেতরের খুঁটিনাটির ওপর নির্ভর করে; parent বদলালে child ভাঙে (fragile base class). সম্পর্কটি compile-এর সময় স্থির — চলার সময় বদলানো যায় না।
• Composition-এর সুবিধা: ভেতরের object interface দিয়ে রাখলে চলার সময় বদলানো যায় (PaymentGateway-এ bKash বা Nagad), টেস্টে নকল object বসানো যায়, আর শুধু দরকারি কাজটুকু বাইরে দেখানো যায়।
• ক্লাসিক উদাহরণ: Java-র নিজের Stack extends Vector — ফলে stack-এর মাঝখানে insertElementAt করা যায়, যা stack-এর নিয়ম ভাঙে। এ কারণেই এখন ArrayDeque পরামর্শ দেওয়া হয়।

উপসংহার: “Favor composition over inheritance” — Gang of Four-এর Design Patterns (১৯৯৪) বইয়ের একটি মূলনীতি, যা Joshua Bloch-এর Effective Java-তেও জোর দিয়ে বলা হয়েছে। inheritance তখনই, যখন সত্যিকারের “is-a” সম্পর্ক আর parent-টি extend করার জন্যই নকশা করা।

ঝালিয়ে নিন: পর্ব ১৯ · inheritance, পর্ব ৪৮ · design pattern

== primitive-এ মান তুলনা করে, আর reference-এ দেখে দুটি ভ্যারিয়েবল একই object-কে দেখাচ্ছে কি না (reference equality). equals() হলো Object-এর একটি method, যা দেখে দুটি object অর্থে সমান কি না। Object-এর নিজের equals আসলে ==-ই করে; String, Integer, record-এর মতো class সেটিকে override করে মান তুলনা করে।

import java.util.Objects;

class Point {
    private final int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Point p)) return false;
        return x == p.x && y == p.y;
    }

    @Override
    public int hashCode() { return Objects.hash(x, y); }
}

class Main {
    public static void main(String[] args) {
        String a = "Dhaka";
        String b = "Dhaka";                  // একই pool object
        String c = new String("Dhaka");      // heap-এ নতুন object
        System.out.println(a == b);          // true
        System.out.println(a == c);          // false
        System.out.println(a.equals(c));     // true
        System.out.println(a == c.intern()); // true

        Point p1 = new Point(2, 3), p2 = new Point(2, 3);
        System.out.println(p1 == p2);        // false: আলাদা object
        System.out.println(p1.equals(p2));   // true: একই মান
        System.out.println(p1.hashCode() == p2.hashCode());
    }
}

equals–hashCode চুক্তি: a.equals(b) সত্য হলে a.hashCode() == b.hashCode() হতেই হবে (উল্টোটা জরুরি নয় — আলাদা object-এর hash মিলতে পারে, তাকে collision বলে)। HashMap আর HashSet আগে hashCode দিয়ে bucket খোঁজে, তারপর equals দিয়ে মেলায়। শুধু equals override করলে দুটি “সমান” Point আলাদা bucket-এ যায় — set.contains(new Point(2, 3)) false দিতে পারে। equals-কে reflexive, symmetric, transitive, consistent হতে হবে, আর x.equals(null) হবে false.

ঝালিয়ে নিন: পর্ব ২৩ · equals, hashCode, toString আর compareTo, পর্ব ০৮ · String pool

enum (Java 5) হলো নির্দিষ্ট কয়েকটি মানের একটি টাইপ — প্রতিটি মান ওই টাইপের একটি public static final object. Java-র enum আসলে পূর্ণ class: field, constructor (সবসময় private), method, এমনকি প্রতিটি মানের আলাদা আচরণ রাখা যায়।

enum OrderStatus {
    PLACED("অর্ডার হয়েছে"), PAID("পরিশোধিত"), DELIVERED("পৌঁছেছে");
    private final String label;
    OrderStatus(String label) { this.label = label; }
    String label() { return label; }
}
// OrderStatus.valueOf("PAID"), OrderStatus.values(), s.ordinal()

• Type safety: int status = 7; ভুল হলেও compile হয়; OrderStatus s = 7; হয় না।
• switch-এ নিরাপদ: switch expression-এ সব মান না ধরলে compiler জানায়।
• বিশেষ collection: EnumMap, EnumSet — ভেতরে array বা bit, খুব দ্রুত।
• Singleton: এক মানের enum হলো thread-safe ও serialization-নিরাপদ singleton-এর সহজতম উপায়।

উপসংহার: ডেটাবেসে ordinal() রাখবেন না — মাঝখানে নতুন মান যোগ হলে সব সংখ্যা সরে যায়; নাম (name()) রাখুন।

ঝালিয়ে নিন: পর্ব ২৪ · enum

Record (Java 16-এ স্থায়ী) হলো শুধু ডেটা বহনের জন্য একটি সংক্ষিপ্ত class. record Student(String name, int roll) { } লিখলেই compiler বানিয়ে দেয়: private final field, সব field নেওয়া constructor (canonical constructor), name()/roll() accessor, আর মানভিত্তিক equals, hashCode, toString.

যাচাই: compact constructor-এ নিয়ম বসানো যায়: record Money(long paisa) { Money { if (paisa < 0) throw new IllegalArgumentException(); } }

উপসংহার: record shallow immutable — field-এ একটি List থাকলে তালিকার ভেতর বাইরে থেকে বদলানো যায়; constructor-এ List.copyOf দিয়ে রক্ষা করুন। DTO, মানভিত্তিক object, Map-এর key — record-এর আদর্শ জায়গা।

ঝালিয়ে নিন: পর্ব ২৫ · record

Sealed class/interface (Java 17-এ স্থায়ী) ঠিক করে দেয় কোন কোন class তাকে extend বা implement করতে পারবে — permits তালিকা দিয়ে। Pattern matching for switch (Java 21-এ স্থায়ী) switch-এ টাইপ ধরে একই সাথে ভ্যারিয়েবল বের করতে দেয়; record pattern দিয়ে record-এর ভেতরের মানও খুলে নেওয়া যায়।

sealed interface PaymentResult permits Success, Failed {}
record Success(String txId) implements PaymentResult {}
record Failed(String reason) implements PaymentResult {}

static String message(PaymentResult r) {
    return switch (r) {                          // default লাগে না
        case Success(String id)   -> "সফল, transaction " + id;
        case Failed(String why)   -> "ব্যর্থ: " + why;
    };
}

কোন সমস্যা: আগে সম্ভাব্য সব টাইপ জানা থাকলেও compiler তা জানত না, তাই instanceof-এর লম্বা শিকল আর একটি “এখানে আসার কথা নয়” else লিখতে হতো। sealed হলে compiler জানে তালিকা সম্পূর্ণ (exhaustiveness) — নতুন টাইপ (ধরা যাক Pending) যোগ করলে যেসব switch সেটি ধরেনি, সবই compile error দেখায়। ভুলটা ধরা পড়ে চলার আগেই।

উপসংহার: এটি algebraic data type-এর Java রূপ — record হলো “এবং” (product), sealed হলো “অথবা” (sum). পরিবর্তনশীল আচরণের জন্য polymorphism এখনো ভালো; স্থির টাইপের তালিকার ওপর অনেক রকম কাজ হলে sealed + switch.

ঝালিয়ে নিন: পর্ব ২৬ · sealed class আর pattern matching

Generics (Java 5) টাইপকে parameter বানায় — List<String>. লাভ দুটি: compile-এর সময় টাইপ যাচাই (ভুল টাইপ ঢোকালে error), আর বের করার সময় cast লাগে না। Java 5-এর আগে List-এ সবকিছু Object, আর ভুল ধরা পড়ত চলার সময় ClassCastException হয়ে।

Type erasure: generic টাইপের তথ্য শুধু compile-এর সময় থাকে; compiler যাচাই শেষে তা মুছে ফেলে (T → Object বা তার bound) আর দরকারি জায়গায় cast বসায়। bytecode-এ List<String> আর List<Integer> একই List. কারণ — পুরোনো (Java 5-এর আগের) কোড আর library-র সাথে মিল রাখা।

• new T() বা new T[10] লেখা যায় না।
• obj instanceof List<String> অবৈধ — চলার সময় String-এর তথ্য নেই।
• List<int> নয় — primitive চলে না, wrapper লাগে।
• void f(List<String>) আর void f(List<Integer>) overload করা যায় না — erasure-এর পর দুটির signature এক।

Wildcard ও PECS: List<? extends Number> থেকে পড়া যায় (producer), List<? super Integer>-এ লেখা যায় (consumer) — “Producer Extends, Consumer Super” (PECS). List<Integer> কিন্তু List<Number>-এর subtype নয় (generics invariant).

ঝালিয়ে নিন: পর্ব ২৮ · generics — type parameter আর wildcard

                Throwable
               /         \
           Error        Exception
   (OutOfMemoryError,    /        \
 StackOverflowError)  IOException,   RuntimeException
                      SQLException   (NullPointerException,
                      (checked)       ArithmeticException,
                                      IllegalArgumentException …)
                                      (unchecked)

উপসংহার: Error সাধারণত catch করা হয় না — JVM-এর গুরুতর সমস্যা, প্রোগ্রাম সাধারণত সামলাতে পারে না। checked exception নিয়ে বিতর্ক আছে: lambda আর stream-এর সাথে এটি অস্বস্তিকর, তাই অনেক আধুনিক library unchecked ব্যবহার করে (যেমন UncheckedIOException). Kotlin বা C#-এর মতো ভাষায় checked exception নেই।

ঝালিয়ে নিন: পর্ব ২৯ · exception — checked, unchecked আর try-with-resources

String readConfig(Path p) throws IOException {        // ঘোষণা
    if (!Files.exists(p)) throw new NoSuchFileException(p.toString()); // ছোড়া
    return Files.readString(p);
}

উপসংহার: unchecked exception-এর জন্য throws লেখা ঐচ্ছিক (লিখলে নথি হিসেবে কাজ করে)। দুটি শব্দ মনে রাখার কৌশল: “throw — কাজ; throws — সতর্কবার্তা”।

ঝালিয়ে নিন: পর্ব ২৯

পদ্ধতি: “ব্যালান্স কম” প্রত্যাশিত একটি ব্যবসায়িক অবস্থা, যা ডাকারীকে সামলাতেই হবে — তাই Exception extend করে checked custom exception. বাড়তি তথ্য (কত টাকা কম) একটি field-এ। আর ঋণাত্মক পরিমাণ প্রোগ্রামারের ভুল — তার জন্য unchecked IllegalArgumentException.

class InsufficientBalanceException extends Exception {
    private final long shortBy;
    InsufficientBalanceException(long shortBy) {
        super("ব্যালান্স কম: আরও " + shortBy + " টাকা লাগবে");
        this.shortBy = shortBy;
    }
    long getShortBy() { return shortBy; }
}

class Account {
    private long balance;
    Account(long balance) { this.balance = balance; }

    void withdraw(long amount) throws InsufficientBalanceException {
        if (amount <= 0) throw new IllegalArgumentException("পরিমাণ শূন্যের বেশি হতে হবে");
        if (amount > balance) throw new InsufficientBalanceException(amount - balance);
        balance -= amount;
    }
    long getBalance() { return balance; }
}

class Main {
    public static void main(String[] args) {
        Account acc = new Account(5000);
        long[] requests = {2000, 4000, -100, 3000};
        for (long r : requests) {
            try {
                acc.withdraw(r);
                System.out.println(r + " টাকা তোলা হলো, বাকি " + acc.getBalance());
            } catch (InsufficientBalanceException e) {
                System.out.println(e.getMessage() + " (ঘাটতি " + e.getShortBy() + ")");
            } catch (IllegalArgumentException e) {
                System.out.println("ভুল অনুরোধ: " + e.getMessage());
            }
        }
    }
}

ঝালিয়ে নিন: পর্ব ২৯ · exception, পর্ব ১৭ · encapsulation

try-with-resources (Java 7) এমন একটি try, যার বন্ধনীতে খোলা রিসোর্স (AutoCloseable বাস্তবায়ন করে এমন যেকোনো object) block শেষে আপনাআপনি close() হয় — স্বাভাবিকভাবে শেষ হোক বা exception-এ।

try (BufferedReader in = Files.newBufferedReader(Path.of("marks.txt"))) {
    System.out.println(in.readLine());
}   // এখানে in.close() নিজে থেকেই

• কম কোড, কম ভুল: finally-তে null যাচাই আর close-এর নিজের try-catch লিখতে হয় না।
• একাধিক রিসোর্স: সেমিকোলন দিয়ে কয়েকটি খোলা যায়; বন্ধ হয় খোলার উল্টো ক্রমে।
• Exception হারায় না: শরীরে exception আর close-এও exception হলে আসলটি ছোড়া হয়, close-এরটি suppressed হিসেবে তার সাথে যুক্ত থাকে (getSuppressed())। পুরোনো finally-পদ্ধতিতে close-এর exception আসলটিকে ঢেকে দিত।

ঝালিয়ে নিন: পর্ব ২৯, পর্ব ৩৭ · ফাইল I/O

পূর্ণ মডেল উত্তর অংশ ২-এর ডায়াগ্রামে ধাপে ধাপে দেখানো হয়েছে। এখানে মূল টেবিল আর কয়েকটি বাড়তি তথ্য, যা ভালো উত্তরকে আলাদা করে:

বাড়তি তথ্য: ArrayList ভরে গেলে প্রায় দেড়গুণ বড় নতুন array বানিয়ে কপি করে — তাই একটি add মাঝে মাঝে O(n), কিন্তু গড়ে O(1) (amortized). আকার আগে জানা থাকলে new ArrayList<>(1000). দুটির কোনোটিই thread-safe নয়।

উপসংহার: ডিফল্ট ArrayList; queue বা stack হিসেবে ArrayDeque. LinkedList-এর আসল সুবিধা শুধু তখন, যখন iterator দিয়ে হাঁটতে হাঁটতে অনেক যোগ-বাদ করতে হয় — বাস্তবে বিরল।

ঝালিয়ে নিন: পর্ব ৩০ · ArrayList আর LinkedList, পর্ব ৩২ · Queue ও Deque

তিনটিই Map — key-value জোড়া, প্রতিটি key একবার। পার্থক্য ভেতরের গঠন আর ক্রমে।

HashMap কীভাবে কাজ করে: put(k, v)-এ (১) k.hashCode() থেকে একটি hash বের হয়, যার ওপরের bit নিচে মিশিয়ে নেওয়া হয়; (২) hash থেকে array-র একটি ঘর (bucket) বাছা হয়; (৩) ঘরে আগে থেকে entry থাকলে equals দিয়ে মেলানো হয় — মিললে মান বদলায়, না মিললে একই ঘরে যোগ হয় (collision). ডিফল্ট শুরুর ধারণক্ষমতা ১৬, load factor ০.৭৫ — উপাদান ধারণক্ষমতার ৭৫%-এর বেশি হলে array দ্বিগুণ হয় আর সব entry নতুন ঘরে যায় (rehashing). Java 8 থেকে একটি ঘরে অনেক entry জমলে (প্রায় ৮টির বেশি, আর table-এ অন্তত ৬৪টি ঘর থাকলে; ছোট table হলে আগে array বড় করা হয়) linked list-কে tree-তে বদলানো হয়, ফলে খারাপ ক্ষেত্রেও খোঁজা মোটামুটি O(log n).

উপসংহার: ডিফল্ট HashMap; সাজানো ক্রম বা পরিসর খুঁজতে TreeMap; ঢোকানোর ক্রম রাখতে (যেমন রিপোর্টে কলামের ক্রম) LinkedHashMap. একাধিক thread-এ ConcurrentHashMap — পুরোনো Hashtable নয়। আর মনে রাখুন: HashMap-এর ক্রমের ওপর নির্ভর করে লেখা কোড বা আউটপুট ভুল।

ঝালিয়ে নিন: পর্ব ৩১ · Set আর Map, পর্ব ২৩ · equals ও hashCode

পদ্ধতি: frequency count-এর জন্য Map; বর্ণানুক্রমে ছাপাতে হবে বলে TreeMap. merge(key, 1, Integer::sum) এক লাইনে কাজ সারে — key না থাকলে 1 বসায়, থাকলে পুরোনো মানের সাথে 1 যোগ করে।

import java.util.Collections;
import java.util.Map;
import java.util.TreeMap;

class Main {
    public static void main(String[] args) {
        String text = "the cat and the hat and the bat";
        Map<String, Integer> freq = new TreeMap<>();   // key বর্ণানুক্রমে
        for (String w : text.split("\\s+")) {
            freq.merge(w, 1, Integer::sum);             // নেই হলে 1, থাকলে +1
        }
        System.out.println(freq);

        String top = Collections.max(freq.entrySet(), Map.Entry.comparingByValue()).getKey();
        System.out.println("most frequent: " + top);

        Map<Character, Integer> chars = new TreeMap<>();
        for (char ch : "banana".toCharArray()) chars.merge(ch, 1, Integer::sum);
        System.out.println(chars);
    }
}

ঝালিয়ে নিন: পর্ব ৩১ · HashMap, TreeMap

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

record Student(String name, int roll, double gpa) implements Comparable<Student> {
    @Override
    public int compareTo(Student other) {        // স্বাভাবিক ক্রম: roll
        return Integer.compare(roll, other.roll);
    }
}

class Main {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>(List.of(
            new Student("Karim", 3, 3.50), new Student("Ayesha", 1, 3.90),
            new Student("Rafi", 2, 3.50), new Student("Mitu", 4, 3.75)));

        Collections.sort(list);                  // Comparable ব্যবহার করে
        list.forEach(s -> System.out.print(s.roll() + ":" + s.name() + " "));
        System.out.println();

        list.sort(Comparator.comparingDouble(Student::gpa).reversed()
                            .thenComparing(Student::name));   // Comparator
        list.forEach(s -> System.out.print(s.gpa() + ":" + s.name() + " "));
        System.out.println();
    }
}

উপসংহার: একটি স্বাভাবিক, সবার মেনে নেওয়া ক্রম থাকলে Comparable (সংখ্যা, তারিখ, roll); পরিস্থিতিভেদে আলাদা ক্রম হলে Comparator. compareTo-কে equals-এর সাথে সামঞ্জস্যপূর্ণ রাখুন — নইলে TreeSet দুটি আলাদা object-কে “একই” ভেবে একটি বাদ দিতে পারে।

ঝালিয়ে নিন: পর্ব ৩৩ · Comparable আর Comparator

Functional interface হলো ঠিক একটি abstract method-ওয়ালা interface — যেমন Runnable, Comparator, Predicate<T>, Function<T,R>. @FunctionalInterface লিখলে compiler শর্তটি পাহারা দেয়। Lambda (Java 8) হলো সেই একটি method-এর সংক্ষিপ্ত, নামহীন বাস্তবায়ন: (a, b) -> a + b.

Predicate<Integer> pass = m -> m >= 40;
Function<String, Integer> len = String::length;      // unbound instance method
Supplier<List<String>> maker = ArrayList::new;       // constructor
Function<String, Integer> parse = Integer::parseInt; // static method
Consumer<String> out = System.out::println;          // নির্দিষ্ট object-এর method

নিয়ম: lambda বাইরের local ভ্যারিয়েবল ব্যবহার করতে পারে কেবল যদি সেটি final বা effectively final হয়। lambda-র ভেতরে this মানে বাইরের object — anonymous class-এর মতো নতুন object নয়।

উপসংহার: lambda কোডকে ডেটার মতো পাঠাতে দেয় — sort-এর নিয়ম, filter-এর শর্ত, পরে চলবে এমন কাজ। লম্বা lambda-কে নাম দেওয়া method-এ সরিয়ে method reference দিয়ে ডাকলে পড়া সহজ হয়।

ঝালিয়ে নিন: পর্ব ৩৪ · lambda, functional interface আর method reference

Stream (Java 8) হলো ডেটার ওপর ধাপে ধাপে কাজের একটি পাইপলাইন; এটি ডেটা রাখে না, আর একবারই ব্যবহার করা যায়। Intermediate operation (filter, map, sorted) নতুন stream ফেরত দেয় এবং lazy — terminal না আসা পর্যন্ত কিছুই চলে না। Terminal operation (collect, forEach, count, sum) পাইপলাইন চালিয়ে ফল দেয়।

import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

record Sale(String region, String item, int qty, long priceTaka) {
    Sale {
        if (qty <= 0 || priceTaka < 0) throw new IllegalArgumentException("invalid sale");
    }
    long total() { return qty * priceTaka; }
}

class Main {
    public static void main(String[] args) {
        List<Sale> sales = List.of(
            new Sale("Dhaka", "Pen", 10, 10), new Sale("Khulna", "Book", 2, 250),
            new Sale("Dhaka", "Book", 3, 250), new Sale("Sylhet", "Pen", 5, 10),
            new Sale("Khulna", "Pen", 20, 10));

        Map<String, Long> byRegion = sales.stream().collect(Collectors.groupingBy(
            Sale::region, TreeMap::new, Collectors.summingLong(Sale::total)));
        byRegion.forEach((region, taka) -> System.out.printf("%-7s %5d%n", region, taka));

        Map<String, Long> countByItem = sales.stream().collect(
            Collectors.groupingBy(Sale::item, TreeMap::new, Collectors.counting()));
        System.out.println(countByItem);

        long grand = sales.stream().mapToLong(Sale::total).sum();
        System.out.println("grand total = " + grand);
    }
}

উপসংহার: lazy হওয়ায় filter(…).findFirst() প্রথম মিল পেলেই থামে — পুরো তালিকা ঘোরে না। stream-এর ভেতরে বাইরের ভ্যারিয়েবল বদলানো (side effect) এড়িয়ে চলুন; ফল collect দিয়ে নিন।

ঝালিয়ে নিন: পর্ব ৩৫ · Stream API, পর্ব ২৫ · record

Optional<T> (Java 8) হলো একটি ছোট বাক্স, যাতে হয় একটি মান আছে, নয় খালি। method-এর return type-এ Optional দেখলে ডাকারী বোঝেন “ফল না-ও থাকতে পারে” — null ফেরত দেওয়ার চেয়ে স্পষ্ট।

Optional<User> u = repo.findByPhone("01711000000");
String name = u.map(User::name).orElse("অতিথি");
u.ifPresent(x -> sendSms(x));
User must = u.orElseThrow();          // খালি হলে NoSuchElementException

• ব্যবহার করুন: খুঁজে না-ও পাওয়া যেতে পারে এমন method-এর return type-এ।
• করবেন না: field, method parameter বা collection-এর উপাদান হিসেবে; খালি তালিকার বদলে Optional<List> নয় — খালি তালিকাই ফেরত দিন।
• ফাঁদ: opt.get() যাচাই ছাড়া ডাকা আসলে null-এর পুরোনো সমস্যাই ফিরিয়ে আনে; Optional ভ্যারিয়েবল নিজে null হওয়া উচিত নয়।

ঝালিয়ে নিন: পর্ব ৩৬ · Optional

Process হলো চলমান একটি প্রোগ্রাম, যার নিজের আলাদা মেমরি (address space) আর OS-এর রিসোর্স আছে। Thread হলো একটি process-এর ভেতরের স্বাধীনভাবে চলা একটি কাজের ধারা; একই process-এর সব thread heap ভাগ করে, কিন্তু প্রত্যেকের নিজের stack থাকে।

উপসংহার: একটি রেস্তোরাঁকে process ভাবুন — নিজের রান্নাঘর, নিজের মজুত। ভেতরের রাঁধুনিরা thread — একই রান্নাঘর ভাগ করেন, তাই একই চুলা নিয়ে ধাক্কা এড়াতে নিয়ম (lock) লাগে।

ঝালিয়ে নিন: পর্ব ৪০ · thread আর synchronization

তিনটিই একাধিক thread-এর মধ্যে ডেটা নিরাপদ রাখার উপায়, কিন্তু দুটি আলাদা সমস্যার আলাদা অংশ সমাধান করে: দৃশ্যমানতা (visibility — এক thread-এর লেখা অন্যটি দেখবে কি না) আর অবিভাজ্যতা (atomicity — কাজের মাঝখানে অন্য thread ঢুকতে পারবে কি না)।

import java.util.concurrent.atomic.AtomicInteger;

class Main {
    private static int syncCount = 0;
    private static final AtomicInteger atomicCount = new AtomicInteger();

    private static synchronized void incrementSync() { syncCount++; }

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 100_000; i++) {
                incrementSync();                 // lock নিয়ে ++
                atomicCount.incrementAndGet();   // lock ছাড়া CAS দিয়ে ++
            }
        };
        Thread t1 = new Thread(task), t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("synchronized: " + syncCount);
        System.out.println("atomic:       " + atomicCount.get());
    }
}

উপসংহার: volatile দিয়ে counter বানানো একটি ক্লাসিক ভুল। অনেক thread একসাথে একটি counter বাড়ালে LongAdder আরও দ্রুত। আর সবচেয়ে ভালো ভাগের অবস্থা হলো যা নেই — immutable object আর thread-এর নিজের ডেটা।

ঝালিয়ে নিন: পর্ব ৪০ · thread আর synchronization

Producer–consumer হলো এমন নকশা, যেখানে এক বা একাধিক thread কাজ তৈরি করে একটি সারিতে রাখে, আর অন্যরা সারি থেকে নিয়ে কাজ করে। মাঝের সারি দুই পক্ষকে আলাদা রাখে — কারও গতি অন্যের ওপর সরাসরি নির্ভর করে না। BlockingQueue-এর put সারি ভরা থাকলে অপেক্ষা করে, take খালি থাকলে অপেক্ষা করে — নিজে wait/notify লিখতে হয় না।

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

class Main {
    static final int POISON = -1;                       // "আর কাজ নেই" সংকেত

    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(2);   // ধারণক্ষমতা ২
        long[] total = {0};

        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) queue.put(i * 100);   // ভরা হলে অপেক্ষা
                queue.put(POISON);
            } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        });

        Thread consumer = new Thread(() -> {
            try {
                while (true) {
                    int order = queue.take();                    // খালি হলে অপেক্ষা
                    if (order == POISON) break;
                    total[0] += order;
                    System.out.println("processed order " + order);
                }
            } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        });

        producer.start();
        consumer.start();
        producer.join();
        consumer.join();
        System.out.println("total = " + total[0]);
    }
}

উপসংহার: একাধিক producer থাকলে ঢোকার ক্রম আর নিশ্চিত থাকে না; একাধিক consumer থাকলে প্রত্যেককে একটি করে poison pill দিতে হয়। বাস্তবে প্রায়ই ExecutorService নিজেই ভেতরে এমন একটি সারি রাখে।

ঝালিয়ে নিন: পর্ব ৪০, পর্ব ৩২ · Queue, পর্ব ৪১ · Executor

Platform thread হলো OS thread-এর একটি পাতলা মোড়ক — প্রতিটি Java thread-এর পেছনে একটি OS thread. Virtual thread (Java 21-এ স্থায়ী, JEP 444) JVM নিজে সামলায়: অনেক virtual thread অল্প কয়েকটি OS thread-এর (carrier thread) ওপর চলে, আর I/O-তে আটকালে JVM তাকে carrier থেকে নামিয়ে অন্যটিকে বসায়।

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.stream.IntStream;

class Main {
    public static void main(String[] args) throws Exception {
        long start = System.nanoTime();
        try (ExecutorService ex = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<Integer>> futures = IntStream.range(0, 10_000)
                .mapToObj(i -> ex.submit(() -> { Thread.sleep(100); return i; }))
                .toList();                                  // ১০,০০০ virtual thread
            long sum = 0;
            for (Future<Integer> f : futures) sum += f.get();
            System.out.println("tasks = " + futures.size() + ", sum = " + sum);
        }
        long ms = (System.nanoTime() - start) / 1_000_000;
        System.out.println("finished in under 5 s? " + (ms < 5000));

        Thread vt = Thread.ofVirtual().unstarted(() -> { });
        Thread pt = Thread.ofPlatform().unstarted(() -> { });
        System.out.println(vt.isVirtual() + " " + pt.isVirtual());
    }
}

উপসংহার: virtual thread কাজকে দ্রুত করে না — অপেক্ষাকে সস্তা করে। CPU-ভারী হিসাবে লাভ নেই। Java 21-এ synchronized block-এর ভেতরে আটকালে virtual thread carrier-এ আটকে থাকে (pinning); Java 24-এ JEP 491 এই সমস্যার বড় অংশ দূর করেছে। আর একসাথে লাখ কাজ database-এ গেলে connection pool-এর সীমা মানতে হয় — দরকার হলে Semaphore.

ঝালিয়ে নিন: পর্ব ৪২ · virtual thread, পর্ব ৪১

• Heap: সব object আর array; সব thread ভাগ করে। GC এখানে কাজ করে। প্রচলিত collector-এ ভাগ: young generation (Eden + survivor) আর old generation.
• Stack (প্রতি thread-এ একটি): প্রতিটি method ডাকে একটি stack frame — local ভ্যারিয়েবল, parameter, অস্থায়ী মান। primitive local সরাসরি এখানে, object-এর শুধু reference. গভীর recursion-এ StackOverflowError.
• Metaspace: class-এর metadata (Java 8 থেকে; আগে PermGen); heap-এর বাইরে native মেমরিতে।
• অন্যান্য: প্রতি thread-এর program counter, native method stack, আর JIT-এর বানানো machine code রাখার code cache.

Garbage collection: GC খুঁজে বের করে কোন object আর পৌঁছানো যায় না — GC root (চলমান thread-এর local ভ্যারিয়েবল, static field ইত্যাদি) থেকে reference ধরে হেঁটে। যাদের কাছে পৌঁছানো যায় না, তাদের মেমরি ফেরত নেওয়া হয়। বেশিরভাগ object অল্প সময় বাঁচে (generational hypothesis), তাই নতুন object-এর young এলাকা ঘন ঘন আর দ্রুত পরিষ্কার হয়; বেশি দিন বাঁচা object old এলাকায় ওঠে।

উপসংহার: Java 9 থেকে বেশিরভাগ ক্ষেত্রে ডিফল্ট collector G1; খুব কম বিরতির জন্য ZGC (Java 21-এ generational ZGC যোগ হয়েছে)। GC থাকলেও memory leak হয় — অপ্রয়োজনীয় object-এর reference কোনো static collection-এ রয়ে গেলে GC তাকে সরাতে পারে না। System.gc() শুধু অনুরোধ, নিশ্চয়তা নয়।

ঝালিয়ে নিন: পর্ব ৪৪ · JVM মেমরি আর garbage collection, পর্ব ০৫

// বিপজ্জনক: phone = "' OR '1'='1" দিলে সব সারি ফেরত আসে
String sql = "SELECT * FROM users WHERE phone = '" + phone + "'";

// নিরাপদ
String safe = "SELECT id, name FROM users WHERE phone = ?";
try (PreparedStatement ps = conn.prepareStatement(safe)) {
    ps.setString(1, phone);
    try (ResultSet rs = ps.executeQuery()) {
        while (rs.next()) System.out.println(rs.getString("name"));
    }
}

উপসংহার: ব্যবহারকারীর দেওয়া যেকোনো মান থাকলে সবসময় PreparedStatement. তবে ? শুধু মানের জায়গায় বসে — table বা column-এর নাম ? দিয়ে দেওয়া যায় না; সেগুলো একটি অনুমোদিত তালিকা থেকে যাচাই করে বসাতে হয়। Connection, Statement, ResultSet — সব try-with-resources-এ।

ঝালিয়ে নিন: পর্ব ৪৯ · JDBC আর ডেটাবেস

Dependency injection মানে একটি object তার দরকারি অন্য object নিজে new দিয়ে বানায় না; বাইরে থেকে (সাধারণত constructor দিয়ে) পায়। Spring-এর container এই object-গুলো (bean) বানায়, জোড়ে আর জীবনচক্র সামলায়। Bean ঘোষণার দুটি প্রধান পথ:

@Service
class OrderService {
    private final PaymentGateway gateway;
    OrderService(PaymentGateway gateway) { this.gateway = gateway; }  // constructor injection
}

@Configuration
class AppConfig {
    @Bean
    Clock clock() { return Clock.system(ZoneId.of("Asia/Dhaka")); }   // JDK-র class
}

উপসংহার: নিজের class-এ @Component পরিবারের stereotype annotation; অন্যের class বা জটিল তৈরি হলে @Bean. constructor injection প্রস্তাবিত — dependency স্পষ্ট, field final রাখা যায়, আর Spring ছাড়াই টেস্টে new OrderService(fakeGateway) লেখা যায়।

ঝালিয়ে নিন: পর্ব ৫০ · Spring Boot-এর শুরু

Idempotent মানে একই অনুরোধ একবার পাঠানো আর দশবার পাঠানোর ফল server-এর অবস্থায় একই। নেটওয়ার্ক ব্যর্থ হলে client নিশ্চিন্তে আবার পাঠাতে পারে কি না — এটাই প্রশ্ন।

প্রসঙ্গ: GET, PUT, DELETE idempotent; POST নয় (দুবার পাঠালে দুটি অর্ডার)। সাধারণ status code: 200 OK, 201 Created (POST-এ নতুন resource, সাথে Location header), 204 No Content, 400 Bad Request, 404 Not Found, 409 Conflict.

উপসংহার: পেমেন্টের মতো POST-কে নিরাপদে আবার পাঠানোর জন্য client একটি অনন্য idempotency key পাঠায়, server সেটি মনে রেখে দ্বিতীয়বার একই কাজ করে না।

ঝালিয়ে নিন: পর্ব ৫১ · Spring Boot দিয়ে REST API

Unit test হলো কোডের একটি ছোট অংশ — সাধারণত একটি method বা class — জানা ইনপুটে প্রত্যাশিত ফল দেয় কি না, স্বয়ংক্রিয়ভাবে যাচাই করার কোড। JUnit 5 তিন অংশে গঠিত: Platform (test চালানোর ভিত্তি), Jupiter (নতুন API), আর Vintage (পুরোনো JUnit 4 test চালানোর জন্য)।

class AccountTest {
    @Test
    void withdrawReducesBalance() throws Exception {
        Account acc = new Account(5000);              // Arrange
        acc.withdraw(2000);                           // Act
        assertEquals(3000, acc.getBalance());         // Assert
    }

    @Test
    void overdrawIsRejected() {
        Account acc = new Account(100);
        assertThrows(InsufficientBalanceException.class, () -> acc.withdraw(500));
    }
}

• গঠন: Arrange–Act–Assert; একটি test-এ একটি আচরণ।
• দরকারি annotation: @Test, @BeforeEach, @ParameterizedTest, @DisplayName.
• ভালো test: দ্রুত, একে অপরের ওপর নির্ভরহীন, প্রতিবার একই ফল; edge case আর ব্যর্থতার পথও যাচাই করে।

ঝালিয়ে নিন: পর্ব ৪৭ · টেস্টিং — JUnit 5, পর্ব ৪৬ · Maven আর Gradle

Singleton হলো এমন একটি class, যার পুরো প্রোগ্রামে ঠিক একটি object থাকবে, আর সেটি পাওয়ার একটি নির্দিষ্ট পথ থাকবে। Gang of Four-এর ২৩টি design pattern-এর একটি (creational).

// ১. Enum — সবচেয়ে সরল; thread-safe, serialization-নিরাপদ
enum AppConfig { INSTANCE; String currency() { return "BDT"; } }

// ২. Holder idiom — প্রথম ব্যবহারের সময় তৈরি (lazy), lock ছাড়াই নিরাপদ
final class IdGenerator {
    private IdGenerator() { }
    private static class Holder { static final IdGenerator INSTANCE = new IdGenerator(); }
    static IdGenerator getInstance() { return Holder.INSTANCE; }
}

কেন নিরাপদ: JVM একটি class-কে ঠিক একবার initialize করে আর সেই কাজ নিজেই synchronize করে। Holder class প্রথমবার getInstance() ডাকা পর্যন্ত লোডই হয় না। পুরোনো double-checked locking-এ field-টি volatile না হলে অর্ধেক-তৈরি object দেখা যেতে পারত — ভাইভায় এটি একটি প্রিয় ফলো-আপ।

সমালোচনা: singleton আসলে একটি global state — যেকোনো জায়গা থেকে ব্যবহার করা যায়, তাই কোন কোড কার ওপর নির্ভর করে তা লুকিয়ে যায়, আর টেস্টে নকল বসানো কঠিন। আধুনিক পথ: Spring-এর মতো DI container-কে বলুন একটিই object বানাতে (Spring bean-এর ডিফল্ট scope singleton), আর সেটি constructor দিয়ে পাঠান।

ঝালিয়ে নিন: পর্ব ৪৮ · design pattern আর clean code, পর্ব ২৪ · enum

try (var server = new ServerSocket(5000);                       // port খুলে listen
     var pool = Executors.newVirtualThreadPerTaskExecutor()) {
    while (true) {
        Socket client = server.accept();                         // client না আসা পর্যন্ত অপেক্ষা
        pool.submit(() -> handle(client));                       // প্রতি সংযোগে একটি virtual thread
    }
}
// handle(): s.setSoTimeout(2_000); UTF-8 দিয়ে BufferedReader/PrintWriter;
//          readLine() == null হলে অন্য প্রান্ত বন্ধ — লুপ শেষ

কীভাবে চলে: ServerSocket একটি port-এ নতুন সংযোগের অপেক্ষা করে। accept() একটি client না আসা পর্যন্ত আটকে থাকে, এলে শুধু সেই client-এর জন্য একটি নতুন Socket দেয়; আসল পড়া-লেখা হয় এই Socket-এর stream দিয়ে। একজন ধীর client যেন বাকিদের আটকে না রাখে, তাই প্রতি সংযোগ আলাদা thread-এ — Java 21-এ virtual thread-এ সহজ ব্লকিং কোডেই হাজারো সংযোগ।

framing: TCP একটি byte-স্রোত। দুবার আলাদা করে লেখা “TEA” আর “DAL” অন্য প্রান্তে একটি read()-এ “TEADAL” হয়ে আসতে পারে। তাই message-এর সীমানা application-কে ঠিক করতে হয় — প্রতিটি message-এর শেষে newline (readLine()), অথবা আগে দৈর্ঘ্য পাঠিয়ে (writeInt + readFully), আর দৈর্ঘ্যের একটি সর্বোচ্চ সীমা যাচাই করে।

timeout: ডিফল্টে socket-এ কোনো timeout নেই — মরা সংযোগে read() চিরকাল অপেক্ষা করে। socket.connect(address, ms) দেয় connect timeout, setSoTimeout(ms) দেয় প্রতি-পড়ার timeout (পার হলে SocketTimeoutException); এর সাথে পুরো request-এর মোট সময়সীমাও রাখা ভালো।

উপসংহার: TCP নির্ভরযোগ্য কিন্তু সীমানাহীন স্রোত, UDP দ্রুত কিন্তু নিশ্চয়তাহীন। নেটওয়ার্ক কোডের তিনটি অভ্যাস — স্পষ্ট framing, প্রতিটি ধাপে timeout, আর client-এর পাঠানো আকারে সীমা।

ঝালিয়ে নিন: পর্ব ৪৩ · নেটওয়ার্কিং — socket, HttpClient আর WebSocket, পর্ব ৪২ · virtual thread

JPA (Jakarta Persistence) object আর টেবিল মেলানোর মানক API; Hibernate তার সবচেয়ে প্রচলিত বাস্তবায়ন, আর Spring Data JPA তার ওপর repository বানায়। Persistence context হলো একটি transaction-এর managed entity-র খাতা: এক id-তে এক object (first-level cache), আর প্রতিটির লোডের সময়ের একটি snapshot.

Dirty checking: commit-এর আগে (flush-এ) Hibernate প্রতিটি managed entity-র বর্তমান মান snapshot-এর সাথে মেলায়, আর যেটা বদলেছে তার জন্য নিজেই UPDATE চালায়। তাই @Transactional method-এ product.setStock(47) লিখলেই যথেষ্ট — save() লাগে না।

N+1 সমস্যা: ১টি query-তে N টি অর্ডার এল, তারপর লুপে প্রতিটির LAZY getCustomer() ছোঁয়ায় আরও একটি করে SELECT — মোট ১ + N. ছোট ডেটায় টের পাওয়া যায় না, ১০০০ অর্ডারে ১০০১টি round trip. সমাধান:

• join fetch — select o from Order o join fetch o.customer, একটি SQL;
• @EntityGraph(attributePaths = "customer") repository method-এ;
• batch fetching — hibernate.default_batch_fetch_size, proxy-গুলো একসাথে in (...) query-তে;
• পড়ার পাতায় DTO projection — শুধু দরকারি কলাম।

সম্পর্ক EAGER করে দেওয়া সমাধান নয় — JPQL query-র পরে Hibernate প্রায়ই আলাদা SELECT চালায়, আর বাকি সব query-তে বাড়তি ডেটা আসে। মনে রাখুন, @ManyToOne আর @OneToOne ডিফল্টে EAGER, তাই সেখানে fetch = FetchType.LAZY স্পষ্ট লিখুন।

উপসংহার: ORM-এর প্রতিটি সুবিধার পেছনে SQL আছে। SQL log চালু রেখে গুনে দেখুন — তালিকা বড় হলে query-র সংখ্যা বাড়লেই সেটা N+1.

ঝালিয়ে নিন: পর্ব ৫২ · Spring Data JPA আর Hibernate, পর্ব ৪৯ · JDBC আর ডেটাবেস

পাসওয়ার্ড সংরক্ষণ: কখনো সরাসরি নয়, MD5 বা SHA-256-এর মতো দ্রুত hash-এও নয় — এগুলো দ্রুত হওয়ার জন্যই বানানো, ফাঁস হওয়া ডেটাবেসে কোটি কোটি অনুমান সস্তা। ব্যবহার করুন salt আর cost factor-সহ ধীর hash — BCrypt, Argon2 বা PBKDF2. Spring-এ:

@Bean
PasswordEncoder passwordEncoder() {
    return PasswordEncoderFactories.createDelegatingPasswordEncoder();   // নতুন hash: {bcrypt}$2a$10$...
}
// সাইন-আপ: hash = encoder.encode(raw);   লগইন: encoder.matches(raw, hash)

প্রতিটি ব্যবহারকারীর আলাদা salt একই পাসওয়ার্ডের hash আলাদা করে, cost factor প্রতিটি অনুমান ব্যয়বহুল করে, আর তুলনা হয় সমান সময়ে (timing attack এড়াতে)।

CSRF আর JWT: CSRF-এর ঝুঁকি আসে কারণ ব্রাউজার cookie নিজে থেকে প্রতিটি request-এ জুড়ে দেয়, অন্য সাইটের পাতা থেকে শুরু হলেও। session cookie-ভিত্তিক সাইটে তাই CSRF token চালু রাখতে হয়। stateless API-তে token যায় Authorization: Bearer header-এ, যা ব্রাউজার নিজে জোড়ে না — অন্য সাইটের request-এ পরিচয়ই থাকে না, তাই সেখানে CSRF বন্ধ রাখা যুক্তিসংগত। কিন্তু JWT cookie-তে রাখলে আবার CSRF সুরক্ষা লাগবে। আর মনে রাখুন, JWT-এর payload এনক্রিপ্ট নয় — যে কেউ পড়তে পারে, শুধু স্বাক্ষরের কারণে বদলাতে পারে না।

উপসংহার: পরিচয় যাচাই আর অনুমতি দুটি আলাদা স্তর; role-এর পাশাপাশি “এটা কি আপনার ডেটা?” পরীক্ষাও নিজে লিখতে হয় (BOLA ঠেকাতে)। নিরাপদ ডিফল্ট রাখুন, আর কোনো সুরক্ষা বন্ধ করলে ঠিক কোন কারণে নিরাপদ, তা বলতে পারুন।

ঝালিয়ে নিন: পর্ব ৫৩ · Spring Security, পর্ব ৫১ · REST API

Sun Microsystems-এ James Gosling-এর নেতৃত্বে একটি দল ১৯৯১ সালে কাজ শুরু করে; প্রথম নাম ছিল Oak. ১৯৯৫ সালে Java নামে প্রকাশ্যে আসে। ২০১০ সালে Oracle, Sun-কে কিনে নেয়। পর্ব ০১

না। int, double-এর মতো primitive type object নয়, আর static method কোনো object ছাড়াই চলে। তবে Java-তে সব কোড কোনো না কোনো class-এর ভেতরে থাকে। পর্ব ০৬

public — JVM বাইরে থেকে ডাকে; static — কোনো object বানানোর আগেই ডাকতে হয়; void — কিছু ফেরত দেয় না (exit code লাগলে System.exit). String[] args-এ আসে command-line argument. পর্ব ০৪

যায় — যেকোনো method-এর মতো। কিন্তু প্রোগ্রাম শুরু করতে JVM শুধু public static void main(String[] args) রূপটিই খোঁজে; বাকিগুলো সাধারণ method, নিজে ডাকতে হয়। পর্ব ০৪

যে method বারবার চলে, চলার সময় তাকে native machine code-এ compile করে, যাতে পরের ডাকগুলো দ্রুত হয়। তাই Java প্রোগ্রাম কিছুক্ষণ চলার পর গতি পায় (warm-up). পর্ব ০৫

int সবসময় ৩২-bit, যেকোনো platform-এ — C-এর মতো compiler-নির্ভর নয়। long ৬৪-bit, আর char ১৬-bit unsigned — একটি UTF-16 code unit. পর্ব ০৬

না। var (Java 10) শুধু local ভ্যারিয়েবলের টাইপ ডান দিক দেখে compile-এর সময় বের করে (type inference); টাইপ তারপর স্থির। field বা parameter-এ var চলে না। পর্ব ০৬

ডিফল্ট সেটিংসে false — Integer cache শুধু −128 থেকে 127; 128-এ দুটি আলাদা object. a.equals(b) true. 127 হলে ==-ও true হতো। পর্ব ০৬

double binary floating point; 0.1 বাইনারিতে ঠিকঠাক লেখা যায় না, তাই যোগফল ছাপে 0.30000000000000004. টাকার হিসাবে BigDecimal বা পয়সায় long; double তুলনায় একটি ছোট সহনসীমা (epsilon). পর্ব ০৭

পূর্ণসংখ্যায় ArithmeticException: / by zero; floating point-এ কোনো exception নেই — ফল Infinity (আর 0.0 / 0 হলে NaN). পর্ব ০৭

&& short-circuit — বাঁ দিক false হলে ডান দিক চালায়ই না; তাই s != null && s.isEmpty() নিরাপদ। & boolean-এ দুই দিকই চালায়, আর পূর্ণসংখ্যায় bitwise AND. পর্ব ০৭

Java 14-এ স্থায়ী switch expression একটি মান ফেরত দেয়, case X -> লেখায় fall-through নেই বলে break লাগে না, আর enum বা sealed টাইপে সব case না ধরলে compiler জানায়। block থেকে মান দিতে yield. পর্ব ১০

না — String immutable; method নতুন String ফেরত দেয়, যা এখানে হারিয়ে গেল। লিখতে হবে s = s.toUpperCase();. নতুনদের খুব সাধারণ ভুল। পর্ব ০৮

Array-তে field arr.length, String-এ method s.length(), collection-এ list.size(). খাতায় তিনটি গুলিয়ে ফেলা খুব প্রচলিত ভুল। পর্ব ১৩

Class নকশা, object সেই নকশা থেকে new দিয়ে বানানো আসল নমুনা — যেমন বাড়ির নকশা আর আসল বাড়ি। একটি class থেকে অনেক object. পর্ব ১৫

বর্তমান object-এর reference. field আর parameter-এর নাম এক হলে আলাদা করতে (this.name = name), আর this(…) দিয়ে একই class-এর আরেকটি constructor ডাকতে। static method-এ this নেই। পর্ব ১৬

পারে। বাইরে থেকে new বন্ধ করতে — singleton, শুধু static method-ওয়ালা utility class, বা of(…)-এর মতো static factory method দিয়ে object বানাতে। পর্ব ১৬

না। constructor inherit হয় না, তাই override-এর প্রশ্নই ওঠে না — final/abstract অর্থহীন; আর এর কাজই একটি object গড়া, তাই static-ও অর্থহীন। লিখলে compile error. পর্ব ১৬

না। subclass-এ একই signature-এর static method লিখলে সেটি method hiding — কোনটি চলবে তা ঠিক হয় reference-এর ঘোষিত টাইপ দেখে, compile-এর সময়; dynamic dispatch হয় না। পর্ব ১৮, পর্ব ২০

parent class-এর constructor ডাকতে (super(…), অবশ্যই প্রথম লাইনে), আর override করা method-এর parent সংস্করণ ডাকতে (super.describe())। না লিখলে compiler নিজে super() বসায়। পর্ব ১৯

Class-এ নেই — একটি class একটিই class extend করে। interface অনেকগুলো implement করা যায়, তাই টাইপের multiple inheritance আছে। কারণ diamond problem এড়ানো (খ-০৭)। পর্ব ১৯

চলার সময় object-এর আসল টাইপ দেখে override করা method বাছাই। Animal a = new Dog(); a.sound(); — ঘোষিত টাইপ Animal, কিন্তু চলে Dog-এর sound(). Java-তে non-static, non-private, non-final method ডিফল্টভাবেই এভাবে চলে। পর্ব ২০

না। parent আর child-এ একই নামের field থাকলে a.name ঘোষিত টাইপ (Animal)-এর field পড়ে — field hiding. শুধু instance method dynamic dispatch পায়; তাই field private রেখে method দিয়ে পড়াই নিরাপদ। পর্ব ২০

subclass-এর object তৈরির সময় super(…) দিয়ে abstract parent-এর constructor চলে আর parent-এর অংশের field (যেমন name) initialize করে। নিয়মটা এক জায়গায় থাকে, প্রতিটি subclass-এ আলাদা লিখতে হয় না। পর্ব ২১

শুধু constant — interface-এর প্রতিটি field আপনাআপনি public static final. instance state রাখা যায় না; এটাই abstract class থেকে মূল পার্থক্য। পর্ব ২১

কোনো method নেই এমন interface, যা শুধু একটি চিহ্ন দেয় — যেমন Serializable, Cloneable, RandomAccess. আজকাল এমন তথ্য দিতে বেশিরভাগ ক্ষেত্রে annotation ব্যবহার হয়। পর্ব ২১

Upcasting (child → parent) আপনাআপনি ও নিরাপদ। Downcasting (parent → child) লিখে করতে হয়, আর object আসলে সেই টাইপের না হলে ClassCastException. আগে if (a instanceof Dog d) দিয়ে যাচাই করুন। পর্ব ২০

String (আর Integer-এর মতো wrapper). কেউ subclass বানিয়ে আচরণ বদলাতে পারলে immutability আর নিরাপত্তার নিশ্চয়তা ভেঙে যেত। পর্ব ১৮

class-এর নাম, @, আর hashCode-এর hexadecimal রূপ — যেমন Point@1b6d3586. সংখ্যাটি চালানো থেকে চালানোয় বদলাতে পারে, তাই এর ওপর নির্ভর করবেন না। record-এ toString আপনাআপনি সুন্দর। পর্ব ২৩

না, জরুরি নয় — আলাদা object-এর hash মিলতে পারে (collision). চুক্তিটি উল্টো দিকে: equals সমান হলে hashCode সমান হতেই হবে। পর্ব ২৩

না — প্রতিটি enum আপনাআপনি java.lang.Enum extend করে, আর Java-তে একটিই parent. তবে enum interface implement করতে পারে, আর প্রতিটি মানের আলাদা method body থাকতে পারে। পর্ব ২৪

অর্থপূর্ণভাবে না — record-এর field final, তাই বদলানো যায় না। বদলানো মান চাইলে নতুন record ফেরত দেয় এমন method লিখুন: Money plus(Money o) { return new Money(paisa + o.paisa); }. পর্ব ২৫

তিনটির একটি: final (আর extend হবে না), sealed (নিজেও সীমিত তালিকা দেবে), বা non-sealed (আবার সবার জন্য খোলা)। record আপনাআপনি final; enum-ও আপনাআপনি final (constant-এর নিজস্ব body থাকলে sealed). পর্ব ২৬

Inner class-এর প্রতিটি object বাইরের class-এর একটি object-এর লুকানো reference রাখে, তাই বাইরের object ছাড়া বানানো যায় না। Static nested class-এ সেই reference নেই। বাইরের object-এর দরকার না হলে static nested — লুকানো reference memory leak-এর কারণ হতে পারে। পর্ব ২৭

না — generics invariant. যেত হলে method-টি সেই তালিকায় একটি Integer ঢুকিয়ে String-এর তালিকা নষ্ট করতে পারত। শুধু পড়ার জন্য নিতে লিখুন List<?> বা List<? extends Object>. পর্ব ২৮

চলে — return-এর মান ঠিক হওয়ার পর, method থেকে বের হওয়ার আগে। finally-তে আবার return লিখলে সেটি try-এর return আর যেকোনো exception — দুটোকেই ঢেকে দেয়, তাই কখনো লিখবেন না। পর্ব ২৯

System.exit() ডাকলে, JVM হঠাৎ বন্ধ বা crash হলে, বা try-এর ভেতরের thread চিরকাল আটকে থাকলে। সাধারণ exception বা return-এ চলে। পর্ব ২৯

Java 7 থেকে এক catch-এ কয়েকটি টাইপ: catch (IOException | SQLException e). নিয়ম: টাইপগুলো একে অপরের subclass হতে পারবে না (তাহলে compile error), আর e আপনাআপনি final. পর্ব ২৯

Collection একটি interface — List, Set, Queue-এর মূল। Collections একটি utility class, যাতে sort, reverse, max, unmodifiableList-এর মতো static method. পর্ব ৩০

List — ক্রম আছে, সূচক আছে, ডুপ্লিকেট চলে। Set — ডুপ্লিকেট নেই। Map — key থেকে value, key অনন্য; Map Collection-এর অংশ নয়। পর্ব ৩১

একটি HashMap দিয়ে — set-এর প্রতিটি উপাদান map-এর key, আর value একটি স্থির dummy object. তাই HashSet-এর নিয়ম (hashCode + equals, ক্রম নিশ্চিত নয়) HashMap-এর মতোই। পর্ব ৩১

iteration চলার সময় collection সরাসরি বদলালে (যেমন for-each-এর ভেতরে list.remove) পরের ধাপে ConcurrentModificationException ছোড়ে। এটি সর্বোচ্চ চেষ্টা, নিশ্চয়তা নয় — কিছু ক্ষেত্রে ধরা পড়ে না। সমাধান iterator.remove() বা removeIf. পর্ব ৩০

না — এর iterator weakly consistent: iteration-এর সময় অন্য thread বদলালেও exception নেই; কিছু বদল দেখা যেতে পারে, কিছু না-ও। তাই একাধিক thread-এ নিরাপদ, কিন্তু “এক মুহূর্তের নিখুঁত ছবি” নয়। পর্ব ৩১

List.of (Java 9) পুরোপুরি unmodifiable — add, remove, set সবেই UnsupportedOperationException, আর null নেয় না। Arrays.asList fixed-size — set চলে কিন্তু add/remove চলে না, আর পেছনের array-র সাথে যুক্ত। পর্ব ৩০

ভেতরে একটি binary heap; ডিফল্টে সবচেয়ে ছোট উপাদান মাথায় (min-heap). offer/poll O(log n), peek O(1). ফাঁদ: for-each বা toString সাজানো ক্রমে দেখায় না — শুধু বারবার poll করলে সাজানো ক্রম পাবেন। পর্ব ৩২

Predicate<T> — T নেয়, boolean দেয়; Function<T,R> — T নেয়, R দেয়; Consumer<T> — নেয়, কিছু দেয় না; Supplier<T> — কিছু নেয় না, T দেয়। পর্ব ৩৪

না — terminal operation-এর পর stream শেষ; আবার ব্যবহার করলে IllegalStateException. দরকার হলে উৎস (list) থেকে নতুন stream বানান। পর্ব ৩৫

map প্রতিটি উপাদানকে একটি উপাদানে বদলায়। flatMap প্রতিটি উপাদান থেকে একটি stream বানিয়ে সবগুলো এক stream-এ চ্যাপ্টা করে — যেমন বাক্যের তালিকা থেকে সব শব্দের এক তালিকা। পর্ব ৩৫

Thread extend করা, Runnable দিয়ে new Thread(task), ফল লাগলে Callable + ExecutorService, আর Java 21-এ virtual thread. বাস্তবে সরাসরি thread নয়, executor-এ কাজ জমা দেওয়াই প্রচলিত। পর্ব ৪০

start() নতুন thread তৈরি করে, আর সেই thread-এ run() চলে। সরাসরি run() ডাকলে নতুন thread হয় না — বর্তমান thread-এই সাধারণ method-এর মতো চলে। একই Thread-এ দুবার start() করলে IllegalThreadStateException. পর্ব ৪০

দুই বা ততোধিক thread একে অপরের ধরে রাখা lock-এর জন্য চিরকাল অপেক্ষা করে — T1 ধরেছে A, চায় B; T2 ধরেছে B, চায় A. সমাধান: সব জায়গায় একই ক্রমে lock নেওয়া (lock ordering), বা tryLock সময়সীমাসহ। পর্ব ৪০

wait() Object-এর method, synchronized-এর ভেতরেই ডাকতে হয়, আর অপেক্ষার সময় lock ছেড়ে দেয়। Thread.sleep() static, কোনো lock ছাড়ে না — শুধু সময় পার করে। আধুনিক কোডে দুটির বদলে প্রায়ই BlockingQueue বা CountDownLatch. পর্ব ৪০

thread আবার ব্যবহার হয় (তৈরির খরচ বাঁচে), একসাথে কতগুলো চলবে তার সীমা থাকে, আর Future দিয়ে ফল ও exception পাওয়া যায়। শেষে shutdown() বা try-with-resources ভুলবেন না। পর্ব ৪১

ভবিষ্যতে আসবে এমন একটি ফল, যার পরে কী হবে তা আগেই জুড়ে রাখা যায়: thenApply (ফল বদলানো), thenCompose (আরেকটি async কাজ), thenCombine (দুটি ফল মেলানো), exceptionally (ভুল সামলানো)। পর্ব ৪১

হয়। GC শুধু পৌঁছানো যায় না এমন object সরায়; অপ্রয়োজনীয় object-এর reference কোথাও রয়ে গেলে সে থেকে যায় — যেমন static collection-এ জমতে থাকা ডেটা, সরানো হয়নি এমন listener, বা thread pool-এ পরিষ্কার না করা ThreadLocal. পর্ব ৪৪

Serialization হলো object-কে byte বা লেখায় (যেমন JSON) রূপান্তর, যাতে ফাইলে রাখা বা নেটওয়ার্কে পাঠানো যায়। transient field Java-র নিজস্ব serialization-এ বাদ পড়ে — যেমন পাসওয়ার্ড বা cache. অবিশ্বস্ত উৎসের ডেটা Java native deserialization-এ পড়া নিরাপত্তার বড় ঝুঁকি; আজ JSON বেশি প্রচলিত। পর্ব ৩৯

চলার সময় একটি class-এর field, method, annotation দেখা আর ডাকা — Spring, JUnit, Jackson এভাবেই কাজ করে। ঝুঁকি: সাধারণ ডাকের চেয়ে ধীর, compile-time যাচাই হারায়, আর private ভেঙে encapsulation নষ্ট করতে পারে। পর্ব ৪৫

দুটিই build tool — dependency নামানো, compile, test, প্যাকেজ। Maven XML (pom.xml) আর নির্দিষ্ট lifecycle মানে; Gradle Kotlin বা Groovy DSL-এ লেখা, বেশি নমনীয়, আর incremental build-এ সাধারণত দ্রুত। পর্ব ৪৬

তিনটি annotation একসাথে: @Configuration (bean-এর উৎস), @EnableAutoConfiguration (classpath দেখে ডিফল্ট সেটআপ) আর @ComponentScan (এই package ও নিচের package-এ component খোঁজা)। পর্ব ৫০

ACID — Atomicity (সব নয়তো কিছুই না), Consistency (নিয়ম ভাঙে না), Isolation (একসাথে চলা transaction একে অপরকে নষ্ট করে না), Durability (commit হলে টিকে থাকে)। JDBC-তে conn.setAutoCommit(false), কাজ শেষে commit(), ভুল হলে rollback(). পর্ব ৪৯

TCP সংযোগভিত্তিক, নির্ভরযোগ্য, ক্রম-ঠিক byte-স্রোত — কিন্তু message-এর সীমানা রাখে না, তাই framing নিজে করতে হয়। UDP সংযোগহীন; প্রতিটি datagram আলাদা message, তবে হারাতে বা উল্টো ক্রমে আসতে পারে। ফলো-আপ: “DNS বা ভিডিও কল কেন UDP?” — দেরিতে আসা ডেটা না আসার সমান, আর handshake-এর খরচ নেই। পর্ব ৪৩

ডিফল্টে timeout নেই — মরা সংযোগে read() চিরকাল আটকে থাকে আর thread নষ্ট হয়। connect timeout (connect(address, ms)), প্রতি-পড়ার timeout (setSoTimeout, পার হলে SocketTimeoutException), আর পুরো request-এর মোট সময়সীমা। HttpClient-এও connectTimeout আর request-এর timeout নিজে দিতে হয়; তার redirect নীতিও ডিফল্টে NEVER. পর্ব ৪৩

JPA (এখন Jakarta Persistence) একটি মানক API — annotation, EntityManager, JPQL; নিজে কোনো SQL চালায় না। Hibernate সেই API-র সবচেয়ে প্রচলিত বাস্তবায়ন; আরেকটি বাস্তবায়নের নাম EclipseLink. Spring Data JPA তার ওপর interface থেকে repository বানায়। পর্ব ৫২

@ManyToOne/@OneToOne ডিফল্টে EAGER, @OneToMany/@ManyToMany LAZY; পরামর্শ — সব LAZY, দরকারি জায়গায় join fetch বা @EntityGraph. LAZY proxy নিজের ডেটা আনতে খোলা persistence context চায়; transaction শেষ হওয়ার পর (যেমন controller-এ) ছুঁলে “no Session” — এই exception. সমাধান EAGER নয়, service-এর ভেতরেই দরকারি ডেটা এনে DTO বানানো। পর্ব ৫২

ডিফল্টে শুধু unchecked exception (RuntimeException, Error)-এ rollback; checked exception-এ commit — দরকারে rollbackFor = Exception.class. Spring proxy দিয়ে কাজ করে, তাই একই class-এর ভেতর থেকে ডাকলে (self-invocation) বা private method-এ annotation নীরবে উপেক্ষিত। ফলো-আপ: “দুজন একসাথে একই স্টক বদলালে?” — @Version দিয়ে optimistic locking; দ্বিতীয় জন OptimisticLockException পায়। পর্ব ৫২

401 Unauthorized মানে authentication ব্যর্থ — পরিচয় জানা যায়নি (token নেই, ভুল বা মেয়াদোত্তীর্ণ)। 403 Forbidden মানে পরিচয় জানা, কিন্তু এই কাজের অনুমতি নেই (authorization ব্যর্থ)। অন্যের ডেটা চাইলে অনেক API 404 দেয়, যাতে ডেটাটির অস্তিত্বই ফাঁস না হয়। পর্ব ৫৩

JSON Web Token (RFC 7519) — header.payload.signature, তিনটি অংশ Base64URL-এ। payload-এ claim (sub, exp, role…) থাকে, আর স্বাক্ষর গোপন key দিয়ে বানানো। এনক্রিপ্ট নয় — যে কেউ পড়তে পারে, তাই গোপন তথ্য রাখা চলে না; কিন্তু key ছাড়া বদলালে স্বাক্ষর মেলে না। মেয়াদ ছোট রাখুন, key কোডের বাইরে, যাচাইয়ে প্রতিষ্ঠিত লাইব্রেরি — Spring-এ OAuth2 Resource Server. পর্ব ৫৩

Cross-Site Request Forgery — লগইন করা অবস্থায় অন্য সাইটের পাতা ব্যবহারকারীর অজান্তে আপনার সাইটে অবস্থা-বদলানো request পাঠায়, আর ব্রাউজার session cookie নিজে থেকে জুড়ে দেয়। cookie-ভিত্তিক লগইনে CSRF token (আর SameSite cookie) লাগে; শুধু Authorization header-এ token পাঠানো stateless API-তে ঝুঁকি নেই, তাই সেখানে বন্ধ রাখা চলে — কিন্তু শুধু এই কারণেই। পর্ব ৫৩