Operators
Arithmetic operators (+ - * / %) numbers par maths karte hain. % operator "remainder" deta hai — jaise 10 % 3 = 1.
Relational operators (== != > < >= <=) do values compare karke true/false batate hain. Logical operators (&& || !) multiple conditions jodte hain.
int a = 10, b = 3;
System.out.println(a % b); // 1
System.out.println(a > b && b > 0); // true+ - * / % basic maths ke liye. Division (/) ka behavior operand types par depend karta hai — do integers ka division "integer division" hota hai (decimal cut jaata hai, jaise 7/2 = 3, na ki 3.5), lekin agar ek bhi operand double ho, result decimal aata hai (7.0/2 = 3.5). % (modulo) remainder deta hai, jo negative numbers ke saath kabhi confusing ho sakta hai (-7 % 2 = -1 in Java, na ki 1).
Unary ++ aur -- do tareeke se use hote hain — pre-increment (++x, pehle badhao fir use karo) aur post-increment (x++, pehle use karo fir badhao). Same expression mein dono use karna (jaise x = x++ + ++x) undefined-jaisi confusing behavior de sakta hai — real code mein aisa kabhi mat likho.
int x = 5;
System.out.println(x++); // prints 5, फिर x = 6
System.out.println(++x); // x = 7 pehle, फिर prints 7
System.out.println(7 / 2); // 3 (integer division)
System.out.println(7.0 / 2); // 3.5Relational operators (== != > < >= <=) do values compare karte hain aur boolean result dete hain. Logical operators mein && aur || "short-circuit" hote hain — matlab agar pehla operand hi result decide kar de, to doosra evaluate hi nahi hota (performance aur safety dono ke liye zaroori, jaise null-check).
& aur | bhi logical operators ki tarah kaam karte hain lekin short-circuit NAHI karte — dono sides hamesha evaluate hote hain, chahe zaroorat ho ya na ho. Isliye agar doosre operand mein koi side-effect (jaise method call) hai jo sirf conditionally chalna chahiye, hamesha && / || use karo, & / | nahi.
! (NOT) operator boolean value ko ulta kar deta hai — !true = false.
String s = null;
if (s != null && s.length() > 0) { // short-circuit: s.length() call hi nahi hoga agar s null hai
System.out.println("Safe!");
}Ye operators bits (0/1) ke level par kaam karte hain — & (AND, dono 1 hon tabhi 1), | (OR, koi ek bhi 1 ho to 1), ^ (XOR, exactly ek 1 ho to 1), ~ (NOT, sab bits ulat do). << left shift karta hai (har shift left = number ko 2 se multiply karne jaisa asar), >> signed right shift (divide by 2 jaisa, sign bit preserve hota hai negative numbers ke liye), aur >>> unsigned right shift (negative numbers ke sign bit ko bhi 0 se bhar deta hai).
Inn operators ka use low-level programming, flags/permissions ko ek hi int mein pack karke store karna (jaise file permissions read/write/execute), ya performance-critical bit-manipulation calculations mein hota hai. Roz-marra ke application code mein kam dikhte hain, lekin interviews mein bahut common hain.
int a = 5; // 0101
int b = 3; // 0011
System.out.println(a & b); // 1 (0001)
System.out.println(a | b); // 7 (0111)
System.out.println(a ^ b); // 6 (0110)
System.out.println(a << 1); // 10 (1010)
System.out.println(-8 >> 1); // -4 (sign preserved)
System.out.println(-8 >>> 1); // bahut bada positive numberCompound assignment operators (+=, -=, *=, /=, %=) shortcuts hain — x += 5 matlab x = x + 5. Ye sirf chhota likhne ka tarika nahi hai — inme ek implicit cast bhi hoti hai jo kabhi useful ho sakti hai: byte b = 10; b += 5; kaam karega, lekin b = b + 5; compile error dega (kyunki b+5 ek int expression banta hai, jise wapas byte mein manually cast karna padega).
Ternary operator (condition ? valueIfTrue : valueIfFalse) ek chhota if-else hai jo ek expression mein fit ho jaata hai — jab tumhe sirf ek value assign/return karni ho, condition ke basis par.
int marks = 75;
String result = (marks >= 40) ? "Pass" : "Fail";
byte b = 10;
b += 5; // works — implicit narrowing cast hoti hai
// b = b + 5; // ye error dega bina explicit cast keJab ek expression mein multiple operators ho, Java ek fixed order follow karta hai ki kaunsa pehle evaluate hoga — isse "precedence" kehte hain. Sabse high precedence unary operators (++, --, !) ki hoti hai, fir arithmetic (* / % pehle, + - baad mein), fir relational (< > ==), fir logical (&& phir ||), aur sabse last assignment (=).
Jab confusion ho, parentheses () use karo — ye sirf readable nahi banate, precedence ko explicitly override bhi karte hain aur bugs se bachate hain.
| Precedence (High → Low) | Operators |
|---|---|
| 1. Unary | ++ -- ! ~ |
| 2. Multiplicative | * / % |
| 3. Additive | + - |
| 4. Relational | < > <= >= |
| 5. Equality | == != |
| 6. Logical AND | && |
| 7. Logical OR | || |
| 8. Ternary | ? : |
| 9. Assignment | = += -= *= /= |