05. ఆపరేటర్లు, ఎక్స్ప్రెషన్స్ & టైప్ కాస్టింగ్ (Operators, Expressions & Type Casting)
డేటాను కేవలం వేరియబుల్స్లో నిల్వ చేయడం మాత్రమే సరిపోదు; ఆ డేటా ఆధారంగా లెక్కలు కట్టడం, షరతులను పరీక్షించడం, మరియు వివిధ రకాల డేటాను ఒకదానితో ఒకటి అనుసంధానించడం నిజమైన సాఫ్ట్వేర్ పవర్ను వెలికితీస్తుంది. జావాలో ఆపరేటర్లు మరియు టైప్ కాస్టింగ్ అనేవి సాఫ్ట్వేర్ ఇంజిన్ యొక్క శక్తివంతమైన గేర్లు లాంటివి.
గణిత పనిముట్లు & కరెన్సీ ఎక్స్ఛేంజ్ కౌంటర్ అనాలజీ (The Math Tools & Currency Exchange Analogy):
1. Operators (ప్రాసెసింగ్ పనిముట్లు - Processing Tools): ముడి ఇనుమును యంత్రాలుగా మార్చే సుత్తి, రంపం మరియు స్క్రూడ్రైవర్ లాంటివే జావా ఆపరేటర్లు (+, -, *, /, %, &&, ||, !). ఇవి వేరియబుల్స్ మధ్య విలువలను సృష్టించడానికి ఉపయోగపడే ప్రధాన పరికరాలు.
2. Widening Type Casting (చిన్న గ్లాసులోని నీటిని పెద్ద బకెట్లో పోయడం - Safe & Automatic): ఒక చిన్న int వేరియబుల్ను పెద్ద double పాత్రలోకి మార్చడం చాలా సులభం. నీరు ఒక్క చుక్క కూడా కింద పడదు, ఎందుకంటే బకెట్ కెపాసిటీ చాలా పెద్దది. దీనిని కంపైలర్ స్వయంచాలకంగా (Implicitly) చేస్తుంది.
3. Narrowing Type Casting (పెద్ద బకెట్లోని నీటిని చిన్న గ్లాసులోకి కుదించడం - Manual & Risky): ఒక 8-బైట్ల double సంఖ్యను బలవంతంగా 4-బైట్ల int గ్లాసులోకి కుదిస్తే దశాంశాలు నేలపాలైపోతాయి (Data Truncation). అందుకే డెవలపర్ రిస్క్ తీసుకుని చేతులారా (int) 99.85 అని రాస్తేనే జావా అనుమతిస్తుంది.
4. Short-Circuit Logic (ఫాస్ట్ సేఫ్టీ సర్క్యూట్ బ్రేకర్): ఇంట్లో మెయిన్ స్విచ్ ఆఫ్ అయితే మిగిలిన స్విచ్లను చూడనవసరం లేనట్లే, && ఆపరేటర్లో మొదటి కండిషన్ ఫెయిల్ అయితే రెండో కండిషన్ను అసలు లెక్కించకుండా సమయాన్ని ఆదా చేస్తుంది.
ఈ ఐదవ అధ్యాయంతో మనం Part 01: Basics & JVM ను దిగ్విజయంగా పూర్తి చేస్తాము! ఈ పాఠంలో ఆపరేటర్ల ప్రిసిడెన్స్, ఇంక్రిమెంట్ సూక్ష్మాలు, మరియు టైప్ కాస్టింగ్ యొక్క లోతైన ఎంటర్ప్రైజ్ పద్ధతులను నేర్చుకుందాం.
1 ఆపరేటర్ల వర్గీకరణ & Precedence టేబుల్
ఒక ఎక్స్ప్రెషన్లో బహుళ ఆపరేటర్లు ఉన్నప్పుడు ఏ ఆపరేషన్ ముందు జరగాలో నిర్ణయించే సూత్రాలనే Operator Precedence & Associativity అంటారు. గణితంలో BODMAS సూత్రం లాంటిదే ఇది:
| ప్రాధాన్యత (Precedence) | ఆపరేటర్ రకం | చిహ్నాలు (Symbols) | దిశ (Associativity) |
|---|---|---|---|
| 1 (అత్యున్నత) | Postfix & బ్రాకెట్స్ | () [] . expr++ expr-- |
ఎడమ నుండి కుడికి (Left to Right) |
| 2 | Unary (ఏకపక్ష) | ++expr --expr +expr -expr ! ~ |
కుడి నుండి ఎడమకు (Right to Left) |
| 3 | గుణకారం & భాగహారం | * / % |
ఎడమ నుండి కుడికి |
| 4 | కూడిక & తీసివేత | + - |
ఎడమ నుండి కుడికి |
| 5 | షిఫ్ట్ ఆపరేటర్లు | << >> >>> |
ఎడమ నుండి కుడికి |
| 6 | రిలేషనల్ & టైప్ చెక్ | < > <= >= instanceof |
ఎడమ నుండి కుడికి |
| 7 | ఈక్వాలిటీ (సమానత్వం) | == != |
ఎడమ నుండి కుడికి |
| 8 | లాజికల్ షార్ట్-సర్క్యూట్ | && || |
ఎడమ నుండి కుడికి |
| 9 (కనిష్ట) | అసైన్మెంట్ | = += -= *= /= %= &= |= |
కుడి నుండి ఎడమకు (Right to Left) |
2 అంకగణిత ఆపరేటర్లు & Modulo (%) విశిష్టత
జావాలో 5 ప్రాథమిక అంకగణిత ఆపరేటర్లు ఉన్నాయి: + (కూడిక), - (తీసివేత), * (గుణకారం), / (భాగహారం), మరియు % (శేషం - Modulo). వీటితో పాటు స్ట్రింగ్ కాన్క్యాటనేషన్ (String Concatenation) లో + ఆపరేటర్ ప్రవర్తన అత్యంత ఆసక్తికరంగా ఉంటుంది:
⚡ String Concatenation vs Arithmetic Addition:
జావాలో + ఆపరేటర్ ముందు లేదా తర్వాత ఏదైనా ఒక స్ట్రింగ్ ఉంటే, మొత్తం ఆపరేషన్ కాన్క్యాటనేషన్ (పదాలను కలపడం) గా మారుతుంది:
• System.out.println("Result: " + 10 + 20); → ప్రింట్ అయ్యేది: Result: 1020 (ఎందుకంటే ఎడమ నుండి కుడికి లెక్కించినప్పుడు మొదట "Result: 10" స్ట్రింగ్ అవుతుంది, తర్వాత 20 కలుస్తుంది).
• System.out.println("Result: " + (10 + 20)); → ప్రింట్ అయ్యేది: Result: 30 (బ్రాకెట్లకు ప్రాధాన్యత ఉండటం వల్ల మొదట కూడిక జరుగుతుంది).
• System.out.println(10 + 20 + " is the sum"); → ప్రింట్ అయ్యేది: 30 is the sum (ముందుగా రెండు పూర్ణాంకాలు కూడబడి తర్వాత స్ట్రింగ్కు కలుస్తాయి).
⚡ Integer Division vs Modulo Trap:
1. ఇంటిజర్ డివిజన్: రెండు పూర్ణాంకాలను భాగించినప్పుడు ఫలితం కూడా పూర్ణాంకమే వస్తుంది. దశాంశాలు పూర్తిగా రద్దు చేయబడతాయి (Truncation):
• int res = 10 / 4; → ఫలితం 2 వస్తుంది (2.5 కాదు!).
• దశాంశాలతో కావాలంటే కనీసం ఒక ఆపరాండ్ డబుల్ అయి ఉండాలి: double res = 10.0 / 4; → ఫలితం 2.5.
2. మోడ్యులో (%) శేషం: భాగించగా మిగిలిన శేషాన్ని ఇస్తుంది. ఒక సంఖ్య సరిసంఖ్యో (Even) లేదా బేసిసంఖ్యో (Odd) కనుగొనడానికి మరియు సైక్లిక్ ఇండెక్సింగ్ కోసం మోడ్యులో అత్యంత ప్రసిద్ధి:
• 10 % 3 = 1
• 14 % 2 = 0 (Even Number).
• నెగెటివ్ సంఖ్యల మోడ్యులో: -10 % 3 = -1 (జావాలో శేషం గుర్తు ఎల్లప్పుడూ మొదటి సంఖ్య యొక్క గుర్తునే అనుసరిస్తుంది).
3 ఇంక్రిమెంట్ & డిక్రిమెంట్: pre (++i) vs post (i++)
జావా ఇంటర్వ్యూలలో తరచుగా అడిగే ట్రిక్కీ కాన్సెప్ట్ — ప్రీ-ఇంక్రిమెంట్ మరియు పోస్ట్-ఇంక్రిమెంట్ మధ్య గల తేడా:
| రకం | సింటాక్స్ | పనితీరు సూత్రం | ఎగ్జాంపుల్ |
|---|---|---|---|
| Pre-Increment (ముందు పెంచడం) | ++i |
"First Increment, Then Use" — ముందుగా వేరియబుల్ విలువ 1 పెరుగుతుంది, ఆ తర్వాతే ఆ విలువ ప్రస్తుత ఎక్స్ప్రెషన్లో వాడబడుతుంది. | int i = 5; int a = ++i; // a = 6, i = 6 |
| Post-Increment (తర్వాత పెంచడం) | i++ |
"First Use, Then Increment" — ముందుగా ఉన్న పాత విలువ ప్రస్తుత ఎక్స్ప్రెషన్లో వాడబడుతుంది, ఆ స్టేట్మెంట్ ముగిసిన తర్వాత మాత్రమే విలువ 1 పెరుగుతుంది. | int i = 5; int b = i++; // b = 5, i = 6 |
4 అసైన్మెంట్ & కాంపౌండ్ ఆపరేటర్లు (+=, -=, *=)
ఒక వేరియబుల్లోని విలువను నవీకరించడానికి కాంపౌండ్ అసైన్మెంట్ ఆపరేటర్లు కోడ్ను ఎంతో కాంపాక్ట్గా మారుస్తాయి. అంతేకాకుండా వీటిలో ఒక రహస్యమైన అంతర్గత టైప్ కాస్టింగ్ దాగి ఉంటుంది:
💡 The Secret Casting of Compound Operators:
సాధారణంగా byte b = 10; b = b + 1; అని రాస్తే జావా కంపైల్-టైమ్ ఎర్రర్ ఇస్తుంది (ఎందుకంటే b + 1 అనేది ఆటోమేటిక్గా int గా మారుతుంది).
కానీ b += 1; అని రాస్తే ఎర్రర్ రాదు! ఎందుకంటే కాంపౌండ్ ఆపరేటర్ అంతర్గతంగా b = (byte)(b + 1); అని ఆటోమేటిక్ కాస్ట్ చేస్తుంది.
5 రిలేషనల్ ఆపరేటర్లు & టెర్నరీ ఆపరేటర్ (? :)
రెండు విలువల మధ్య సంబంధాన్ని పరీక్షించి ఎల్లప్పుడూ true లేదా false బూలియన్ విలువను అందించే ఆపరేటర్లు:
==(Equal to): రెండు ప్రిమిటివ్ విలువలు సమానమా అని చూస్తుంది. (హెచ్చరిక: ఆబ్జెక్టులు & స్ట్రింగ్స్కి.equals()వాడాలి).!=(Not equal to): సమానం కాదా?>,<(Greater than, Less than): ఎక్కువ లేదా తక్కువ.>=,<=(Greater than or equal, Less than or equal).
🎯 The Ternary Operator (? :) — Inline Decision Making:
జావాలో మూడు ఆపరాండ్లు తీసుకునే ఏకైక ఆపరేటర్ Ternary Operator (షరతు ఆధారిత ఆపరేటర్). ఇది 4 లైన్ల if-else కోడ్ను ఒకే లైన్లోకి కుదిస్తుంది:
• సింటాక్స్: variable = (condition) ? valueIfTrue : valueIfFalse;
• ఉదాహరణ: int max = (a > b) ? a : b;
• ప్రాక్టికల్ వినియోగం: యూజర్ స్టేటస్ నిర్ణయించడం: String status = (userAge >= 18) ? "MAJOR" : "MINOR";. దీని వల్ల కోడ్ ఎంతో క్లీన్గా మరియు వేగవంతంగా మారుతుంది.
🧮 Java Math క్లాస్ యుటిలిటీస్:
క్లిష్టమైన గణిత శాస్త్ర లెక్కలను సులభతరం చేయడానికి జావా java.lang.Math క్లాస్ను అందిస్తుంది. దీనిలోని అన్ని మెథడ్స్ స్టాటిక్:
• Math.max(a, b) / Math.min(a, b): గరిష్ట మరియు కనిష్ట విలువలు.
• Math.sqrt(25): వర్గమూలం (Square root → 5.0).
• Math.pow(2, 8): ఘాతాంకం (Power → 256.0).
• Math.abs(-50): సంపూర్ణ ధన విలువ (Absolute → 50).
• Math.round(45.75): సమీప పూర్ణాంకానికి రౌండ్ చేయడం (46).
6 లాజికల్ ఆపరేటర్లు & Short-Circuit మూల్యాంకనం
బహుళ షరతులను కలపడానికి వాడే తార్కిక ఆపరేటర్లు:
⚡ Short-Circuit Evaluation Mechanics:
1. Logical AND (&&): రెండు షరతులూ true అయితేనే true. ఒకవేళ మొదటి శరతు false అయితే, రెండవ శరతును JVM అసలు ముట్టుకోదు! (ఫలితం ఎలాగూ false కాబట్టి). దీని వల్ల NullPointerException రాకుండా నిరోధించవచ్చు: if (user != null && user.isActive()).
2. Logical OR (||): ఏదో ఒక శరతు true అయినా true. ఒకవేళ మొదటి శరతు true అయితే, రెండవ శరతును లెక్కించకుండానే ఫలితం true గా నిర్ణయిస్తుంది.
3. Logical NOT (!): ఫలితాన్ని తిరగవేస్తుంది (true ని false గా, false ని true గా).
7 బిట్వైజ్ ఆపరేటర్లు (&, |, ^, ~, <<, >>)
హార్డ్వేర్ లెవల్ డేటా, నెట్వర్క్ ప్యాకెట్లు, మరియు ఎన్క్రిప్షన్ ప్రోగ్రామింగ్లో పూర్ణాంకాల బైనరీ బిట్స్ (0s & 1s) పై నేరుగా పనిచేసే ఆపరేటర్లు:
&(Bitwise AND): రెండు బిట్లు 1 అయితేనే 1.|(Bitwise OR): ఏదో ఒక బిట్ 1 అయినా 1.^(Bitwise XOR): రెండు బిట్లు వేర్వేరు అయితేనే 1 (1^0=1, 1^1=0).~(Bitwise Complement): బిట్లను తిరగవేస్తుంది (1 ని 0, 0 ని 1 గా).<<(Left Shift): బిట్లను ఎడమవైపుకి జరుపుతుంది (సంఖ్యను 2 యొక్క ఘాతాలతో గుణించినట్లే:x << 1అంటేx * 2).>>(Signed Right Shift): బిట్లను కుడివైపుకి జరుపుతుంది (సంఖ్యను 2 తో భాగించినట్లే:x >> 1అంటేx / 2).
8 టైప్ కాస్టింగ్: Implicit Widening vs Explicit Narrowing
ఒక డేటా టైప్లోని విలువను మరొక డేటా టైప్లోకి మార్చడాన్ని Type Casting అంటారు. జావాలో రెండు ప్రాథమిక మార్గాలు ఉన్నాయి:
| రకం | మార్పిడి క్రమం | ఎలా జరుగుతుంది? | డేటా నష్టం? |
|---|---|---|---|
| Widening Casting (Implicit / ఆటోమేటిక్) | byte → short → char → int → long → float → double |
జావా కంపైలర్ స్వయంచాలకంగా మార్పిడి చేస్తుంది. | 0% నష్టం (సురక్షితమైనది). చిన్న పాత్రలోని నీరు పెద్ద పాత్రలోకి సులభంగా సర్దుకుంటుంది. |
| Narrowing Casting (Explicit / మ్యాన్యువల్) | double → float → long → int → char → short → byte |
డెవలపర్ స్వయంగా బ్రాకెట్లలో టైప్ పేర్కొనాలి: (int) myDouble |
అధిక నష్టం (దశాంశాలు కోల్పోవడం లేదా విలువ సైజును మించిపోతే ఓవర్ఫ్లో జరగడం). |
🔬 Type Promotion in Expressions (ఎక్స్ప్రెషన్లలో ఆటోమేటిక్ ప్రమోషన్):
జావాలో అంకగణిత గణనలు జరిగేటప్పుడు కంపైలర్ కొన్ని అంతర్గత ప్రమోషన్ నిబంధనలను పాటిస్తుంది:
1. byte, short, మరియు char వేరియబుల్స్ ఏదైనా గణనలో పాల్గొన్నప్పుడు అవి ఆటోమేటిక్గా int గా ప్రమోట్ అవుతాయి. ఉదాహరణకు: byte a = 10, b = 20; byte c = a + b; ❌ (ఎర్రర్ వస్తుంది, ఎందుకంటే a + b ఫలితం int. దీనిని byte c = (byte)(a + b); అని రాయాలి).
2. ఒక ఎక్స్ప్రెషన్లో ఏదైనా ఒక ఆపరాండ్ long అయితే మొత్తం ఎక్స్ప్రెషన్ long గా మారుతుంది.
3. ఏదైనా ఒక ఆపరాండ్ float అయితే మొత్తం ఫలితం float గా, ఏదైనా ఒకటి double అయితే మొత్తం ఫలితం double గా ప్రమోట్ చేయబడుతుంది.
9 కోడ్ డెమో 1: కాంప్లెక్స్ ఎక్స్ప్రెషన్స్ & ప్రిసిడెన్స్ ఎవాల్యుయేటర్
ఆపరేటర్ ప్రిసిడెన్స్ మరియు పోస్ట్/ప్రీ ఇంక్రిమెంట్ల ఆధారంగా కాంప్లెక్స్ ఎక్స్ప్రెషన్స్ ఎలా రన్ అవుతాయో స్టెప్-బై-స్టెప్ విశ్లేషించే ప్రోగ్రామ్:
public class ExpressionEvaluator {
public static void main(String[] args) {
System.out.println("==================================================");
System.out.println(" COMPLEX EXPRESSION & PRECEDENCE EVALUATOR ");
System.out.println("==================================================");
int a = 10;
int b = 5;
int c = 2;
// Expression without parenthesis
int result1 = a + b * c; // Multiplied first: 10 + 10 = 20
// Expression with parenthesis overriding precedence
int result2 = (a + b) * c; // Added first: 15 * 2 = 30
System.out.printf(" 10 + 5 * 2 = %d (Multiplication precedence)%n", result1);
System.out.printf(" (10 + 5) * 2 = %d (Parentheses override)%n", result2);
System.out.println("--------------------------------------------------");
// Increment quirks demonstration
int x = 5;
int y = x++ + ++x; // 5 + 7 = 12, x becomes 7
System.out.printf(" x = 5; x++ + ++x = %d (Final x = %d)%n", y, x);
// Integer division vs floating division
int intDiv = 10 / 4;
double floatDiv = 10.0 / 4;
System.out.printf(" 10 / 4 (Integer) = %d%n", intDiv);
System.out.printf(" 10.0 / 4 (Floating) = %.1f%n", floatDiv);
System.out.println("==================================================");
}
}
==================================================
COMPLEX EXPRESSION & PRECEDENCE EVALUATOR
==================================================
10 + 5 * 2 = 20 (Multiplication precedence)
(10 + 5) * 2 = 30 (Parentheses override)
--------------------------------------------------
x = 5; x++ + ++x = 12 (Final x = 7)
10 / 4 (Integer) = 2
10.0 / 4 (Floating) = 2.5
==================================================
10 కోడ్ డెమో 2: సురక్షితమైన టైప్ కాస్టింగ్ & ఓవర్ఫ్లో డిటెక్టర్
వైడనింగ్ మరియు నారోయింగ్ కాస్టింగ్ ఫలితాలు మరియు ఒక వేరియబుల్ తన పరిమితిని దాటినప్పుడు వచ్చే ఓవర్ఫ్లోను గుర్తించే డయాగ్నోస్టిక్ ప్రోగ్రామ్:
public class TypeCastingInspector {
public static void main(String[] args) {
System.out.println("--------------------------------------------------");
System.out.println(" TYPE CASTING & OVERFLOW INSPECTION ");
System.out.println("--------------------------------------------------");
// 1. Widening Casting (int to double) - 100% Safe
int smallNumber = 450;
double wideDouble = smallNumber;
System.out.println("Widening (int → double): " + wideDouble);
// 2. Narrowing Casting (double to int) - Truncates decimal part
double productPrice = 1299.85;
int truncatedPrice = (int) productPrice;
System.out.println("Narrowing (1299.85 → int): " + truncatedPrice + " (Lost .85)");
// 3. Overflow demonstration (byte range is -128 to 127)
int largeVal = 130;
byte overflowByte = (byte) largeVal; // Wraps around to negative!
System.out.println("Overflow (130 → byte) : " + overflowByte + " (Wrap-around!)");
// 4. Bitwise Shift for ultra-fast multiplication and division
int baseVal = 8;
int multipliedByFour = baseVal << 2; // 8 * (2^2) = 32
int dividedByTwo = baseVal >> 1; // 8 / (2^1) = 4
System.out.printf("Bitwise Shift: 8 << 2 = %d | 8 >> 1 = %d%n", multipliedByFour, dividedByTwo);
System.out.println("--------------------------------------------------");
}
}
--------------------------------------------------
TYPE CASTING & OVERFLOW INSPECTION
--------------------------------------------------
Widening (int → double): 450.0
Narrowing (1299.85 → int): 1299 (Lost .85)
Overflow (130 → byte) : -126 (Wrap-around!)
Bitwise Shift: 8 << 2 = 32 | 8 >> 1 = 4
--------------------------------------------------
11 కోడ్ డెమో 3: E-Commerce Discount, Tax & Currency Converter Engine (Capstone Mini Project)
ఆధునిక ఇ-కామర్స్ పోర్టల్ కోసం ఆర్డర్ సారాంశం, కూపన్ డిస్కౌంట్లు, జీఎస్టీ పన్నులు మరియు కరెన్సీ మార్పిడిని సమర్థవంతంగా గణించే E-Commerce Pricing & Billing Engine:
public class EcommerceBillingEngine {
public static void main(String[] args) {
String itemName = "Dell UltraSharp 27-inch 4K Monitor";
int itemQuantity = 2;
double unitPriceUSD = 350.00;
double usdToInrRate = 83.25;
double discountPercentage = 15.0; // 15% Promotional Coupon
double gstTaxPercentage = 18.0; // 18% GST
// Core Financial Equations
double subtotalUSD = itemQuantity * unitPriceUSD;
double discountUSD = (subtotalUSD * discountPercentage) / 100.0;
double discountedUSD = subtotalUSD - discountUSD;
double gstAmountUSD = (discountedUSD * gstTaxPercentage) / 100.0;
double finalTotalUSD = discountedUSD + gstAmountUSD;
// Currency Conversion to INR via Type Casting
double finalTotalINR = finalTotalUSD * usdToInrRate;
long roundedTotalINR = Math.round(finalTotalINR);
System.out.println("==================================================");
System.out.println(" E-COMMERCE ORDER INVOICE & BILLING ");
System.out.println("==================================================");
System.out.printf(" Item Name : %s%n", itemName);
System.out.printf(" Quantity : %d units @ $%.2f USD each%n", itemQuantity, unitPriceUSD);
System.out.println("--------------------------------------------------");
System.out.printf(" Subtotal : $%,10.2f USD%n", subtotalUSD);
System.out.printf(" Discount 15%% : -$%,9.2f USD%n", discountUSD);
System.out.printf(" GST Tax 18%% : +$%,9.2f USD%n", gstAmountUSD);
System.out.println("--------------------------------------------------");
System.out.printf(" TOTAL (USD) : $%,10.2f USD%n", finalTotalUSD);
System.out.printf(" EXCHANGE RATE: 1 USD = ₹ %.2f INR%n", usdToInrRate);
System.out.printf(" TOTAL (INR) : ₹ %,10d (Rounded)%n", roundedTotalINR);
System.out.println("==================================================");
}
}
=================================================="
E-COMMERCE ORDER INVOICE & BILLING
==================================================
Item Name : Dell UltraSharp 27-inch 4K Monitor
Quantity : 2 units @ $350.00 USD each
--------------------------------------------------
Subtotal : $ 700.00 USD
Discount 15% : -$ 105.00 USD
GST Tax 18% : +$ 107.10 USD
--------------------------------------------------
TOTAL (USD) : $ 702.10 USD
EXCHANGE RATE: 1 USD = ₹ 83.25 INR
TOTAL (INR) : ₹ 58,450 (Rounded)
==================================================
12 టాప్ 6 ఆపరేటర్ మిస్టేక్స్ & 5 క్విజ్లు
ఆపరేటర్లు మరియు టైప్ కాస్టింగ్లో కొత్త ప్రోగ్రామర్లు తరచుగా చేసే 6 ప్రధాన తప్పులు:
| లోపం | తప్పు కోడ్ | సరిదిద్దిన సరైన విధానం |
|---|---|---|
| ఇంటిజర్ డివిజన్ డెసిమల్స్ కోల్పోవడం | double d = 5 / 2; // 2.0 వస్తుంది |
double d = 5.0 / 2; // 2.5 వస్తుంది |
| ఈక్వాలిటీ (==) vs అసైన్మెంట్ (=) గందరగోళం | if (x = 10) // కంపైల్ ఎర్రర్ |
if (x == 10) |
| ఆబ్జెక్ట్స్ మరియు స్ట్రింగ్స్కి == వాడటం | if (str1 == str2) (మెమరీ అడ్రస్ చూస్తుంది) |
కంటెంట్ సమానత్వానికి if (str1.equals(str2)) వాడాలి. |
| షార్ట్-సర్క్యూట్ మిస్ అవ్వడం (& vs &&) | if (user != null & user.isValid()) (NullPointerException వస్తుంది) |
షార్ట్-సర్క్యూట్ కోసం && వాడాలి: if (user != null && user.isValid()) |
| నారోయింగ్ కాస్టింగ్లో బ్రాకెట్స్ మర్చిపోవడం | int x = (int) a + b; // కేవలం a మాత్రమే కాస్ట్ అవుతుంది |
మొత్తం రిజల్ట్ కాస్ట్ కావాలంటే: int x = (int) (a + b); |
| పోస్ట్ ఇంక్రిమెంట్ అసైన్మెంట్ ట్రాప్ | int i = 0; i = i++; // i ఎప్పటికీ 0 గానే ఉంటుంది |
కేవలం i++; అని మాత్రమే రాయాలి. |
🧠 మీ అవగాహనను పరీక్షించుకోండి (5 Interactive Quizzes):
ప్రశ్న 1: జావాలో '10 % 3' మరియు '-10 % 3' ల ఫలితాలు ఎంత?
సమాధానం: 10 % 3 = 1, మరియు -10 % 3 = -1. జావాలో మోడ్యులో ఫలితం ఎల్లప్పుడూ మొదటి ఆపరాండ్ (లబ్ధం) యొక్క చిహ్నాన్ని (Sign) అనుసరిస్తుంది.
ప్రశ్న 2: '&&' మరియు '&' ఆపరేటర్ల మధ్య గల ప్రధాన తేడా ఏమిటి?
సమాధానం: && షార్ట్-సర్క్యూట్ లాజికల్ ఆపరేటర్ (మొదటిది false అయితే రెండోది రన్ చేయదు). & అనేది బిట్వైజ్ ఆపరేటర్ (రెండు వైపులా తప్పనిసరిగా లెక్కించబడుతుంది).
ప్రశ్న 3: 'int' ను 'double' గా మార్చడానికి ఎక్స్ప్లిసిట్ కాస్టింగ్ అవసరమా?
సమాధానం: అవసరం లేదు! ఇది వైడనింగ్ (Widening Casting) కాబట్టి జావా కంపైలర్ ఆటోమేటిక్గా ఇంప్లిసిట్గా మారుస్తుంది.
ప్రశ్న 4: 'x << 1' చేయడం వల్ల గణితపరంగా సంఖ్యకు ఏమి జరుగుతుంది?
సమాధానం: ఆ సంఖ్య 2 తో గుణించబడుతుంది (Multiplied by 2).
ప్రశ్న 5: 'byte b = 127; b++;' రన్ చేస్తే b విలువ ఎంత అవుతుంది?
సమాధానం: -128! ఎందుకంటే బైట్ యొక్క గరిష్ట పరిమితి 127. అది దాటినప్పుడు బైనరీ సైకిల్ ప్రకారం కనీస నెగెటివ్ విలువ -128 కు చేరుకుంటుంది (Integer Overflow Wrap-around).