অপারেটর — হিসাব, তুলনা আর যুক্তি

১ · অপারেটর কী — মান থেকে নতুন মান

পর্ব ০৬-এ আপনি ভ্যারিয়েবলে মান রাখতে শিখেছেন। কিন্তু শুধু মান রেখে দিলে প্রোগ্রাম কিছুই করে না। দোকানের হিসাব, পরীক্ষার গড়, লগইনের অনুমতি — সব জায়গায় পুরোনো মান থেকে নতুন মান বানাতে হয়। এই কাজ করে operator: এমন একটি চিহ্ন, যা এক বা একাধিক মান নিয়ে একটি নতুন মান তৈরি করে। যে মানগুলোর ওপর অপারেটর কাজ করে, তাদের বলে operand. আর operand ও অপারেটর মিলে যা দাঁড়ায়, যেমন price * qty, তাকে বলে expression — প্রতিটি expression শেষ পর্যন্ত একটি মান দেয়।

Java-র অপারেটরগুলোকে কাজ অনুযায়ী তিনটি বড় দলে ভাবা যায়:

এতটুকু সহজ। কঠিন অংশ অন্য জায়গায়: একই চিহ্নের ফল নির্ভর করে operand-এর টাইপ আর হিসাবের ক্রমের ওপর। 7 / 2 আর 7.0 / 2 দেখতে প্রায় এক, ফল আলাদা। a == b দুটি int-এর বেলায় এক কাজ করে, দুটি String-এর বেলায় আরেক কাজ। এই নিয়মগুলো না জানলে প্রোগ্রাম কোনো error দেখায় না — শুধু চুপচাপ ভুল উত্তর দেয়। এ ধরনের বাগ সবচেয়ে বিপজ্জনক, কারণ কেউ টেরই পায় না।

২ · হিসাবের অপারেটর — ভাগে সাবধান

যোগ (+), বিয়োগ (-) আর গুণ (*) স্কুলের অঙ্কের মতোই কাজ করে। চমক লুকিয়ে আছে বাকি দুটিতে — ভাগ (/) আর ভাগশেষ (%).

Integer division — ভগ্নাংশ কেটে ফেলা

দুটি operand-ই পূর্ণসংখ্যা (int বা long) হলে Java integer division করে: ভাগফলের দশমিক অংশ সোজা বাদ দেয়, গোল (round) করে না। 7 / 2 = 3, 9 / 10 = 0, -7 / 2 = -3. যেকোনো একটি operand দশমিক (double) হলেই পুরো হিসাব দশমিকে হয়: 7 / 2.0 = 3.5.

এটি সবসময় বাগ নয় — অনেক সময় ঠিক এটাই দরকার। ধরুন চার বন্ধু মিলে চায়ের দোকানে ১২৫০ টাকা বিল করলেন, আর ঠিক করলেন প্রত্যেকে পূর্ণ টাকায় দেবেন, যা খুচরা বাকি থাকবে তা যে বিল দিচ্ছে সে দেবে:

% অপারেটরের নাম remainder বা modulo — ভাগশেষ দেয়। একটি নিয়ম সবসময় সত্য: (a / b) * b + a % b == a. অর্থাৎ ৩১২ × ৪ + ২ = ১২৫০. %-এর পরিচিত ব্যবহার: জোড়-বিজোড় যাচাই (n % 2 == 0), শেষ অঙ্ক বের করা (n % 10), সেকেন্ড থেকে মিনিট-সেকেন্ড (s / 60 আর s % 60), আর ঘুরে ঘুরে আসা হিসাব — যেমন সপ্তাহের দিন ((day + 3) % 7).

ঋণাত্মক সংখ্যার % — Java শূন্যের দিকে কাটে

Java-র integer division দশমিক অংশ সবসময় শূন্যের দিকে কেটে ফেলে (truncation toward zero). -7 / 2-এর আসল মান −৩.৫; শূন্যের দিকে কাটলে −৩. তাহলে উপরের নিয়ম অনুযায়ী -7 % 2 = −৭ − (−৩ × ২) = −১. অর্থাৎ Java-তে %-এর ফলের চিহ্ন হয় বাঁ দিকের operand-এর মতো: -7 % 2 = -1, কিন্তু 7 % -2 = 1.

এর একটি বাস্তব ফাঁদ আছে: n % 2 == 1 দিয়ে বিজোড় যাচাই করলে ঋণাত্মক বিজোড় সংখ্যায় ভুল হয়, কারণ -7 % 2 হলো -1, 1 নয়। নিরাপদ উপায় n % 2 != 0.

যদি গণিতের মতো “সবসময় অঋণাত্মক ভাগশেষ” চান — যেমন ঘড়ির হিসাব বা array-তে ঘুরে ঘুরে index — তাহলে Java 8 থেকে আছে Math.floorDiv(a, b) আর Math.floorMod(a, b). এরা নিচের দিকে (floor) কাটে: Math.floorDiv(-7, 2) = -4, Math.floorMod(-7, 2) = 1.

শূন্য দিয়ে ভাগেও টাইপ ভেদে আচরণ আলাদা। 5 / 0 (দুটিই int) চলার সময় ArithmeticException: / by zero ছোড়ে। কিন্তু 5.0 / 0 কোনো exception দেয় না, ফল দেয় Infinity; আর 0.0 / 0 দেয় NaN (Not a Number). দশমিক সংখ্যার এই নিয়ম আসে IEEE 754 মান থেকে, যা প্রায় সব আধুনিক CPU মেনে চলে।

৩ · টাইপের নিয়ম — promotion, লুকানো cast আর overflow

পর্ব ০৬-এ দেখেছেন, Java-তে পূর্ণসংখ্যার চারটি টাইপ: byte (৮ bit), short (১৬), int (৩২), long (৬৪)। এখন একটি অবাক করা নিয়ম: Java byte, short বা char নিয়ে সরাসরি হিসাব করে না। হিসাবের আগে এদের সবাইকে int-এ তুলে নেয়। একে বলে numeric promotion. নিয়মটি এক লাইনে:

ফলে দুটি byte যোগ করলেও ফল int. আর int-কে চুপচাপ byte-এ ভরলে মান হারাতে পারে, তাই Java অনুমতি দেয় না:

byte a = 10, b = 20;
byte c = a + b;      // a + b-এর টাইপ int, byte নয়

Main.java:4: error: incompatible types: possible lossy conversion from int to byte
        byte c = a + b;
                   ^
1 error

বার্তাটির মানে: “int থেকে byte-এ রূপান্তরে মান হারাতে পারে।” আপনি নিশ্চিত হলে নিজে cast করুন: byte c = (byte) (a + b); — তখন দায়িত্ব আপনার। কারণটাও যৌক্তিক: JVM-এর bytecode-এ byte যোগের আলাদা কোনো নির্দেশই নেই; পর্ব ০৫-এ দেখা iadd সব ছোট টাইপের জন্য কাজ করে।

char-ও এই নিয়মে পড়ে, যা অনেককে অবাক করে: 'A' + 1-এর ফল 66 (একটি int), 'B' নয়। কারণ 'A'-এর ভেতরের সংখ্যা ৬৫.

Compound assignment — যেখানে cast লুকিয়ে থাকে

x = x + 5-এর সংক্ষিপ্ত রূপ x += 5. একই রকম -=, *=, /=, %= আছে। এদের বলে compound assignment. কিন্তু এরা শুধু সংক্ষেপ নয় — এদের ভেতরে একটি cast লুকানো। Java-র নিয়ম অনুযায়ী b += 1 আসলে b = (byte) (b + 1). তাই:

byte b = 10;
b = b + 1;    // compile error: int থেকে byte
b += 1;       // ঠিক আছে — ভেতরে (byte) cast আছে

সুবিধাজনক, কিন্তু ঝুঁকিও এখানে। byte b = 127; b += 1; compile হয়, চলে, আর b হয়ে যায় -128 — কোনো সতর্কবার্তা ছাড়াই। একইভাবে int total = 0; total += 2.7; compile হয়, আর total হয় 2; দশমিক অংশ নিঃশব্দে উধাও।

Overflow — সীমা পেরোলে উল্টো দিকে

পর্ব ০৬-এ দেখেছেন, int-এর সর্বোচ্চ মান ২১৪৭৪৮৩৬৪৭. তার সাথে ১ যোগ করলে Java কোনো error দেয় না; ফল ঘুরে চলে যায় সর্বনিম্ন মানে, -2147483648. একে বলে integer overflow. গুণের বেলায় এটি সহজেই ঘটে — যেমন মিলিসেকেন্ডের হিসাবে 365 * 24 * 60 * 60 * 1000 int-এ ধরে না। সমাধান দুটি: বড় সংখ্যার জন্য long (প্রথম operand-কে 365L লিখলে পুরো হিসাব long-এ হয়), আর যেখানে ভুল ফল মেনে নেওয়া যায় না — যেমন টাকার হিসাব — সেখানে Math.addExact, Math.multiplyExact. এরা overflow হলে চুপ থাকে না, ArithmeticException: integer overflow ছোড়ে।

৪ · ++ আর -- — আগে বাড়বে, না পরে?

i++ মানে i-কে ১ বাড়াও, i-- মানে ১ কমাও। এদের বলে increment/decrement operator. একা একটি লাইনে লিখলে i++; আর ++i;-এর মধ্যে কোনো পার্থক্য নেই। পার্থক্য দেখা দেয় যখন এরা একটি বড় expression-এর অংশ:

• Postfix i++: expression-এর মান হয় পুরোনো মান; তারপর i বাড়ে। int i = 5; int x = i++; → x = ৫, i = ৬.
• Prefix ++i: আগে i বাড়ে; expression-এর মান হয় নতুন মান। int i = 5; int x = ++i; → x = ৬, i = ৬.

লক্ষ করুন, i++ দুটি কাজ করে: একটি মান দেয়, আবার একটি ভ্যারিয়েবলও বদলায়। মান দেওয়ার বাইরে এই বাড়তি বদলকে বলে side effect. একটি expression-এ একই ভ্যারিয়েবলের ওপর একাধিক side effect থাকলে মাথা গুলিয়ে যায়। সবচেয়ে বিখ্যাত উদাহরণ:

1int i = 5;2i = i++;3System.out.println(i);

নিয়মটি সহজ রাখুন: ++ আর -- হয় নিজের লাইনে একা লিখুন (count++;), নয়তো for লুপের হালনাগাদ অংশে (পর্ব ১১)। a[i++] = i; বা x = i++ + ++i;-এর মতো কোড Java-তে নির্দিষ্ট ফল দিলেও পাঠকের মাথা ঘুরিয়ে দেয় — আর পরীক্ষার প্রশ্ন ছাড়া বাস্তবে এর কোনো দরকার নেই। ++ char-এও চলে: char ch = 'A'; ch++; → 'B' (এখানেও compound assignment-এর মতো লুকানো cast আছে)।

এ পর্যন্ত যা শিখলেন, সব একটি প্রোগ্রামে দেখুন। চালানোর আগে প্রতিটি লাইনের আউটপুট আন্দাজ করুন:

class Main {
    public static void main(String[] args) {
        int bill = 1250, friends = 4;
        int each = bill / friends;      // integer division
        int left = bill % friends;      // ভাগশেষ
        System.out.println("প্রত্যেকে " + each + " টাকা, বাকি " + left + " টাকা");

        System.out.println("গড় (ভুল): " + (70 + 85 + 90) / 3);
        System.out.println("গড় (ঠিক): " + (70 + 85 + 90) / 3.0);

        System.out.println("-7 / 2 = " + (-7 / 2) + ", -7 % 2 = " + (-7 % 2));
        System.out.println("floorDiv = " + Math.floorDiv(-7, 2)
                + ", floorMod = " + Math.floorMod(-7, 2));

        byte b = 127;
        b += 1;                         // লুকানো cast: (byte) (b + 1)
        System.out.println("byte 127 + 1 = " + b);

        int i = 5;
        i = i++;
        System.out.println("i = i++ এর পরে i = " + i);
    }
}

৫ · তুলনা — হ্যাঁ/না প্রশ্ন, আর ==-এর ফাঁদ

তুলনার অপারেটর ছয়টি: == (সমান), != (অসমান), <, >, <=, >=. এদের বলে comparison operator. ফল সবসময় একটি boolean — true বা false. age >= 18 একটি প্রশ্ন, আর তার উত্তর একটি মান, যা ভ্যারিয়েবলে রাখা যায়: boolean adult = age >= 18;

C থেকে আসা একটি ভুল Java নিজেই আটকে দেয়। C-তে if (x = 5) (ভুল করে এক =) compile হয় আর সবসময় সত্য হয়। Java-তে if-এর ভেতরে অবশ্যই boolean লাগে, আর x = 5-এর টাইপ int — তাই compile error. (ব্যতিক্রম: x নিজেই boolean হলে if (done = true) compile হয়ে যায় — সাবধান।)

Primitive-এ মান, object-এ ঠিকানা

পর্ব ০৫-এর stack আর heap-এর ছবি মনে করুন। একটি int ভ্যারিয়েবলে সরাসরি সংখ্যাটি থাকে; একটি String ভ্যারিয়েবলে থাকে শুধু একটি reference — heap-এ রাখা object-এর ঠিকানা। == সবসময় ভ্যারিয়েবলের ভেতরে যা আছে, সেটাই তুলনা করে। তাই:

• Primitive-এ (int, double, char, boolean…) == মান তুলনা করে। 5 == 5 → true.
• Object-এ (String, Integer, আপনার নিজের class…) == দেখে দুটি reference একই object দেখায় কি না — একে বলে reference equality. ভেতরের লেখা এক হলেও দুটি আলাদা object হলে ফল false.

দুটি String-এর লেখা এক কি না জানতে লিখুন a.equals(b). equals method ভেতরের বিষয়বস্তু মেলায়। কেন "hi" == "hi" কখনো true আর কখনো false আসে — তার কারণ String pool, বিস্তারিত পর্ব ০৮-এ। আর নিজের class-এ equals কীভাবে লিখবেন, পর্ব ২৩-এ।

দশমিক সংখ্যা == দিয়ে মেলাবেন না

0.1 + 0.2 == 0.3 Java-তে false. কারণ floating-point সংখ্যা binary-তে রাখা হয়, আর ০.১-এর মতো অনেক দশমিক সংখ্যা binary-তে ঠিকঠাক লেখা যায় না — যেমন দশমিকে ১/৩ = ০.৩৩৩… শেষ হয় না। ফলে 0.1 + 0.2 আসলে 0.30000000000000004. দশমিক তুলনায় একটি ছোট সহনসীমা (tolerance) রাখুন:

double a = 0.1 + 0.2;
boolean same = Math.abs(a - 0.3) < 1e-9;   // true — পার্থক্য খুব ছোট হলেই "সমান"

সহনসীমা কত হবে, তা নির্ভর করে আপনার সংখ্যা কত বড় আর কতটা নির্ভুলতা দরকার তার ওপর। আর টাকার হিসাবে double-ই এড়িয়ে চলুন: পয়সায় long রাখুন, বা BigDecimal ব্যবহার করুন (পর্ব ০৬)।

৬ · যুক্তি — &&, ||, ! আর short-circuit

বাস্তবের সিদ্ধান্ত প্রায়ই একাধিক শর্তে হয়। একটি অনলাইন দোকান ঠিক করল: “ছাড় পাবেন যদি আপনার কাছে বৈধ কুপন থাকে, অথবা আপনি member হন এবং কেনাকাটা ২০০০ টাকা বা তার বেশি হয়।” এই বাক্যকে কোডে আনতে লাগে logical operator:

boolean discount = hasCoupon || (member && total >= 2000);

এখানে বন্ধনী আসলে দরকার নেই — &&-এর precedence ||-এর চেয়ে বেশি, তাই Java এমনিতেই এভাবে পড়ত। তবু বন্ধনী দিলে পাঠক এক নজরে নিয়মটি বোঝেন, নিয়ম মনে রাখার দরকার পড়ে না।

Short-circuit — দরকার না হলে ডান দিক চলেই না

false && (যা-ই হোক) সবসময় false; true || (যা-ই হোক) সবসময় true. তাই বাঁ দিক দেখেই উত্তর জানা গেলে Java ডান দিকটি চালায়ই না। একে বলে short-circuit evaluation. এটি শুধু গতির ব্যাপার নয় — এর ওপর নিরাপত্তা দাঁড়িয়ে আছে। নিচের stepper-এ s-এ কোনো String নেই, আছে null:

1String s = null;2if (s != null && s.length() > 3) {3    System.out.println("লম্বা নাম");4}5System.out.println("শেষ");

||-এর বেলায় উল্টো: বাঁ দিক true হলে ডান দিক চলে না। যেমন s == null || s.isEmpty() — “ফাঁকা বা না-থাকা” যাচাইয়ের প্রচলিত ধরন।

একক & আর | boolean-এর ওপরও চলে, কিন্তু short-circuit করে না — দুই দিক সবসময় হিসাব হয়। খুব কম ক্ষেত্রে এটি ইচ্ছাকৃত হয়, যেমন দুই দিকেই এমন method আছে যার চলাটা জরুরি। তবে এমন কোড বিভ্রান্তিকর; সাধারণ নিয়ম: শর্ত জুড়তে সবসময় && আর ||. আরেকটি কম-পরিচিত অপারেটর ^ (XOR): দুই দিক আলাদা হলে true.

Ternary — এক লাইনে “যদি… তবে… নইলে…”

একটি মেট্রো রেলের টিকিট-অ্যাপ ধরুন, যেখানে ১২ বছরের কম বয়সীদের টিকিট ৫০ টাকা, বাকিদের ১০০ টাকা। ternary operator শর্ত ? মান১ : মান২ দিয়ে এক লাইনেই:

int price = age < 12 ? 50 : 100;

শর্ত সত্য হলে প্রথম মান, নইলে দ্বিতীয় মান। এটিই Java-র একমাত্র অপারেটর যা তিনটি operand নেয় — নাম “ternary” সেখান থেকে। এটি একটি expression, তাই সরাসরি ভ্যারিয়েবলে রাখা বা println-এ দেওয়া যায়, আর short-circuit-এর মতো যে দিকটি দরকার শুধু সেটিই হিসাব হয়। ছোট, পরিষ্কার পছন্দের জন্য এটি চমৎকার। কিন্তু একাধিক ternary একটার ভেতরে আরেকটা বসালে (a ? b : c ? d : e) কোড পড়া কঠিন হয়ে যায় — সেখানে if/else বা Java 14 থেকে আসা switch expression ভালো (পর্ব ১০)।

৭ · Bitwise অপারেটর — একটি সংখ্যায় অনেকগুলো হ্যাঁ/না

কম্পিউটারের ভেতরে প্রতিটি int আসলে ৩২টি bit — ৩২টি ছোট সুইচ, প্রতিটি ০ বা ১. Bitwise operator এই সুইচগুলোর ওপর সরাসরি কাজ করে, প্রতিটি অবস্থানে আলাদাভাবে:

বাস্তব উদাহরণ: ব্যবহারকারীর অনুমতি

একটি অফিসের ফাইল-শেয়ারিং অ্যাপে প্রত্যেক ব্যবহারকারীর তিন ধরনের অনুমতি থাকতে পারে: পড়া, লেখা, মোছা। তিনটি আলাদা boolean না রেখে একটি int-এর তিনটি bit ব্যবহার করা যায় — প্রতিটি অনুমতির জন্য একটি bit. একে বলে bitmask বা flag. Linux-এর ফাইল permission (chmod 755) ঠিক এই ধারণায় চলে।

• অনুমতি দেওয়া: perm |= DELETE; — OR দিয়ে নির্দিষ্ট bit-টি ১ করা।
• অনুমতি আছে কি না: (perm & WRITE) != 0 — AND দিয়ে শুধু ওই bit-টি দেখা। বন্ধনী জরুরি — কারণ নিচে অংশ ৮-এ।
• অনুমতি কেড়ে নেওয়া: perm &= ~WRITE; — ~WRITE-এ WRITE ছাড়া সব bit ১, তাই AND করলে শুধু WRITE মুছে যায়।
• উল্টে দেওয়া: perm ^= READ; — থাকলে মুছবে, না থাকলে দেবে।

একটি int-এ এভাবে ৩২টি পর্যন্ত হ্যাঁ/না রাখা যায়, তুলনা করা যায় এক নির্দেশে। Java-র নিজের library-তেও এটি আছে — যেমন AWT-এর font style (Font.BOLD | Font.ITALIC). তবে সাধারণ ব্যবসায়িক কোডে আধুনিক Java-তে EnumSet বেশি পাঠযোগ্য (পর্ব ২৪)।

>> বনাম >>> — Java-র নিজস্ব অপারেটর

Java-র int সবসময় চিহ্নযুক্ত (signed): বাঁ দিকের প্রথম bit ১ হলে সংখ্যাটি ঋণাত্মক। ঋণাত্মক সংখ্যা রাখার এই পদ্ধতির নাম two's complement. ডানে সরানোর সময় বাঁ দিকে যে ফাঁকা ঘর তৈরি হয়, তা কী দিয়ে ভরা হবে — এখানেই দুই shift operator-এর পার্থক্য:

1int n = -16;2int a = n >> 2;     // -43int b = n >>> 2;    // 10737418204int c = n >>> 28;   // 15

একটি খুঁটিনাটি: shift-এর পরিমাণ int-এর জন্য ৩২ দিয়ে ভাগশেষ নিয়ে ধরা হয়। তাই 1 << 33 আসলে 1 << 1 = 2, শূন্য নয়। long-এর বেলায় ৬৪ দিয়ে। এবার অনুমতি, ternary, short-circuit আর Math একসাথে চালিয়ে দেখুন:

class Main {
    static final int READ = 1, WRITE = 2, DELETE = 4;   // 001, 010, 100

    public static void main(String[] args) {
        String coupon = null;
        boolean hasCoupon = coupon != null && coupon.length() > 3;   // NPE হয় না
        int total = 2400; boolean member = true;
        boolean discount = hasCoupon || (member && total >= 2000);
        System.out.println("কুপন? " + hasCoupon + ", ছাড়? " + discount);

        int age = 10;
        System.out.println("টিকিট: " + (age < 12 ? 50 : 100) + " টাকা");

        int perm = READ | WRITE;                         // 011
        System.out.println("লিখবে? " + ((perm & WRITE) != 0) + ", মুছবে? " + ((perm & DELETE) != 0));
        perm |= DELETE;  perm &= ~WRITE;                 // 101
        System.out.println("নতুন perm = " + Integer.toBinaryString(perm));
        System.out.println("-16 >> 2 = " + (-16 >> 2) + ", -16 >>> 28 = " + (-16 >>> 28));

        double a = 0.1 + 0.2;
        System.out.println((a == 0.3) + " " + (Math.abs(a - 0.3) < 1e-9));
        System.out.println(Math.round(2.5) + " " + Math.pow(2, 10) + " " + Math.max(3, 7));
    }
}

৮ · কে আগে? precedence, ক্রম আর Math class

স্কুলে শিখেছেন “ভাগ-গুণ আগে, যোগ-বিয়োগ পরে”। Java-রও এমন নিয়ম আছে, তবে অনেক বেশি অপারেটরের জন্য। কোন অপারেটর আগে operand ধরবে — তাকে বলে operator precedence. একই স্তরের অপারেটর পাশাপাশি থাকলে কোন দিক থেকে ধরা হবে — তাকে বলে associativity; বেশিরভাগ অপারেটর বাঁ থেকে ডানে, কিন্তু assignment (=, +=) আর ternary ডান থেকে বাঁয়ে (a = b = 0 মানে a = (b = 0)). ধাপে ধাপে দেখুন:

1int a = 10, b = 4, c = 3, d = 2, e = 4;2int r = a + b * c / d % e;3System.out.println(r);

Java-র পুরো precedence টেবিলে পনেরোর বেশি স্তর। মুখস্থ করার দরকার নেই — নিচের সরল রূপটি জানলেই যথেষ্ট, বাকিটা বন্ধনী দিয়ে সামলান:

টেবিলের একটি ফাঁদ চোখে রাখুন: bitwise & আছে ==-এর নিচে। তাই perm & WRITE != 0 Java পড়ে perm & (WRITE != 0) হিসেবে — যা int & boolean, compile error. C-তে একই ভুল চুপচাপ compile হয়ে ভুল ফল দেয়; Java-র কঠোর টাইপ অন্তত এখানে আপনাকে বাঁচায়। সমাধান সেই একই — বন্ধনী: (perm & WRITE) != 0.

Precedence এক জিনিস, মূল্যায়নের ক্রম আরেক

Precedence বলে কোন অপারেটর কোন operand ধরবে — expression-এর গঠন। কিন্তু operand-গুলো কোন ক্রমে হিসাব হবে, সেটি আলাদা প্রশ্ন। Java-র উত্তর পরিষ্কার: evaluation order সবসময় বাঁ থেকে ডানে (Java Language Specification §15.7). f() + g() * h()-এ গুণ আগে হবে ঠিকই, কিন্তু তিনটি method ডাকা হবে f, g, h ক্রমে। Method-এর argument-ও বাঁ থেকে ডানে হিসাব হয়। এই নিশ্চয়তার জন্যই অংশ ৪-এর i = i++ সব JVM-এ একই ফল দেয়। তবু JLS নিজেই পরামর্শ দেয়: কোড যেন এই নিয়মের ওপর খুব বেশি নির্ভর না করে — একটি expression-এ একটির বেশি side effect রাখবেন না।

Math class — হাতের কাছের হিসাব-যন্ত্র

অপারেটরে যা নেই, তার জন্য আছে java.lang.Math — import ছাড়াই ব্যবহার করা যায়। এর সব method static, তাই Math.max(3, 7)-এর মতো সরাসরি ডাকা যায় (পর্ব ১৮-এ static-এর বিস্তারিত)।

Math.round-এর টাইপ নিয়ে সবচেয়ে বেশি হোঁচট খান নতুনরা: int n = Math.round(4.6); compile হয় না, কারণ double দিলে ফল long, আর long থেকে int-এ মান হারাতে পারে — সেই পুরোনো “possible lossy conversion” বার্তা। হয় long n লিখুন, নয়তো (int) Math.round(4.6). (float দিলে অবশ্য int ফেরত দেয়।) আর Math.round .৫-কে সবসময় ওপরের দিকে (ধনাত্মক অসীমের দিকে) নেয় — তাই −২.৫ হয় −২, −৩ নয়।

৯ · AI-এর যুগে — অপারেটরের নিঃশব্দ ভুল ধরা

AI-এর লেখা Java কোড সাধারণত compile হয়, চলেও। অপারেটরের ভুল তাই চোখে পড়ে না — কোনো লাল দাগ নেই, শুধু কিছু ক্ষেত্রে ভুল উত্তর। AI ভুলগুলো শেখে ইন্টারনেটের লাখো কোড থেকে, যেখানে এগুলো খুব প্রচলিত। আর Python ও JavaScript-এর কোড থেকে শেখা অভ্যাস সে কখনো কখনো Java-তে নিয়ে আসে, যেখানে নিয়ম আলাদা।

"admin".equals(role) লেখার কৌশলটি খেয়াল করুন: ধ্রুব লেখাটি বাঁ দিকে রাখলে role null হলেও NPE আসে না, শুধু false আসে। দুই দিকই null হতে পারলে java.util.Objects.equals(a, b).

AI-এর লেখা কোড হাতে পেলে — অপারেটর চেকলিস্ট

• প্রতিটি ==/!=-এর দুই পাশে primitive আছে কি না দেখেছি; object হলে equals বা Objects.equals
• প্রতিটি /-এর operand-এর টাইপ দেখেছি — গড়, শতাংশ, অনুপাতে দশমিক দরকার কি না
• শর্তে &&/|| আছে, আর null-পাহারা শর্তটি বাঁ দিকে
• ঋণাত্মক মান, শূন্য, Integer.MAX_VALUE দিয়ে অন্তত একবার চালিয়ে দেখেছি
• যেখানে precedence নিয়ে এক মুহূর্তও দ্বিধা লেগেছে, সেখানে বন্ধনী বসিয়েছি