07. స్విచ్ స్టేట్మెంట్స్ & మోడరన్ స్విచ్ ఎక్స్ప్రెషన్స్ (Switch Statements & Modern Switch Expressions)
ఒక వేరియబుల్కు డజన్ల కొద్దీ విలువలలో ఏదో ఒకటి వచ్చే అవకాశం ఉన్నప్పుడు (ఉదాహరణకు వారంలోని 7 రోజులు, ట్రాఫిక్ సిగ్నల్ రంగులు, లేదా సర్వర్ ఎర్రర్ కోడ్లు), పదే పదే if-else if-else if ల్యాడర్ రాయడం కోడ్ను గజిబిజిగా మారుస్తుంది. దీనికి పరిష్కారంగా జావా వేగవంతమైన జంప్-టేబుల్ ఆర్కిటెక్చర్తో కూడిన switch స్టేట్మెంట్ను అందిస్తుంది.
మల్టీ-ఫ్లోర్ లిఫ్ట్ & స్మార్ట్ డిజిటల్ సెలెక్టర్ అనాలజీ (The Multi-Floor Elevator & Smart Selector Analogy):
1. Classic switch (సాంప్రదాయ లిఫ్ట్ బటన్ ప్యానెల్): 20 అంతస్తుల భవనంలో లిఫ్ట్ ఎక్కినప్పుడు ప్రతి అంతస్తు వద్ద ఆగి డోర్ తీయకుండా, నేరుగా 12వ బటన్ నొక్కితే 12వ అంతస్తుకే వెళ్లి ఆగే డైరెక్ట్ జంప్ మెకానిజం.
2. The break Statement & Fall-Through (ఆటోమేటిక్ డోర్ బ్రేక్): లిఫ్ట్ 12వ అంతస్తులో ఆగగానే break వేయకపోతే, ఆ కింద ఉన్న 13, 14, 15 ఫ్లోర్లలోకి ఆగకుండా జారిపోతుంది! ఈ ప్రమాదాన్నే Fall-Through Trap అంటారు.
3. Modern Java 14+ Switch Expressions (స్మార్ట్ టచ్ స్క్రీన్ లిఫ్ట్ - Arrow Syntax ->):
ఆధునిక జావాలో పాతకాలపు బోరింగ్ break రాయాల్సిన పనేలేదు! సరికొత్త బాణం గుర్తు -> ఆటోమేటిక్ బ్రేక్ ఇస్తుంది. అంతేకాకుండా స్విచ్ ఒక ఫలితాన్ని వేరియబుల్కు నేరుగా రిటర్న్ చేయగలదు (Expression) మరియు క్లిష్టమైన బ్లాక్స్ కోసం yield కీవర్డ్ తోడుగా ఉంటుంది.
ఈ ఏడవ పాఠంలో క్లాసిక్ స్విచ్ పరిమితులు, మోడరన్ జావా 14+ స్విచ్ ఎక్స్ప్రెషన్స్ (Arrow Labels), మరియు క్లౌడ్ సర్వర్ టైర్ ప్రైసింగ్ కాప్స్టోన్ ఇంజిన్ రూపకల్పనను సమగ్రంగా నేర్చుకుందాం!
1 switch స్టేట్మెంట్ ఉద్దేశం & if-else కంటే ఎందుకు ఫాస్ట్?
ఒక వేరియబుల్లోని విలువను బట్టి అనేక మార్గాలలో ఒకదానిని ఎంచుకోవడానికి switch స్టేట్మెంట్ ఉపయోగపడుతుంది. సాధారణ else-if ల్యాడర్లో కంప్యూటర్ ప్రతి షరతును వరుసగా (O(N) లీనియర్ క్రమంలో) చెక్ చేసుకుంటూ వెళ్లాలి. అంటే 10వ కండిషన్ మ్యాచ్ అవ్వాలంటే ముందున్న 9 కండిషన్లనూ తప్పనిసరిగా లెక్కించాలి. కానీ switch లో కంపైలర్ బైట్కోడ్లో tableswitch లేదా lookupswitch అనే ఇంటర్నల్ జంప్ టేబుల్ను నిర్మిస్తుంది:
⚡ Internal JVM Architecture: tableswitch vs lookupswitch:
1. tableswitch (వరుస సంఖ్యల కోసం - O(1) Time): కేస్ విలువలు వరుస క్రమంలో ఉంటే (ఉదా: 1, 2, 3, 4), JVM ఒక అరే ఇండెక్స్ తరహాలో O(1) కాన్స్టాంట్ టైమ్లో తక్షణమే సంబంధిత మెమరీ అడ్రస్కు జంప్ చేస్తుంది! మధ్యలో ఎన్ని వేల లైన్లు ఉన్నా ఫలితం ఒక్క సైకిల్లోనే తేలిపోతుంది.
2. lookupswitch (వివిక్త విలువల కోసం - O(log N) Time): కేస్ విలువలు వివిక్తంగా లేదా అస్తవ్యస్తంగా ఉంటే (ఉదా: 10, 500, 9999), కంపైలర్ వాటిని బైనరీ సెర్చ్ ట్రీ రూపంలో అమరుస్తుంది. లీనియర్ ఇఫ్-ఎల్స్ కంటే ఇది ఎన్నో రెట్లు వేగవంతమైనది.
అందువల్ల 5 కంటే ఎక్కువ బ్రాంచ్లు ఉన్నప్పుడు మరియు కచ్చితమైన విలువలను పరీక్షించేటప్పుడు switch వాడటం పరిశ్రమ ప్రామాణికం.
2 స్విచ్ సపోర్ట్ చేసే డేటా టైప్స్
జావాలో స్విచ్ అన్ని రకాల డేటా టైప్స్ను అంగీకరించదు. కేవలం కింది నిర్దిష్ట డేటా టైప్స్కు మాత్రమే స్విచ్ సపోర్ట్ ఉంది:
| అనుమతించబడిన డేటా టైప్స్ (Allowed) | అనుమతించబడని డేటా టైప్స్ (Disallowed - కంపైల్ ఎర్రర్) |
|---|---|
• byte, short, char, int (మరియు వాటి Wrapper Classes: Byte, Short, Character, Integer) |
• float, double (దశాంశాల అనిశ్చితి వల్ల స్విచ్ సపోర్ట్ చేయదు) |
• String (జావా 7 నుండి సపోర్ట్ అందుబాటులోకి వచ్చింది) |
• long (64-bit పరిమాణం వల్ల జంప్ టేబుల్ అసాధ్యం) |
• enum (జావా 5 నుండి ఎన్యూమరేషన్స్ సపోర్ట్) |
• boolean (కేవలం true/false మాత్రమే కాబట్టి if-else వాడాలి) |
3 case, break & default లేబుల్స్ అనాటమీ
క్లాసిక్ స్విచ్ స్టేట్మెంట్లో ప్రతి బ్రాంచ్ను case లేబుల్తో గుర్తిస్తాం. ప్రతి కేస్ చివర break; స్టేట్మెంట్ రాయడం అత్యంత ముఖ్యం:
switch (dayOfWeek) {
case 1:
System.out.println("సోమవారం (Monday)");
break;
case 2:
System.out.println("మంగళవారం (Tuesday)");
break;
case 3:
System.out.println("బుధవారం (Wednesday)");
break;
default:
System.out.println("చెల్లని వారం సంఖ్య!");
}
default లేబుల్: పైన పేర్కొన్న ఏ ఒక్క కేస్ కూడా మ్యాచ్ కానప్పుడు default బ్లాక్ రన్ అవుతుంది (if-else లోని చివరి else లాంటిది).
4 Fall-Through బిహేవియర్: ఉద్దేశపూర్వక & ప్రమాదకరమైన సందర్భాలు
ఒక case బ్లాక్ చివర break రాయడం మర్చిపోతే, తర్వాతి కేస్ యొక్క షరతు మ్యాచ్ కాకపోయినప్పటికీ ఆ కోడ్ కూడా రన్ అవుతుంది! దీనినే Fall-Through అంటారు:
🎯 When Fall-Through is Useful (ఉద్దేశపూర్వక వినియోగం):
బహుళ కేస్లకు ఒకే లాజిక్ రన్ చేయాలనుకున్నప్పుడు ఫాల్-త్రూ ఉద్దేశపూర్వకంగా వాడతారు:
case 1: case 2: case 3: case 4: case 5: System.out.println("వారపు పనిదినం (Weekday)"); break;
case 6: case 7: System.out.println("వారాంతపు సెలవు (Weekend)"); break;
అయితే 90% సందర్భాలలో బిగినర్లు పొరపాటున break మర్చిపోయి భయంకరమైన బగ్స్ను సృష్టిస్తుంటారు.
5 Modern Switch Expressions ఆవిర్భావం (JEP 361)
పాతకాలపు స్విచ్లోని break స్టేట్మెంట్లు, బాయిలర్ప్లేట్ కోడ్, మరియు ఫాల్-త్రూ బగ్స్ను శాశ్వతంగా నిర్మూలించడానికి జావా 14 లో అధికారికంగా Switch Expressions (JEP 361) ను విడుదల చేశారు.
🚀 Statement vs Expression:
• Statement: కేవలం ఒక పనిని చేస్తుంది, కానీ ఎలాంటి విలువను వెనక్కి ఇవ్వదు (రిటర్న్ చేయదు).
• Expression: ఒక పనిని పూర్తి చేసుకుని ఒక నిర్దిష్ట విలువను (Result) నేరుగా వేరియబుల్కు అందజేస్తుంది. ఉదా: var result = switch(day) { ... };
6 Arrow Syntax (->) తో నో-ఫాల్త్రూ గ్యారెంటీ
ఆధునిక జావాలో కోలన్ : బదులుగా బాణం గుర్తు -> (Arrow Syntax) వాడతాం. ఇందులో break రాయాల్సిన అవసరమే లేదు! కంపైలర్ స్వయంచాలకంగా సంబంధిత కేస్ను మాత్రమే రన్ చేసి బయటకు వచ్చేస్తుంది:
case 1, 2, 3, 4, 5 -> "వారపు పనిదినం (Weekday)";
case 6, 7 -> "వారాంతపు సెలవు (Weekend)";
default -> "చెల్లని సంఖ్య";
}; // గమనిక: స్విచ్ ఎక్స్ప్రెషన్ చివర సెమీకోలన్ తప్పనిసరి!
7 yield కీవర్డ్: స్విచ్ బ్లాక్ నుండి రిటర్న్ వాల్యూస్
ఒక కేస్ లోపల కేవలం ఒకే లైన్ కాకుండా, బహుళ లైన్ల లాజిక్ లేదా లాగింగ్ అవసరమైనప్పుడు కర్లీ బ్రాకెట్స్ { } వాడి, చివరి విలువను బయటకు పంపడానికి yield కీవర్డ్ ఉపయోగిస్తాం:
🔬 The 'yield' Keyword Explained:
మెథడ్స్ లోపల return ఎలాగో, స్విచ్ ఎక్స్ప్రెషన్ బ్లాక్ లోపల yield అలా పనిచేస్తుంది:
case "VIP" -> {
System.out.println("Applying Premium VIP Benefits");
double discount = calculateSpecialDiscount();
yield discount;
};
8 మల్టిపుల్ కామా-సెపరేటెడ్ లేబుల్స్ & Java 21 ప్యాటర్న్ మ్యాచింగ్
ఆధునిక జావా స్విచ్లో బహుళ విలువల కోసం వేర్వేరు లైన్లు రాయకుండా ఒకే లైన్లో కామాతో వేరుచేయవచ్చు: case "MON", "WED", "FRI" -> ...
🔒 Exhaustiveness Requirement (పరిపూర్ణత నిబంధన):
స్విచ్ను ఒక ఎక్స్ప్రెషన్గా వాడి విలువను రిటర్న్ చేస్తున్నప్పుడు, ప్రవేశపెట్టిన వేరియబుల్ యొక్క అన్ని సంభావ్య విలువలనూ తప్పనిసరిగా కవర్ చేయాలి! కాబట్టి స్విచ్ ఎక్స్ప్రెషన్లో default లేబుల్ ఖచ్చితంగా ఉండాలి (Enum వాడి అన్ని enum కాన్స్టాంట్స్ కవర్ చేసినప్పుడు మినహా).
🚀 Modern Java 21 Pattern Matching for switch (JEP 441):
జావా 21 LTS లో విడుదలైన అత్యంత శక్తివంతమైన ఫీచర్ — Pattern Matching for switch. గతంలో ఒక ఆబ్జెక్ట్ రకాన్ని తెలుసుకోవడానికి పదే పదే instanceof మరియు టైప్ కాస్టింగ్ రాయాల్సి వచ్చేది. ఇప్పుడు నేరుగా స్విచ్లోనే టైప్ ప్యాటర్న్స్ మరియు when గార్డ్స్ వాడవచ్చు:
static String formatValue(Object obj) {
return switch (obj) {
case Integer i -> String.format("పూర్ణాంకం: %d", i);
case Double d -> String.format("దశాంశం: %.2f", d);
case String s when s.length() > 5 -> "పొడవైన పదం: " + s.toUpperCase();
case String s -> "చిన్న పదం: " + s;
case null -> "[నల్ ఆబ్జెక్ట్]";
default -> "గుర్తించబడని రకం: " + obj.toString();
};
}
ఈ సరికొత్త జావా 21 సింటాక్స్ ద్వారా కోడ్ ఎంతో సురక్షితంగా మరియు ఆధునికంగా మారుతుంది.
🔬 How String Switching Works Internally (Bytecode Level):
స్ట్రింగ్స్ను స్విచ్ చేసినప్పుడు కంపైలర్ రెండు దశలలో పనిచేస్తుంది:
1. మొదట స్ట్రింగ్ యొక్క hashCode() ను లెక్కించి ఇంటీజర్ జంప్ టేబుల్ను ఎగ్జిక్యూట్ చేస్తుంది.
2. వేర్వేరు స్ట్రింగ్స్కు ఒకే హ్యాష్కోడ్ వచ్చే అవకాశం (Hash Collision) ఉంటుంది కాబట్టి, ధృవీకరణ కోసం అంతర్గతంగా equals() మెథడ్ను కాల్ చేసి కచ్చితమైన సమానత్వాన్ని నిర్ధారిస్తుంది!
9 కోడ్ డెమో 1: వీక్లీ షెడ్యూల్ ప్లానర్ (Classic vs Modern Switch)
సాంప్రదాయ బ్రేక్ ఆధారిత స్విచ్ మరియు ఆధునిక యారో సింటాక్స్ స్విచ్ ఎక్స్ప్రెషన్ల మధ్య వ్యత్యాసాన్ని స్పష్టంగా ప్రదర్శించే లైవ్ ప్రోగ్రామ్:
public class WeeklySchedulePlanner {
public static void main(String[] args) {
System.out.println("==================================================");
System.out.println(" WEEKLY SCHEDULE & WORKFLOW PLANNER ENGINE ");
System.out.println("==================================================");
int dayNumber = 4; // Thursday
// 1. Classic Switch Statement with Fall-through & Break
System.out.print("[CLASSIC SWITCH] Day " + dayNumber + " is: ");
switch (dayNumber) {
case 1: System.out.println("Monday (Sprint Planning)"); break;
case 2: System.out.println("Tuesday (Code Development)"); break;
case 3: System.out.println("Wednesday (Mid-week Sync)"); break;
case 4: System.out.println("Thursday (Code Review & QA)"); break;
case 5: System.out.println("Friday (Deployment to Staging)"); break;
case 6: case 7: System.out.println("Weekend (Recharge & Family)"); break;
default: System.out.println("Invalid day index!");
}
// 2. Modern Java 14+ Switch Expression with Arrow Syntax
String focusArea = switch (dayNumber) {
case 1 -> "Sprint Planning & Architecture Roadmap";
case 2, 3 -> "Core Feature Implementation (Full-Throttle)";
case 4 -> "Automated Testing, Security Audit & PR Reviews";
case 5 -> "Production Release & Monitoring";
case 6, 7 -> "Offline (Personal Downtime)";
default -> "Unassigned Day";
};
System.out.println("--------------------------------------------------");
System.out.println("[MODERN SWITCH] Focus Area: " + focusArea);
System.out.println("==================================================");
}
}
==================================================
WEEKLY SCHEDULE & WORKFLOW PLANNER ENGINE
==================================================
[CLASSIC SWITCH] Day 4 is: Thursday (Code Review & QA)
--------------------------------------------------
[MODERN SWITCH] Focus Area: Automated Testing, Security Audit & PR Reviews
==================================================
10 కోడ్ డెమో 2: ఇ-కామర్స్ ఆర్డర్ స్టేటస్ ట్రాకర్ (String Switching)
స్ట్రింగ్ ఆబ్జెక్టులను స్విచ్లో ఉపయోగించి లాజిస్టిక్స్ డెలివరీ స్టేటస్ను విశ్లేషించే ఎంటర్ప్రైజ్ ఆర్డర్ ట్రాకర్ ప్రోగ్రామ్:
public class OrderStatusTracker {
public static void main(String[] args) {
String trackingId = "IND-DEL-984210";
String currentStatus = "OUT_FOR_DELIVERY";
System.out.println("--------------------------------------------------");
System.out.println(" LOGISTICS ORDER DISPATCH & TRACKING ");
System.out.println("--------------------------------------------------");
System.out.println("Tracking ID : " + trackingId);
System.out.println("Current Status: " + currentStatus);
// String based Modern Switch Expression
String customerAlert = switch (currentStatus.toUpperCase()) {
case "ORDER_PLACED" -> "Your order has been confirmed by the merchant.";
case "PROCESSING" -> "Warehouse team is currently packaging your items.";
case "SHIPPED" -> "Package has left the central distribution hub.";
case "OUT_FOR_DELIVERY" -> {
String deliveryExecutive = "శ్రీకాంత్ యాదవ్ (Ph: +91 98765 43210)";
yield "Out for delivery today! Agent: " + deliveryExecutive;
}
case "DELIVERED" -> "Package delivered successfully! Thank you for shopping.";
case "CANCELLED", "RETURNED" -> "Order was canceled. Refund initiated to source bank.";
default -> "Unknown status code. Please contact customer care.";
};
System.out.println("--------------------------------------------------");
System.out.println("Customer Notification:
>> " + customerAlert);
System.out.println("--------------------------------------------------");
}
}
--------------------------------------------------
LOGISTICS ORDER DISPATCH & TRACKING
--------------------------------------------------
Tracking ID : IND-DEL-984210
Current Status: OUT_FOR_DELIVERY
--------------------------------------------------
Customer Notification:
>> Out for delivery today! Agent: శ్రీకాంత్ యాదవ్ (Ph: +91 98765 43210)
--------------------------------------------------
11 కోడ్ డెమో 3: Cloud Server Billing Tier Engine (Capstone Mini Project)
ఒక పూర్తిస్థాయి క్లౌడ్ ఇన్ఫ్రాస్ట్రక్చర్ ప్రైసింగ్ ఇంజిన్: సర్వర్ ఆర్కిటెక్చర్, vCPUలు, RAM మరియు బ్యాండ్విడ్త్ ఆధారంగా మంత్లీ బిల్లును లెక్కించడానికి yield కీవర్డ్ మరియు బహుళ లేబుల్స్ ఉపయోగించే కాప్స్టోన్ ప్రాజెక్ట్:
public class CloudBillingTierEngine {
public static void main(String[] args) {
String instanceTier = "ENTERPRISE_PRO";
int activeHours = 720; // Full 30 days month
double discountRate = 0.10; // 10% Long-term commitment
System.out.println("==================================================");
System.out.println(" HYPER-SCALE CLOUD INFRASTRUCTURE BILLING ");
System.out.println("==================================================");
// Modern Switch Expression evaluating hourly rate using yield
double hourlyRateUSD = switch (instanceTier.toUpperCase()) {
case "NANO", "MICRO" -> 0.015;
case "SMALL", "MEDIUM" -> 0.045;
case "LARGE", "XLARGE" -> 0.180;
case "ENTERPRISE_PRO" -> {
double baseCompute = 0.450; // 16 vCPU, 64GB RAM
double dedicatedNetworkSla = 0.080; // 10 Gbps SLA
yield baseCompute + dedicatedNetworkSla;
}
default -> {
System.out.println("[WARN] Unrecognized tier. Defaulting to standard Micro.");
yield 0.015;
}
};
double grossCostUSD = activeHours * hourlyRateUSD;
double discountUSD = grossCostUSD * discountRate;
double netCostUSD = grossCostUSD - discountUSD;
double netCostINR = netCostUSD * 83.25;
System.out.printf(" Selected Tier : %s%n", instanceTier);
System.out.printf(" Billing Rate : $%.3f USD per hour%n", hourlyRateUSD);
System.out.printf(" Uptime Hours : %d hours%n", activeHours);
System.out.println("--------------------------------------------------");
System.out.printf(" Gross Compute : $%,10.2f USD%n", grossCostUSD);
System.out.printf(" Commitment Disc: -$%,9.2f USD (10%%)%n", discountUSD);
System.out.println("--------------------------------------------------");
System.out.printf(" TOTAL INVOICE : $%,10.2f USD%n", netCostUSD);
System.out.printf(" TOTAL IN INR : ₹ %,10.2f INR%n", netCostINR);
System.out.println("==================================================");
}
}
=================================================="
HYPER-SCALE CLOUD INFRASTRUCTURE BILLING
==================================================
Selected Tier : ENTERPRISE_PRO
Billing Rate : $0.530 USD per hour
Uptime Hours : 720 hours
--------------------------------------------------
Gross Compute : $ 381.60 USD
Commitment Disc: -$ 38.16 USD (10%)
--------------------------------------------------
TOTAL INVOICE : $ 343.44 USD
TOTAL IN INR : ₹ 28,591.38 INR
==================================================
12 టాప్ 6 కామన్ స్విచ్ మిస్టేక్స్ & 5 క్విజ్లు
స్విచ్ స్టేట్మెంట్స్ మరియు ఎక్స్ప్రెషన్స్లో డెవలపర్లు తరచుగా చేసే 6 ప్రధాన తప్పులు:
| లోపం | తప్పు కోడ్ | సరిదిద్దిన సరైన విధానం |
|---|---|---|
| క్లాసిక్ స్విచ్లో break మర్చిపోవడం | case 1: doA(); case 2: doB(); (ఫాల్-త్రూ జరుగుతుంది) |
ప్రతి కేస్ చివర break; లేదా మోడరన్ యారో సింటాక్స్ -> వాడాలి. |
| ఫ్లోట్ లేదా డబుల్ వేరియబుల్స్ స్విచ్లో వాడటం | double d = 2.5; switch(d) (కంపైల్ ఎర్రర్) |
ఫ్లోటింగ్ పాయింట్లకు if-else వాడాలి. |
| స్విచ్ ఎక్స్ప్రెషన్లో default లేకపోవడం | int res = switch(x) { case 1 -> 10; }; |
అన్ని సంభావ్య విలువల కోసం తప్పనిసరిగా default -> ... ఉండాలి. |
| స్విచ్ ఎక్స్ప్రెషన్ చివర సెమీకోలన్ మర్చిపోవడం | int x = switch(...) { ... } |
ఎక్స్ప్రెషన్ అసైన్మెంట్ కాబట్టి చివర }; ఉండాలి. |
| yield బదులు return వాడటం | case 1 -> { return 10; } (మొత్తం మెథడ్ రిటర్న్ అయిపోతుంది!) |
కేవలం స్విచ్ నుండి రిటర్న్ కావడానికి yield 10; వాడాలి. |
| కేస్ లేబుల్స్లో వేరియబుల్స్ వాడటం | int y = 5; case y: |
కేస్ లేబుల్స్ ఖచ్చితంగా Compile-time Constants అయి ఉండాలి (ఉదా: final int y = 5;). |
🧠 మీ అవగాహనను పరీక్షించుకోండి (5 Interactive Quizzes):
ప్రశ్న 1: జావాలో స్విచ్ స్టేట్మెంట్కు 'double' వేరియబుల్ను పాస్ చేయవచ్చా?
సమాధానం: పాస్ చేయకూడదు! ఫ్లోటింగ్ పాయింట్ సంఖ్యలకు కచ్చితమైన సమానత్వం ఉండదు కాబట్టి జావా కంపైల్-టైమ్ ఎర్రర్ ఇస్తుంది.
ప్రశ్న 2: Modern Switch Expressions లో '->' (Arrow) సింటాక్స్ యొక్క ముఖ్య ప్రయోజనం ఏమిటి?
సమాధానం: ఆటోమేటిక్ బ్రేక్! యారో సింటాక్స్ వాడినప్పుడు ఫాల్-త్రూ (Fall-through) జరగదు, కాబట్టి ప్రత్యేకంగా break రాయాల్సిన అవసరమే లేదు.
ప్రశ్న 3: స్విచ్ ఎక్స్ప్రెషన్ బ్లాక్ నుండి విలువను రిటర్న్ చేయడానికి ఏ కీవర్డ్ వాడతారు?
సమాధానం: yield కీవర్డ్. (ఇది జావా 14 లో పరిచయం చేయబడింది).
ప్రశ్న 4: ఒకే కేస్లో బహుళ విలువలను ఎలా పేర్కొనవచ్చు?
సమాధానం: కామాతో వేరుచేయవచ్చు: case 1, 2, 3 -> ... (Modern Java 14+ ఫీచర్).
ప్రశ్న 5: జావాలో String లను స్విచ్లో వాడటం ఎప్పటి నుండి సాధ్యమైంది?
సమాధానం: జావా 7 (Java SE 7) నుండి స్ట్రింగ్స్ను స్విచ్లో వాడే సౌకర్యం అందుబాటులోకి వచ్చింది. అంతర్గతంగా ఇది స్ట్రింగ్ యొక్క hashCode() మరియు equals() లతో పనిచేస్తుంది.