nested, inner আর anonymous class — class-এর ভেতরে class

১ · class-এর ভেতরে class — কেন?

এখন পর্যন্ত আপনার প্রতিটি class ছিল ফাইলের সবচেয়ে বাইরের স্তরে — Shape, Circle, Main সবাই পাশাপাশি। কিন্তু কিছু class আছে যাদের আলাদা কোনো জীবন নেই। একটি গানের তালিকা (Playlist) ভাবুন। তালিকার গানগুলো একে একে ঘুরে দেখার জন্য একটি ছোট সহকারী object লাগে, যে মনে রাখে “এখন কত নম্বর গানে আছি” — পর্ব ১১-এ দেখা iterator. এই সহকারী শুধু ওই একটি তালিকার জন্যই অর্থবহ। প্রোগ্রামের অন্য কোথাও কেউ একে আলাদাভাবে ব্যবহার করবে না।

এমন সহকারীকে যদি বাইরের স্তরে রাখেন, তিনটি সমস্যা হয়। প্রথমত, package-এ অপ্রয়োজনীয় নাম বাড়ে। দ্বিতীয়ত, সহকারী তালিকার private array পড়তে পারে না, তাই তালিকাকে নিজের ভেতরের জিনিস খুলে দিতে হয়। তৃতীয়ত, যে কোড পড়ছে সে বুঝতে পারে না যে এই দুটি class আসলে একটি জোড়া। সমাধান: সহকারীকে মূল class-এর ভেতরে লিখুন। এমন class-কে বলে nested class, আর যার ভেতরে থাকে তাকে বলা হয় outer (বাইরের) class.

Java-তে class-এর ভেতরে class রাখার চারটি উপায় আছে। তাদের পার্থক্য বুঝতে শুধু দুটি প্রশ্ন করুন: এর object বানাতে কি বাইরের class-এর একটি object লাগে? আর class-টি কোথায় লেখা — class-এর সদস্য হিসেবে, নাকি একটি method-এর ভেতরে?

শেষ তিনটিকে একসাথে বলা হয় inner class — Java-র নিয়মে যে nested class static নয়, সেটাই inner. তবে দৈনন্দিন কথায় “inner class” বললে সাধারণত দ্বিতীয় সারির সদস্য-class-টিকেই বোঝায়; এই পর্বেও তাই।

২ · static nested class — বাইরের object ছাড়াই

পর্ব ১৬-এ Builder pattern দেখেছেন, আর পর্ব ১৮-এ static. দুটি মিলিয়েই সবচেয়ে পরিচিত static nested class. একটি ব্যাংকের লেনদেন (Transaction) ভাবুন: কে পাঠাচ্ছে, কাকে, কত টাকা। লেনদেন বানাতে কোনো নির্দিষ্ট Bank object লাগে না, কিন্তু নামের দিক থেকে এটা ব্যাংকেরই জিনিস। আর লেনদেন বানানোর সহকারী Builder শুধু লেনদেনের জন্যই অর্থবহ:

class Bank {
    private final List<Transaction> log = new ArrayList<>();

    static class Transaction {                      // static nested
        private final String from, to;
        private final long amount;
        private Transaction(Builder b) {            // বাইরে থেকে new নিষেধ
            from = b.from; to = b.to; amount = b.amount;
        }
        public String toString() { return from + " -> " + to + ": " + amount + " Tk"; }

        static class Builder {                      // nested-এর ভেতরে nested
            private String from, to;
            private long amount;
            Builder from(String f) { from = f; return this; }
            Builder to(String t)   { to = t; return this; }
            Builder amount(long a) { amount = a; return this; }
            Transaction build() {
                if (amount <= 0) throw new IllegalArgumentException("amount must be positive");
                return new Transaction(this);       // private constructor — ভেতর থেকে চলে
            }
        }
    }
    void record(Transaction t) { log.add(t); }
}

// ব্যবহার:
Bank.Transaction t = new Bank.Transaction.Builder()
        .from("Rahim").to("Karim").amount(5000).build();
System.out.println(t);        // Rahim -> Karim: 5000 Tk

খেয়াল করার মতো চারটি জিনিস:

• নাম বাইরের class দিয়ে শুরু। বাইরে থেকে লিখতে হয় Bank.Transaction, আর Builder হলো Bank.Transaction.Builder. নামই বলে দেয় কে কার সহকারী।
• object বানাতে Bank object লাগেনি। new Bank.Transaction.Builder() — কোথাও new Bank() নেই। static nested class আসলে একটি সাধারণ top-level class-এর মতোই, শুধু ঠিকানাটা বাইরের class-এর ভেতরে।
• একে অন্যের private জিনিস দেখতে পায়। Builder ডাকছে Transaction-এর private constructor, আর Transaction পড়ছে Builder-এর private field. একই top-level class-এর ভেতরের সবাই একে অন্যের private সদস্য ব্যবহার করতে পারে। ফলে বাইরের কেউ Builder এড়িয়ে যাচাই ছাড়া লেনদেন বানাতে পারে না।
• বাইরের class-এর instance field সরাসরি পড়া যায় না। Transaction-এর ভেতর থেকে log লিখলে compiler আপত্তি করবে, কারণ কোন Bank-এর log? কোনো নির্দিষ্ট ব্যাংক object তো এর সাথে বাঁধা নেই। বাইরের class-এর static সদস্য অবশ্য সরাসরি পড়া যায়।

JDK-তে static nested class সবখানে

Map-এর প্রতিটি key-value জোড়া একটি Map.Entry — এটি Map interface-এর ভেতরে ঘোষিত nested interface (interface-এর ভেতরের সব সদস্য-টাইপ নিজে থেকেই static). java.util.LinkedList-এর ভেতরে আছে private static class Node, যেটি একটি মান আর আগের-পরের node-এর reference রাখে। বাইরের কেউ Node-এর কথা জানে না; লিস্টের ব্যবহারকারী দেখে শুধু add, get, remove. এভাবে nested class বাস্তবায়নের খুঁটিনাটি লুকিয়ে রাখে — পর্ব ১৭-এর encapsulation, এবার class-এর স্তরে। পর্ব ৩০-এ লিংকড লিস্ট বিস্তারিত দেখবেন।

৩ · inner class — যে object বাইরের object-কে ধরে রাখে

এবার উল্টো পরিস্থিতি। Playlist-এর iterator-কে জানতে হবে কোন তালিকার গান সে ঘুরছে। “রোড ট্রিপ” তালিকার iterator আর “পড়ার সময়” তালিকার iterator আলাদা গান দেবে। অর্থাৎ iterator object একটি নির্দিষ্ট Playlist object-এর সাথে বাঁধা। ঠিক এই কাজের জন্য inner class: static ছাড়া সদস্য-class.

inner class-এর প্রতিটি object-এর ভেতরে compiler একটি লুকানো field রাখে, যেটি তার বাইরের object-কে দেখায়। একে বলে enclosing instance, আর কোডে তাকে লেখা হয় Outer.this (এখানে Playlist.this). পর্ব ১৬-এর this মানে “এই object”; Playlist.this মানে “যে Playlist-এর ভেতরে আমি বাস করি।” inner class-এর ভেতরে songs লিখলে compiler নিজেই সেটাকে Playlist.this.songs বানিয়ে নেয় — তাই outer-এর private field-ও সরাসরি পড়া যায়।

এখন দুই ধরনের nested class-এর object মেমরিতে কেমন দেখায়, ধাপে ধাপে দেখুন। বিশেষ করে শেষ ধাপটি খেয়াল করুন:

1class Playlist {2    private final String[] songs;3    class SongIterator {        // inner4        int pos = 0;5        String next() { return songs[pos++]; }6    }7    static class Stats { int plays; }   // static nested8}9Playlist.Stats st = new Playlist.Stats();10Playlist road = new Playlist("Tumi Robe Nirobe", "Ekla Cholo Re");11Playlist.SongIterator it = road.new SongIterator();12it.next();13road = null;

পুরো উদাহরণটি — একটি Playlist, যা Iterable হওয়ায় for-each লুপে চলে, আর যার iterator একটি private inner class:

import java.util.Iterator;

class Playlist implements Iterable<String> {
    private final String name;
    private final String[] songs;
    Playlist(String name, String... songs) { this.name = name; this.songs = songs; }

    // inner class — প্রতিটি iterator একটি নির্দিষ্ট Playlist-এর সাথে বাঁধা
    private class SongIterator implements Iterator<String> {
        private int pos = 0;
        public boolean hasNext() { return pos < songs.length; }  // outer-এর private field
        public String next() {
            return Playlist.this.name + " #" + (pos + 1) + ": " + songs[pos++];
        }
    }
    public Iterator<String> iterator() { return new SongIterator(); }
}

class Main {
    public static void main(String[] args) {
        Playlist road = new Playlist("Road Trip", "Tumi Robe Nirobe", "Ekla Cholo Re");
        for (String s : road) System.out.println(s);
        System.out.println(road.iterator().getClass().getName());
    }
}

বাইরে থেকে inner object বানানো, আর static context-এর ফাঁদ

outer-এর instance method-এর ভেতরে this আছে, তাই সেখানে সমস্যা নেই। কিন্তু static method-এ — যেমন main-এ — কোনো this নেই। সেখানে সরাসরি inner object বানাতে চাইলে:

class Main {
    class Inner { }
    public static void main(String[] args) {
        Inner in = new Inner();
    }
}

Main.java:4: error: non-static variable this cannot be referenced from a static context
        Inner in = new Inner();
                   ^
1 error

বার্তাটা প্রথমে বিভ্রান্তিকর — আপনি তো কোথাও this লেখেননি! কিন্তু compiler new Inner()-কে পড়ে this.new Inner() হিসেবে, কারণ inner object-এর একটি বাইরের object লাগবেই। static main-এ সেই this নেই। দুটি সমাধান: হয় একটি outer object বানিয়ে new Main().new Inner() লিখুন, নয়তো — এবং প্রায়ই এটাই আসল উত্তর — Inner-কে static করুন, যদি সে বাইরের object আদৌ ব্যবহার না করে। নতুনরা এই error দেখে প্রায়ই সব কিছুতে static বসিয়ে দেন; প্রশ্নটা হওয়া উচিত “এই class-এর কি সত্যিই বাইরের object লাগে?”

নাম মিলে গেলে — Outer.this দিয়ে আলাদা করা

class Outer {
    private int secret = 42;
    class Inner {
        int secret = 7;
        void show() {
            System.out.println(secret + " " + this.secret + " " + Outer.this.secret);
        }
    }
}
// new Outer().new Inner().show();   →   7 7 42

inner class-এর নিজের field বাইরের একই নামের field-কে ঢেকে দেয় (পর্ব ১৬-এর shadowing). secret আর this.secret দুটিই inner-এর ৭; বাইরেরটা পেতে লিখতে হয় Outer.this.secret.

৪ · local class আর effectively final-এর নিয়ম

কখনো একটি সহকারী class শুধু একটি method-এর ভেতরেই লাগে। তখন তাকে সেই method-এর ভেতরেই লেখা যায় — এটা local class. local variable-এর মতোই এর scope শুধু সেই block; method-এর বাইরে এর নাম কেউ জানে না।

static String receipt(String shop, int[] prices) {
    class Line {                                  // local class
        final int no, price;
        Line(int no, int price) { this.no = no; this.price = price; }
        String show() { return shop + " item " + no + ": " + price + " Tk"; }  // shop পড়ছে
    }
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < prices.length; i++) sb.append(new Line(i + 1, prices[i]).show()).append('\n');
    return sb.toString();
}

Line-এর ভেতর থেকে shop পড়া হচ্ছে — shop হলো receipt method-এর parameter, অর্থাৎ একটি local variable. এখানেই একটি গুরুত্বপূর্ণ সমস্যা লুকিয়ে আছে। local variable থাকে method-এর stack frame-এ (পর্ব ১২), আর method শেষ হলেই সেই frame মুছে যায়। কিন্তু local বা anonymous class-এর object method শেষ হওয়ার পরও বেঁচে থাকতে পারে — যেমন সেটা ফেরত দেওয়া হলে। তখন সে মুছে যাওয়া ভ্যারিয়েবল পড়বে কীভাবে?

Java-র উত্তর: কপি রাখো। object তৈরির মুহূর্তে compiler ভ্যারিয়েবলের মানটি object-এর ভেতরের একটি লুকানো field-এ কপি করে দেয়। একে বলে variable capture. কপির ধারণাটা নিচের stepper-এ দেখুন:

1static Runnable greeter(String name) {2    String msg = "Hello, " + name;3    return new Runnable() {4        public void run() {5            System.out.println(msg);6        }7    };8}9Runnable r = greeter("Rahim");10r.run();11// যদি লাইন ৩-এর পরে লিখতেন: msg = "Bye";

এই নিয়মের নাম effectively final: ভ্যারিয়েবলের সামনে final লেখা না থাকলেও, ঘোষণার পর কোথাও নতুন মান বসানো না হলে সে “কার্যত final”. Java 8-এর আগে final শব্দটি নিজে লিখতে হতো; Java 8 থেকে compiler নিজেই বুঝে নেয়। নিয়ম ভাঙলে আসল error দেখতে কেমন:

class Main {
    public static void main(String[] args) {
        int count = 0;
        Runnable r = new Runnable() {
            public void run() { System.out.println(count); }
        };
        count++;
        r.run();
    }
}

Main.java:5: error: local variables referenced from an inner class must be final or effectively final
            public void run() { System.out.println(count); }
                                                   ^
1 error

লক্ষ করুন, error দেখাচ্ছে লাইন ৫-এ, যেখানে count পড়া হচ্ছে — যদিও “দোষ” লাইন ৭-এর count++-এর। কারণ count++ একা বৈধ; সমস্যা হলো একটি বদলানো ভ্যারিয়েবলকে class-এর ভেতর থেকে ধরা। count++ লাইনটা মুছে দিলে error চলে যাবে।

সত্যিই যদি বাইরের একটি গণনা বদলাতে হয়? তাহলে বদলানো যায় এমন একটি object ধরুন — ভ্যারিয়েবল নিজে না বদলে তার ভেতরের অবস্থা বদলান। যেমন java.util.concurrent.atomic.AtomicInteger বা একটি field. কিন্তু আগে ভাবুন: প্রায়ই এর চেয়ে পরিষ্কার নকশা আছে, যেমন anonymous class-এর নিজের field-এ গণনা রাখা — পরের অংশের বোতামের উদাহরণে ঠিক এটাই করা হয়েছে।

Java 16 থেকে: local record, enum আর interface

Java 16-এ record স্থায়ী হওয়ার সাথে method-এর ভেতরে record, enum আর interface ঘোষণা করাও বৈধ হয়েছে। এগুলো নিজে থেকেই static — বাইরের object বা local variable ধরে না। একটি method-এর ভেতরে মধ্যবর্তী ফল গুছিয়ে রাখতে local record খুব কাজের:

static void topScorer(String[] names, int[] runs) {
    record Score(String name, int runs) { }      // শুধু এই method-এর জন্য
    Score best = new Score(names[0], runs[0]);
    for (int i = 1; i < names.length; i++)
        if (runs[i] > best.runs()) best = new Score(names[i], runs[i]);
    System.out.println(best);                    // Score[name=..., runs=...]
}

৫ · anonymous class — নাম ছাড়া, একবারের জন্য

অনেক সময় একটি interface-এর implementation একবারই লাগে, একটি জায়গাতেই। তার জন্য আলাদা নাম দিয়ে class লেখা, তারপর new করা — বাড়তি ঝামেলা। anonymous class দুটি কাজ এক ধাপে করে: class ঘোষণা আর object তৈরি।

Runnable task = new Runnable() {     // "Runnable implement করে এমন একটি নামহীন class-এর object"
    public void run() {
        System.out.println("Backup started");
    }
};                                   // শেষে সেমিকোলন — এটা একটি statement

new Runnable() দেখে ভাববেন না যে interface-এর object বানানো হচ্ছে — সেটা অসম্ভব (পর্ব ২১)। পরের { ... } অংশটিই একটি নতুন, নামহীন class-এর শরীর, যেটি Runnable implement করে। new সেই নামহীন class-এর object বানায়। একইভাবে একটি class বা abstract class-এর নামও বসানো যায় — তখন anonymous class হয় তার subclass, আর বন্ধনীর ভেতরের argument যায় parent-এর constructor-এ।

যেখানে anonymous class জন্মেছিল — event listener

পুরোনো Java GUI লাইব্রেরি (AWT, Swing) আর পুরোনো Android কোডে প্রতিটি বোতামের জন্য একটি event listener লাগত — “এই বোতাম চাপলে এটা করো।” প্রতিটি বোতামের কাজ আলাদা, প্রতিটি একবারের। Swing-এ লেখা হতো button.addActionListener(new ActionListener() { ... }), Android-এ setOnClickListener(new View.OnClickListener() { ... }). নিচের প্রোগ্রামে আমরা নিজেরাই একটি ছোট Button বানিয়ে সেই ধাঁচটি অনুকরণ করেছি, তারপর Comparator দিয়ে সাজানো — প্রথমে anonymous class-এ, তারপর lambda-তে:

import java.util.*;
interface ClickListener { void onClick(String label); }
class Button {
    private final String label;
    private ClickListener listener;
    Button(String label) { this.label = label; }
    void setOnClick(ClickListener l) { listener = l; }
    void click() { listener.onClick(label); }
}
class Main {
    public static void main(String[] args) {
        Button pay = new Button("Pay");
        pay.setOnClick(new ClickListener() {        // anonymous class
            private int count = 0;                   // নিজস্ব state
            public void onClick(String label) {
                System.out.println(label + " #" + (++count) + " " + getClass().getName());
            }
        });
        pay.click(); pay.click();
        List<String> names = new ArrayList<>(List.of("Nusrat", "Ali", "Rahim"));
        names.sort(new Comparator<String>() {       // পুরোনো ধাঁচ: ছোট নাম আগে
            public int compare(String a, String b) { return Integer.compare(a.length(), b.length()); }
        });
        System.out.println(names);
        names.sort((a, b) -> Integer.compare(b.length(), a.length()));  // lambda: বড় নাম আগে
        System.out.println(names);
    }
}

anonymous class-এর সীমা

• constructor লেখা যায় না — নামই নেই, constructor-এর নাম কী হবে? শুরুর কাজ করতে field-এ সরাসরি মান দিন বা instance initializer block ({ ... }) ব্যবহার করুন।
• একটিই parent: একটি interface implement করে অথবা একটি class extend করে — দুটি একসাথে নয়, দুটি interface-ও নয়।
• নতুন public method যোগ করলে বাইরে থেকে ডাকা কঠিন: ভ্যারিয়েবলের টাইপ হয় parent-এর (ClickListener), আর সেখানে নতুন method নেই। (var দিয়ে রাখলে টাইপটা নামহীন class-ই থাকে, তবে সেটা কদাচিৎ কাজে লাগে।)

৬ · anonymous class থেকে lambda — আর কখন anonymous class-ই লাগে

ওপরের Comparator-টা আবার দেখুন। তিন লাইনের মধ্যে আসল কাজের কথা শুধু একটি: “a আর b-এর দৈর্ঘ্য তুলনা করো।” বাকি সব — new Comparator<String>(), public int compare, বন্ধনী — compiler আগে থেকেই জানে, কারণ Comparator-এ একটিই abstract method. পর্ব ২১-এ দেখেছেন, এমন interface-কে বলে functional interface. Java 8 এই পুনরাবৃত্তি ছেঁটে ফেলার জন্য lambda এনেছে। রূপান্তরটা ধাপে ধাপে দেখুন:

names.sort(new Comparator<String>() {
    public int compare(String a, String b) {
        return Integer.compare(a.length(), b.length());
    }
});

names.sort(
    (String a, String b) {
        return Integer.compare(a.length(), b.length());
    }
);
// sort চায় Comparator — তার একটিই method, compare

names.sort((String a, String b) -> {
    return Integer.compare(a.length(), b.length());
});

names.sort((a, b) -> {
    return Integer.compare(a.length(), b.length());
});
// List<String> থেকে compiler জানে a, b হলো String

names.sort((a, b) -> Integer.compare(a.length(), b.length()));
// আরও ছোট (পর্ব ৩৩-৩৪): names.sort(Comparator.comparingInt(String::length));

তবু যেখানে anonymous class-ই লাগে

lambda শুধু functional interface-এর জন্য। তিনটি পরিস্থিতিতে anonymous class (বা নাম দেওয়া class) এখনো দরকার:

• একাধিক abstract method: পুরোনো GUI-র MouseListener-এ পাঁচটি method (mouseClicked, mousePressed, …) — lambda একটির বেশি শরীর দিতে পারে না।
• নিজস্ব state: ওপরের বোতামের count-এর মতো field. lambda-র নিজের field থাকে না।
• abstract class বা সাধারণ class-এর subclass: lambda শুধু interface-এর জন্য। একটি abstract method-ওয়ালা abstract class হলেও না:

abstract class Task {
    abstract void run();
}

class Main {
    public static void main(String[] args) {
        Task t = () -> System.out.println("hi");
    }
}

Main.java:7: error: incompatible types: Task is not a functional interface
        Task t = () -> System.out.println("hi");
                 ^
1 error

this — দুটিতে দুই অর্থ

এই পার্থক্যটি সূক্ষ্ম, আর AI-ও প্রায়ই গুলিয়ে ফেলে। anonymous class একটি সত্যিকারের নতুন class, তাই তার ভেতরে this মানে সেই নামহীন object. lambda নতুন class নয়, নতুন scope-ও নয় — তার ভেতরে this মানে যে object-এর method-এ lambda লেখা হয়েছে, অর্থাৎ বাইরের object.

class Screen {
    String name = "Home";
    void show() {
        Runnable anon = new Runnable() {
            public void run() { System.out.println("anonymous: " + this.getClass().getName()); }
        };
        Runnable lam = () -> System.out.println("lambda:    " + this.getClass().getName() + " " + this.name);
        anon.run();
        lam.run();
    }
}
// new Screen().show();
// anonymous: Screen$1
// lambda:    Screen Home

anonymous class-এর ভেতর থেকে বাইরের Screen পেতে লিখতে হতো Screen.this; lambda-তে সাধারণ this-ই যথেষ্ট। একই কারণে lambda-র ভেতরে বাইরের কোনো local variable-এর নামে নতুন ভ্যারিয়েবল ঘোষণা করা যায় না (একই scope), কিন্তু anonymous class-এর ভেতরে যায় (নতুন scope, তাই বাইরেরটা ঢাকা পড়ে)।

lambda-র পুরো গল্প — java.util.function-এর interface-গুলো, method reference, আর lambda দিয়ে কোড সাজানোর কৌশল — পর্ব ৩৪-এ। এই পর্বের জন্য মনে রাখুন: lambda হলো “একটি method-ওয়ালা anonymous class”-এর সংক্ষিপ্ত, আর আরও কার্যকর বিকল্প।

৭ · পর্দার আড়ালে — class ফাইল, synthetic accessor আর nestmates

একটি চমকপ্রদ তথ্য: JVM “nested class” বলে কিছু চেনে না। পর্ব ৫-এ দেখেছেন, javac প্রতিটি class-এর জন্য একটি আলাদা class file বানায়। nested class-ও তার ব্যতিক্রম নয় — প্রতিটি পায় নিজের ফাইল, শুধু নামে $ দিয়ে বাইরের class-এর নাম জোড়া থাকে। একটি Outer.java compile করলে কী কী তৈরি হয়, দেখুন:

class Outer {
    private int x = 1;
    class Inner { int get() { return x; } }
    static class Nested { }
    Runnable anon() { return new Runnable() { public void run() { } }; }
    Object local() { class Helper { } return new Helper(); }
    Runnable lam() { return () -> System.out.println(x); }
}

Outer.class
Outer$Inner.class
Outer$Nested.class

Outer.class
Outer$Inner.class
Outer$Nested.class
Outer$1.class          ← anonymous
Outer$1Helper.class    ← local class Helper

lambda-র শরীর → Outer.class-এর ভেতরে
একটি private synthetic method (যেমন lambda$lam$0)
আর তাকে জোড়ার জন্য একটি invokedynamic নির্দেশ
→ আলাদা .class ফাইল নেই

Outer.class:       NestMembers attribute
                   (Inner, Nested, 1, 1Helper)
Outer$Inner.class: NestHost attribute → Outer
JVM: একই nest-এর সবাই একে অন্যের private ব্যবহার করতে পারে

Java 11-এর আগে কী হতো? JVM-এর নিয়মে এক class আরেক class-এর private সদস্য ছুঁতে পারত না। তাই ভাষার প্রতিশ্রুতি (“inner class outer-এর private পড়তে পারে”) রাখতে javac চুপচাপ outer class-এ package-private synthetic accessor method বানাত — নাম হতো access$000, access$100 ধরনের — আর inner class সেগুলো ডাকত। এতে class ফাইল বড় হতো, stack trace-এ অদ্ভুত নাম দেখা যেত, আর reflection দিয়ে private সদস্য ব্যবহারের নিয়মে অসংগতি থাকত। JEP 181 (nest-based access control) এই কৌশলের প্রয়োজন মিটিয়ে দিয়েছে।

৮ · কোনটা কখন — সিদ্ধান্ত নেওয়ার নিয়ম

Joshua Bloch-এর বিখ্যাত বই Effective Java-র (তৃতীয় সংস্করণ) Item 24-এর শিরোনাম: “Favor static member classes over nonstatic” — অর্থাৎ inner class-এর চেয়ে static nested class বেছে নিন। যুক্তি: inner class প্রতিটি object-এ একটি বাড়তি reference রাখে, তৈরি করতে সময় ও মেমরি লাগে, আর সবচেয়ে বড় কথা — বাইরের object-কে অকারণে বাঁচিয়ে রাখতে পারে। তাই প্রশ্নগুলো এই ক্রমে করুন:

একটি সতর্কতা: nested class অতিরিক্ত ব্যবহার করলে একটি বিশাল ফাইল তৈরি হয়, যেখানে পাঁচ স্তর গভীরে class লুকানো। nested class ছোট রাখুন; যখন একটি nested class নিজেই বড় হয়ে ওঠে বা অন্য জায়গা থেকে ব্যবহার শুরু হয়, তাকে আলাদা ফাইলে সরিয়ে দিন।

৯ · AI-এর যুগে — লুকানো reference আর অপ্রয়োজনীয় দৈর্ঘ্য ধরুন

AI-কে একটি linked list বা একটি Builder লিখতে বললে প্রায়ই দেখবেন class Node বা class Builder — static ছাড়া। কোড চলে, টেস্টও পাস করে। কিন্তু প্রতিটি Node এখন অকারণে পুরো লিস্ট object-এর একটি লুকানো reference বহন করছে, আর main থেকে new Node() লিখতে গেলে সেই বিভ্রান্তিকর non-static variable this error আসছে, যার “সমাধান” হিসেবে AI আবার অন্য কোথাও static বসাচ্ছে। এমন ভুলগুলো আপনাকেই ধরতে হবে:

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

• প্রতিটি non-static nested class সত্যিই বাইরের object-এর কিছু ব্যবহার করে
• Node, Builder, Entry ধরনের সহকারী static
• একটি method-ওয়ালা interface-এর জন্য lambda, anonymous class থাকলে তার কারণ আছে
• lambda-র ভেতরের this বাইরের object বোঝাচ্ছে — এবং সেটাই উদ্দেশ্য
• কোনো inner বা anonymous object static collection, cache বা অন্য thread-এ অনির্দিষ্টকাল জমা থাকছে না
• effectively final error চাপা দিতে int[] বা AtomicInteger-এর কৌশল নেই