constructor আর this — জন্ম থেকেই বৈধ object

১ · Constructor — object-এর জন্মমুহূর্ত

পর্ব ১৫-এ আপনি class লিখে new দিয়ে object বানিয়েছেন, তারপর একটি একটি করে field-এ মান বসিয়েছেন। একটি দোকানের পণ্যের জন্য সেটা দেখতে এমন:

Product p = new Product();   // এই মুহূর্তে name = null, price = 0.0
p.name = "Chal 5kg";
p.price = 420.0;             // এর আগে কেউ p ব্যবহার করলে?

প্রথম আর তৃতীয় লাইনের মাঝখানে p একটি আধা-তৈরি object: নাম আছে, দাম নেই। কেউ ভুলে দামের লাইনটি না লিখলে প্রোগ্রাম চলবে, আর ক্যাশ মেমোতে ছাপা হবে “Chal 5kg — 0.0 টাকা”. কেউ p.price = -420 লিখলে সেটাও আটকানোর কেউ নেই। Object-এর invariant — যে শর্ত সবসময় সত্য থাকার কথা, যেমন “দাম কখনো ঋণাত্মক নয়” — রক্ষা করার কোনো নির্দিষ্ট জায়গা নেই।

সমাধান হলো একটি বিশেষ method, যা object জন্মানোর মুহূর্তে ঠিক একবার চলে, প্রয়োজনীয় সব মান নেয়, যাচাই করে, তারপর field-এ বসায়। এর নাম constructor. Constructor শেষ না হওয়া পর্যন্ত বাইরের কেউ object-টির reference পায় না — তাই বাইরের দুনিয়া কখনো আধা-তৈরি object দেখে না।

Constructor-এর তিন নিয়ম

class Product {
    String name;
    double price;

    Product(String n, double p) {   // constructor: নাম = class-এর নাম, return type নেই
        name = n;
        price = p;
    }
}

Product p = new Product("Chal 5kg", 420.0);   // জন্মের সময়েই সব মান

যে void নীরবে সব নষ্ট করে

সবচেয়ে ধূর্ত ভুলটি দেখুন। অভ্যাসবশত কেউ constructor-এর সামনে void লিখে ফেলল:

class Product {
    String name;
    void Product(String n) {   // ভুল! এটা এখন একটি সাধারণ method
        name = n;
    }
}

Product p = new Product("Chal 5kg");

Main.java:8: error: constructor Product in class Product cannot be applied to given types;
        Product p = new Product("Chal 5kg");
                    ^
  required: no arguments
  found:    String
  reason: actual and formal argument lists differ in length
1 error

Java-তে method-এর নাম class-এর নামের মতো হওয়া বৈধ (খারাপ রীতি, কিন্তু বৈধ)। তাই void Product(String n) compiler-এর চোখে একটি method, যার নাম ঘটনাক্রমে Product. Class-এ তাহলে কোনো constructor লেখা নেই, আর compiler নিজে একটি argument-হীন constructor দিয়েছে। ফলে new Product("Chal 5kg") মেলে না। আর যদি কেউ new Product() লিখত, কোনো error-ই আসত না — name নীরবে null থেকে যেত। তাই নিয়ম মুখস্থ রাখুন: constructor-এর সামনে কোনো টাইপ নেই।

২ · new চাপলে কী ঘটে — object তৈরির ক্রম

new Product("Chal", 420.0) — এক লাইন, কিন্তু ভেতরে কয়েকটি ধাপ নির্দিষ্ট ক্রমে চলে। এই ক্রম জানা থাকলে অনেক রহস্যময় bug সহজ হয়ে যায়। Constructor ছাড়াও field-এ মান বসানোর আরও দুটি জায়গা আছে: ঘোষণার সাথেই মান দেওয়া (int stock = 10;), আর class-এর ভেতরে একটি নামহীন { … } block, যাকে বলে instance initializer block. তিনটি কোন ক্রমে চলে, নিচে ধাপে ধাপে দেখুন:

1class Product {2    String name;               // initializer নেই3    int stock = 10;            // field initializer4    double price;5    { stock = stock + 5; }     // instance initializer block6    Product(String name, double price) {7        this.name = name;8        this.price = price;9    }10}11Product p = new Product("Chal", 420.0);

একটি ছোট পরীক্ষা: ওপরের class-এ যদি constructor-এর শরীরে stock = 3; লেখা থাকত, শেষে stock কত হতো? উত্তর 3 — কারণ constructor-এর শরীর সবার শেষে চলে, আগের 10 আর 15-কে মুছে দিয়ে। নিয়মটি এক লাইনে: ডিফল্ট মান → (super) → field initializer ও block, লেখার ক্রমে → constructor-এর শরীর।

৩ · Default constructor — কখন আছে, কখন হারায়

পর্ব ১৫-এ আপনি কোনো constructor না লিখেই new Student() লিখেছিলেন, আর সেটা চলেছিল। কারণ: class-এ একটিও constructor না থাকলে compiler নিজে একটি argument-হীন, শরীর-খালি constructor যোগ করে দেয়। একে বলে default constructor. এর access modifier হয় class-এর মতোই — public class হলে সেটাও public. ভেতরে শুধু ওই লুকানো super().

কিন্তু যে মুহূর্তে আপনি নিজে যেকোনো একটি constructor লেখেন, compiler আর কিছু যোগ করে না। যুক্তিটা সহজ: আপনি একটি constructor লিখে জানিয়ে দিয়েছেন “এই object বানাতে এগুলো লাগবেই।” তখন compiler পেছনের দরজা খোলা রাখলে আপনার নিয়ম ভেঙে যেত।

class Ticket {
    String route;
    Ticket(String route) {          // একটি parameterized constructor
        this.route = route;
    }
}

Ticket t = new Ticket();             // আগে চলত, এখন?

Main.java:8: error: constructor Ticket in class Ticket cannot be applied to given types;
        Ticket t = new Ticket();
                   ^
  required: String
  found:    no arguments
  reason: actual and formal argument lists differ in length
1 error

মেসেজটি পড়তে শিখুন, কারণ এটি বারবার দেখবেন। required: String — যে constructor আছে, সে একটি String চায়। found: no arguments — আপনি কিছুই দেননি। একাধিক constructor থাকলে javac প্রতিটির তালিকা দিয়ে বলে no suitable constructor found for Ticket(no arguments). সমাধান দুটি: হয় সঠিক argument দিন, নয়তো সত্যিই argument ছাড়া object বানানো অর্থপূর্ণ হলে নিজে একটি argument-হীন constructor লিখুন। নিজে লেখা argument-হীন constructor-কে প্রায়ই no-arg constructor বলা হয়; “default constructor” নামটি কঠোরভাবে শুধু compiler-এর বানানোটির জন্য।

যে constructor parameter নেয়, তাকে বলে parameterized constructor. বেশিরভাগ বাস্তব class-এ এটিই প্রধান constructor, কারণ বেশিরভাগ object-এর অন্তত কিছু তথ্য ছাড়া কোনো অর্থ নেই — নামহীন পণ্য, রুটহীন টিকিট।

৪ · this — “আমি যে object-এর ভেতরে আছি”

একটি class থেকে হাজারটা object তৈরি হতে পারে, কিন্তু method আর constructor-এর কোড একটিই। তাহলে name = … লিখলে কোন object-এর name বদলায়? উত্তর: যে object-এর ওপর এই মুহূর্তে কোডটি চলছে। প্রতিটি instance method আর constructor একটি লুকানো reference পায়, যা সেই object-কে দেখায়। Java-তে তার নাম this.

সবচেয়ে সাধারণ ব্যবহার — নামের সংঘাত মেটানো

অংশ ১-এ parameter-এর নাম ছিল n আর p — পড়তে অস্বস্তিকর। স্বাভাবিক ইচ্ছা হলো parameter-এর নামও name আর price রাখা। কিন্তু তখন constructor-এর ভেতরে name বললে দুটি জিনিস বোঝাতে পারে: field, অথবা parameter. Java-র নিয়ম: ভেতরের scope-এর নাম বাইরেরটাকে ঢেকে দেয়। Parameter ভেতরের, তাই সাধারণ name মানে parameter. একে বলে shadowing. Field-এ পৌঁছাতে হলে বলতে হয় this.name — “এই object-এর name”. নিচে দেখুন this ভুলে গেলে কী ঘটে:

Customer(String name) {
    name = name;        // কোন name কোনটা?
}

constructor-এর frame        heap-এর object
┌──────────────────┐        ┌─────────────────────┐
│ name = "Rahim"   │        │ this.name = null    │
└──────────────────┘        └─────────────────────┘
দুটি আলাদা name — parameter আর field

constructor-এর frame        heap-এর object
┌──────────────────┐        ┌─────────────────────┐
│ name = "Rahim"   │◀─┐     │ this.name = null    │
└──────────────────┘  │     └─────────────────────┘
           └──নিজেকে নিজে─┘
দুই পাশের name-ই parameter; field-এ কেউ হাত দেয়নি

constructor-এর frame        heap-এর object
   (মুছে গেছে)              ┌─────────────────────┐
                            │ this.name = null    │
                            └─────────────────────┘
c.greet()  →  Hello, null
compile error নেই, crash নেই — শুধু ভুল ফল

Customer(String name) {
    this.name = name;   // বাঁয়ে field, ডানে parameter
}

constructor-এর frame        heap-এর object
┌──────────────────┐ কপি   ┌─────────────────────┐
│ name = "Rahim"   │──────▶│ this.name = "Rahim" │
└──────────────────┘        └─────────────────────┘
c.greet()  →  Hello, Rahim

this নিয়ে আরও তিনটি তথ্য। (১) যেখানে নামের সংঘাত নেই, সেখানে this. ঐচ্ছিক — price * qty আর this.price * this.qty একই জিনিস। (২) static method-এ কোনো object নেই, তাই this-ও নেই; main-এর ভেতরে this লিখলে javac বলে non-static variable this cannot be referenced from a static context (পর্ব ১৮)। (৩) this একটি সাধারণ reference — তাকে অন্য কোথাও পাঠানো বা ফেরত দেওয়া যায়, যা অংশ ৭-এ দেখবেন।

৫ · Constructor overloading আর this(...) chaining

বাস কাউন্টারে টিকিট কাটার কয়েকটি উপায় আছে। কেউ শুধু বলেন “একটা টিকিট দেন” — তখন ডিফল্ট রুট, যেকোনো সিট। কেউ বলেন “খুলনার টিকিট” — রুট আছে, সিট যেকোনো। কেউ বলেন “খুলনা, সিট বারো”। পর্ব ১২-এর method overloading-এর মতোই একটি class-এ একাধিক constructor রাখা যায়, যদি তাদের parameter-তালিকা আলাদা হয়। একে বলে constructor overloading.

কিন্তু তিনটি constructor-এ যদি তিনবার একই যাচাই আর একই assignment লেখেন, তাহলে কোনো নিয়ম বদলালে তিন জায়গায় বদলাতে হবে। সমাধান: একটি constructor-কে “আসল” বানান, যেটি সব কাজ করে; বাকিরা ডিফল্ট মান জুড়ে তাকে কাজ দিয়ে দেয়। একই class-এর আরেক constructor ডাকার উপায় হলো this(...), আর এই কৌশলের নাম constructor chaining. চালিয়ে দেখুন কোন ক্রমে লাইন ছাপা হয়:

class Ticket {
    final String route;
    final int seat;                          // 0 মানে যেকোনো সিট
    Ticket() {
        this("Dhaka-Sylhet");                // প্রথম statement হতেই হবে
        System.out.println("3: Ticket()");
    }
    Ticket(String route) {
        this(route, 0);
        System.out.println("2: Ticket(route)");
    }
    Ticket(String route, int seat) {
        System.out.println("1: Ticket(route, seat)");
        this.route = route;  this.seat = seat;
    }
}
class Main {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        System.out.println(t.route + ", seat " + t.seat);
    }
}

ধাপে ধাপে দেখুন constructor-গুলো কীভাবে একটির ভেতরে আরেকটি খোলে, আর উল্টো ক্রমে শেষ হয়:

1Ticket() {2    this("Dhaka-Sylhet");3    System.out.println("3: Ticket()");4}5Ticket(String route) {6    this(route, 0);7    System.out.println("2: Ticket(route)");8}9Ticket(String route, int seat) {10    System.out.println("1: Ticket(route, seat)");11    this.route = route;12    this.seat = seat;13}14Ticket t = new Ticket();

this(...)-এর নিয়ম

• প্রথম statement হতেই হবে। this(...)-এর আগে একটি println লিখলে Java 21-এ javac বলে call to this must be first statement in constructor. যুক্তি: অন্য constructor object-টিকে প্রস্তুত করার আগে এই constructor তার ওপর কাজ শুরু করলে আধা-তৈরি object ব্যবহারের ঝুঁকি। (পরের সংস্করণে এই নিয়ম কিছুটা শিথিল হয়েছে: Java 22–24-এ preview হিসেবে, আর Java 25-এ JEP 513-এর মাধ্যমে স্থায়ীভাবে। এখন যে statement তৈরি-হতে-থাকা object-টি ব্যবহার করে না — যেমন argument যাচাই — সেটা this(...) বা super(...)-এর আগে লেখা যায়। এই কোর্স Java 21-এ, তাই আপাতত পুরোনো নিয়মই মানুন।)
• একটি constructor-এ বড়জোর একটি this(...) — আর this(...) ও super(...) একসাথে নয়, কারণ দুটিই প্রথম হতে চায়।
• বৃত্ত চলবে না। A যদি B-কে আর B যদি A-কে ডাকে, javac বলে recursive constructor invocation — compile-এর সময়েই ধরা পড়ে।
• সাধারণত ছোট থেকে বড় দিকে ডাকুন: কম parameter-এর constructor ডিফল্ট মান জুড়ে বেশি parameter-এর constructor-কে ডাকে, আর সবচেয়ে বড়টি আসল কাজ করে।

৬ · যাচাই — অবৈধ object জন্মাতেই দেবেন না

এবার constructor-এর আসল শক্তি। পণ্যের দাম ঋণাত্মক হতে পারে না, নাম ফাঁকা হতে পারে না, স্টক শূন্যের কম হতে পারে না। এই শর্তগুলো constructor-এ যাচাই করলে, আর ভুল হলে object তৈরিই বন্ধ করে দিলে, পুরো প্রোগ্রামে কোথাও একটি অবৈধ Product থাকার সম্ভাবনাই থাকে না। বন্ধ করার উপায় হলো একটি exception ছোড়া — Java-তে ভুল argument-এর জন্য প্রচলিত exception হলো IllegalArgumentException:

class Product {
    private final String name;
    private final double price;
    private final int stock;
    Product(String name, double price, int stock) {
        if (name == null || name.isBlank()) throw new IllegalArgumentException("name is empty");
        if (price < 0) throw new IllegalArgumentException("price < 0: " + price);
        if (stock < 0) throw new IllegalArgumentException("stock < 0: " + stock);
        this.name = name;
        this.price = price;
        this.stock = stock;
    }
    @Override public String toString() { return name + " | " + price + " tk | stock " + stock; }
}
class Main {
    public static void main(String[] args) {
        System.out.println(new Product("Chal 5kg", 420.0, 30));
        try { new Product("Dal 1kg", -150, 10); }
        catch (IllegalArgumentException e) { System.out.println("Rejected: " + e.getMessage()); }
    }
}

এই কৌশলের নাম fail-fast: ভুল যত আগে, যত কাছে ধরা পড়ে, খুঁজে পাওয়া তত সহজ। দাম −150 যদি চুপচাপ ঢুকে যেত, ভুলটা ধরা পড়ত হয়তো মাসের শেষে হিসাব না মেলায় — তখন কোন লাইন থেকে এলো, খুঁজে পাওয়া কঠিন। Exception message-এ খারাপ মানটিও রাখুন ("price < 0: " + price) — পরে log পড়তে সুবিধা হয়।

final field — constructor-কে বাধ্য করা

ওপরের field তিনটি final. final field-এ ঠিক একবার মান দিতে হয় — ঘোষণার সাথে, অথবা প্রতিটি constructor-এর প্রতিটি পথে। কোনো constructor কোনো final field-এ মান দিতে ভুলে গেলে javac সেই constructor-এর শেষে বলে variable price might not have been initialized. তাই অংশ ৪-এর name = name ভুলটি final field-এ হলে compile-এর সময়েই ধরা পড়ত — নীরব bug হয়ে থাকত না। আর জন্মের পরে কেউ p.price = -5 লিখতে চাইলে সেটাও compile error. final-এর পুরো গল্প পর্ব ১৮-এ।

৭ · this পাঠানো আর this ফেরত দেওয়া

নিজেকে অন্য method-এ পাঠানো

this যেহেতু একটি সাধারণ reference, object নিজেকে argument হিসেবে অন্য কারও কাছে পাঠাতে পারে। যেমন টিকিট নিজেই কাউন্টারের খাতায় নিজের নাম তোলে:

class Ticket {
    void book(Counter counter) {
        counter.register(this);   // “আমাকে খাতায় তোলো”
    }
}

এটা পুরোপুরি স্বাভাবিক — event listener, observer আর parent-child সম্পর্কে (যেমন একটি Order তার প্রতিটি OrderItem-কে নিজের reference দিয়ে রাখে) এর ব্যবহার সবখানে। শুধু একটি সতর্কতা: constructor-এর ভেতর থেকে this বাইরে পাঠাবেন না। তখনো constructor শেষ হয়নি, কিছু field হয়তো এখনো মান পায়নি — অথচ বাইরের কেউ object-টির reference পেয়ে গেল। অংশ ২-এর “আধা-তৈরি object বাইরে আসে না” প্রতিশ্রুতি আপনি নিজেই ভাঙলেন। একাধিক thread থাকলে (পর্ব ৪০) এটা বিশেষ বিপজ্জনক।

নিজেকে ফেরত দেওয়া — method chaining

পিৎজা অর্ডারের কথা ভাবুন: সাইজ বাধ্যতামূলক, টপিং যত খুশি, চিজ ঐচ্ছিক। প্রতিটি বিকল্পের জন্য constructor বানালে অসংখ্য constructor লাগবে। তার বদলে সাইজ constructor-এ নিন, আর বাকি প্রতিটি method কাজ শেষে return this; করুক — অর্থাৎ নিজেকেই ফেরত দিক:

class Pizza {
    private final String size;
    private final List<String> toppings = new ArrayList<>();
    private boolean cheese;

    Pizza(String size) { this.size = size; }

    Pizza addTopping(String t) { toppings.add(t); return this; }
    Pizza addCheese()          { cheese = true;   return this; }

    int total() {
        int base = size.equals("Large") ? 800 : 600;
        return base + toppings.size() * 80 + (cheese ? 100 : 0);
    }
}

এখন প্রতিটি ডাকের ফল আবার একই Pizza, তাই তার ওপর সরাসরি পরের method ডাকা যায় — এটাই method chaining. যখন পুরো API এভাবে বাক্যের মতো পড়ার জন্য নকশা করা হয়, তাকে বলে fluent interface. ধাপে ধাপে দেখুন প্রতিটি ডাক কী ফেরত দেয়:

1Pizza p = new Pizza("Medium")2        .addTopping("Chicken")3        .addTopping("Olive")4        .addCheese();5System.out.println(p.total());

একটি সূক্ষ্ম কথা: এখানে প্রতিটি method একই object বদলায় (mutable). String-এর মতো immutable class-এ chaining দেখতে একই রকম — s.trim().toUpperCase() — কিন্তু সেখানে প্রতিটি ধাপ একটি নতুন object ফেরত দেয়, this নয়। আর Pizza-র আরেকটি দুর্বলতা আছে: size-এর মতো বাধ্যতামূলক মান অনেকগুলো হলে constructor আবার লম্বা হয়ে যায়। তার সমাধান builder — পরের অংশে।

৮ · কপি, factory, builder আর record

সাধারণ constructor সব প্রয়োজন মেটায় না। পেশাদার Java কোডে object তৈরির আরও চারটি ধরন বারবার দেখবেন — এখানে এক ঝলক, যাতে চিনতে পারেন।

Copy constructor — clone নয়

একটি পণ্যের হুবহু আরেকটি কপি চাই। পর্ব ১৩ আর ১৫-এ দেখেছেন, Product b = a; কপি বানায় না — দুটি ভ্যারিয়েবল একই object দেখায় (aliasing). Java-তে প্রচলিত উপায় হলো copy constructor — একটি constructor যে একই class-এর আরেকটি object নেয়:

Product(Product other) {
    this(other.name, other.price, other.stock);   // যাচাই-সহ আসল constructor-কে কাজ দিলাম
}

Product copy = new Product(original);

Java-র Object class-এ একটি clone() method আছে, আর নতুনরা প্রায়ই সেটাই খোঁজেন। কিন্তু অভিজ্ঞ Java প্রোগ্রামাররা সাধারণত এড়িয়ে চলেন: clone ব্যবহার করতে Cloneable নামের একটি অদ্ভুত interface লাগে যাতে কোনো method নেই, clone নিজে protected, ফেরত দেয় Object (cast লাগে), কোনো constructor না ডেকেই object বানায় — ফলে আপনার যাচাই এড়িয়ে যায় — আর ডিফল্টভাবে shallow copy করে। Joshua Bloch-এর Effective Java বইয়ে (Item 13) clone-এর সমস্যাগুলো বিস্তারিত বলা আছে, আর সুপারিশ হলো copy constructor বা copy factory. লক্ষ রাখুন, copy constructor-ও নিজে থেকে deep copy করে না: field-এ যদি একটি List থাকে, নতুন list বানিয়ে কপি করতে হবে, নইলে দুটি object একই list ভাগ করবে।

Static factory method — নাম-ওয়ালা constructor

আপনি ইতিমধ্যে অনেক ব্যবহার করেছেন: List.of(1, 2, 3), Integer.valueOf("42"), String.valueOf(3.5), পরে দেখবেন LocalDate.of(2026, 10, 18). এগুলো constructor নয় — static method, যা ভেতরে object বানিয়ে (বা আগের একটি ফেরত দিয়ে) দেয়। একে বলে static factory method. সুবিধা: নাম থাকে (Temperature.ofCelsius(30) বনাম Temperature.ofFahrenheit(86) — দুটিই একটি double নেয়, constructor দিয়ে আলাদা করা অসম্ভব), প্রতিবার নতুন object বানাতে হয় না (Integer.valueOf −128 থেকে 127 পর্যন্ত আগের object ফেরত দেয়), আর ফেরত দেওয়া object-এর আসল class লুকিয়ে রাখা যায়। প্রচলিত নাম: of, valueOf, from, getInstance, newInstance. প্রায়ই constructor-কে private রেখে শুধু factory খোলা রাখা হয় (পর্ব ১৭, ১৮)।

Builder — অনেক parameter হলে

একটি বাস রিজার্ভেশনে রুট, তারিখ, সময়, সিট, যাত্রীর নাম, ফোন, এসি না নন-এসি, খাবার, ছাড়… দশটি parameter. Constructor-এ new Booking("Dhaka-Khulna", d, t, 12, "Rina", "017…", true, false, 0) — কোন true কোনটা, কেউ মনে রাখতে পারে না। প্রতিটি ঐচ্ছিক সমন্বয়ের জন্য আলাদা constructor বানালে সেগুলো ক্রমশ লম্বা হতে থাকে — একে বলে telescoping constructor. সমাধান builder pattern:

Booking b = Booking.builder()
        .route("Dhaka-Khulna")
        .seat(12)
        .passenger("Rina")
        .ac(true)
        .build();          // এখানে সব যাচাই, তারপর একবারে object

খেয়াল করুন, এটা অংশ ৭-এর method chaining-ই, কিন্তু একটি পার্থক্যসহ: chaining হয় একটি আলাদা builder object-এর ওপর, আর আসল Booking জন্মায় শুধু build()-এ, সব যাচাই পার হওয়ার পরে। তাই আসল object-কে immutable রাখা যায়, আর কখনো আধা-তৈরি অবস্থায় দেখা যায় না। পুরো নকশা পর্ব ৪৮-এ।

Record — constructor নিজেই তৈরি হয়

যে class শুধু কয়েকটি মান বহন করে, তার জন্য Java 16 থেকে record আছে। record Point(int x, int y) {} লিখলেই compiler দুটি private final field, সব field নেওয়া একটি constructor (একে বলে canonical constructor), x() আর y() accessor, আর equals, hashCode, toString বানিয়ে দেয়। যাচাই চাইলে একটি ছোট “compact” constructor লেখা যায়:

record Price(double amount) {
    Price {                                   // compact constructor: parameter-তালিকা নেই
        if (amount < 0) throw new IllegalArgumentException("amount < 0");
    }                                         // field-এ assignment compiler নিজে করে
}

Record-এর পুরো আলোচনা পর্ব ২৫-এ। এখানে শুধু লক্ষ করুন, ভাষার নকশাকারেরাও একই সিদ্ধান্তে পৌঁছেছেন: সব মান constructor-এ, যাচাই constructor-এ, তারপর আর বদল নয়।

৯ · Java-তে destructor নেই — তাহলে পরিষ্কার করে কে?

C++-এ প্রতিটি constructor-এর একটি জোড়া আছে — destructor (~Product()), যা object-এর জীবন শেষে নিশ্চিতভাবে চলে আর মেমরি, ফাইল, lock সব ফেরত দেয়। Java-তে এমন কিছু নেই। কারণ মেমরির দায়িত্ব প্রোগ্রামারের নয়, JVM-এর: যখন কোনো object-এর দিকে আর কোনো reference থাকে না, garbage collector একসময় তার জায়গা ফেরত নেয় (পর্ব ৫, বিস্তারিত পর্ব ৪৪)। কখন নেবে, তা নির্দিষ্ট নয় — এক সেকেন্ড পরে, এক ঘণ্টা পরে, বা প্রোগ্রাম শেষ হওয়া পর্যন্ত কখনোই না।

মেমরির জন্য এটা চমৎকার। কিন্তু খোলা ফাইল, ডেটাবেস connection বা network socket অপারেটিং সিস্টেমের সীমিত সম্পদ — সেগুলো “একসময়” নয়, কাজ শেষ হওয়া মাত্র বন্ধ করা দরকার। Java-র উত্তর হলো try-with-resources (Java 7 থেকে):

try (var reader = Files.newBufferedReader(Path.of("bill.txt"))) {
    System.out.println(reader.readLine());
}   // এখানে reader.close() নিশ্চিতভাবে চলে — exception হলেও

এটা পর্ব ২৯ আর ৩৭-এ বিস্তারিত দেখবেন। তার আগে একটি পুরোনো জিনিস চিনে রাখুন: finalize(). Java 1.0 থেকে Object-এ এই method ছিল, যা GC object সরানোর আগে ডাকতে পারত। অনেকে একে destructor ভেবে ব্যবহার করতেন — কিন্তু কখন চলবে বা আদৌ চলবে কি না, তার কোনো নিশ্চয়তা ছিল না। Java 9-এ এটি deprecated হয়, আর Java 18-এ JEP 421 একে “deprecated for removal” ঘোষণা করে — অর্থাৎ ভবিষ্যতের কোনো সংস্করণে সরিয়ে ফেলা হবে। নতুন কোডে কখনো finalize লিখবেন না।

১০ · AI-এর যুগে — constructor-এর প্রতিশ্রুতি যাচাই করুন

AI-কে “একটি Product class লিখে দাও” বললে সে প্রায় সবসময় compile হয় এমন কোড দেয়। সমস্যা compile-এ নয়, প্রতিশ্রুতিতে: AI-এর লেখা constructor প্রায়ই শুধু field-এ মান কপি করে, যাচাই করে না — অর্থাৎ সে object-কে বৈধ রাখার দায়িত্বই নেয় না। IDE-র “Generate constructor” বোতামও ঠিক একই জিনিস বানায়। নিচের ভুলগুলো সবচেয়ে বেশি দেখা যায়:

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

• প্রতিটি constructor-এ প্রতিটি parameter-এর সীমা যাচাই হচ্ছে — একটি ঋণাত্মক বা ফাঁকা মান দিয়ে নিজে চালিয়ে দেখেছি
• প্রতিটি assignment-এ বাঁ পাশে this. আছে, কোথাও name = name নেই
• যা বদলানোর কথা নয়, সেই field final, আর কোনো setter যাচাই ছাড়া মান বসাচ্ছে না
• একাধিক constructor থাকলে কোড কপি নয়, this(...) দিয়ে একটি আসল constructor-এ যাচ্ছে
• Constructor-এর ভেতরে this বাইরে পাঠানো বা override করা যায় এমন method ডাকা হয়নি
• কোথাও clone() বা finalize() নেই