స్విచ్, కేస్, డిఫాల్ట్

"హాయ్, అమిగో!"

"హాయ్, బిలాబో! మిమ్మల్ని మళ్ళీ చూడటం చాలా బాగుంది. మీ ఉపన్యాసాలు మాత్రమే చాలా బాగున్నాయి మరియు అర్థమయ్యేలా ఉన్నాయి. ఈ జావా మెమరీ మోడల్ లా కాదు."

"అవును, బిలాబోకి పాఠాలు ఎలా ఎంచుకోవాలో తెలుసు. ఈ రోజు నేను మీకు స్విచ్ స్టేట్‌మెంట్ గురించి చెప్పబోతున్నాను."

"దీని గురించి ఎవరో ఇప్పటికే నాకు చెప్పారని నేను అనుకుంటున్నాను."

"ఎల్లీ చేసింది. కాబట్టి, అమిగో స్విచ్ స్టేట్‌మెంట్ గురించి పాఠం వినకూడదనుకుంటున్నారా? బహుశా మీరు మీ స్వంతంగా బోధించడం ప్రారంభిస్తారా?"

"లేదు, నాకు కావాలి, నాకు కావాలి. స్విచ్ స్టేట్‌మెంట్ గురించి విందాం."

"సరే. జావాలో, స్విచ్ స్టేట్‌మెంట్ అని పిలుస్తారు. మీరు కొన్ని వేరియబుల్ యొక్క వివిధ విలువలను బట్టి నిర్దిష్ట చర్యలను చేయవలసి వచ్చినప్పుడు ఇది సౌకర్యవంతంగా ఉంటుంది."

int i = 5;
switch(i)
{
 case 1:
  System.out.println("one");
  break;
 case 2:
  System.out.println("two");
  break;
 case 3:
  System.out.println("three");
  break;
 default:
  System.out.println("many");
}

int i = 5;
if (i == 1)
{
 System.out.println("one");
}
else if (i == 2)
{
 System.out.println("two");
}
else if (i == 3)
{
 System.out.println("three");
}
else
{
 System.out.println("many");
}

స్విచ్ స్టేట్‌మెంట్, దానికి పంపబడిన వేరియబుల్ కీవర్డ్ కేస్‌ను అనుసరించే విలువతో సరిపోలితే , కావలసిన కోడ్ ముక్కకు వెళ్లడానికి మిమ్మల్ని అనుమతిస్తుంది.

నేను 1 అయితే, ఎగ్జిక్యూషన్ "కేస్ 1" అని గుర్తించబడిన పంక్తికి చేరుకుంటుంది.

నేను 2 అయితే, ఎగ్జిక్యూషన్ "కేస్ 2" అని గుర్తించబడిన పంక్తికి వెళుతుంది.

నేను 3 అయితే, ఎగ్జిక్యూషన్ "కేస్ 3" అని గుర్తించబడిన పంక్తికి వెళుతుంది.

"ఏదైనా కేసులకు జంప్ చేయకపోతే, అప్పుడు «డిఫాల్ట్» బ్లాక్ అమలు చేయబడుతుంది."

"నేను చూస్తున్నాను. మరియు కుడి వైపున అదే లాజిక్ ఉంది, అయితే if స్టేట్‌మెంట్‌లను ఉపయోగించి అమలు చేయబడిందా?"

"అవును."

"మరియు 'బ్రేక్' అనే పదంతో ఏముంది? ఇది లూప్‌లలో మాత్రమే ఉపయోగించబడుతుందని మీరు చెప్పారు?"

"అవును మరియు ఇక్కడ. బ్రేక్ స్టేట్‌మెంట్ అమలు చేయబడినప్పుడు, మేము వెంటనే స్విచ్ నుండి నిష్క్రమిస్తాము ."

"కానీ బ్రేక్ స్టేట్‌మెంట్ తీసివేయబడితే, స్విచ్‌లోని అన్ని లైన్‌లు చివరి వరకు అమలు చేయబడతాయి."

switch(i)
{
 case 1:
  System.out.println("one");
 case 2:
  System.out.println("two");
 case 3:
  System.out.println("three");
 default:
  System.out.println("many"); }

"వాస్తవానికి, కేస్ అనేది కోడ్‌లోని లేబుల్. స్విచ్ స్టేట్‌మెంట్‌లో, మేము తదుపరి లేబుల్‌కి వెళ్లి, స్విచ్ ముగిసే వరకు లేదా బ్రేక్ స్టేట్‌మెంట్‌ను పొందే వరకు అన్ని కోడ్‌లను అమలు చేయడం ప్రారంభిస్తాము."

"కాబట్టి, మనం విరామం వ్రాయకపోతే, మనం జంప్ చేసిన లైన్ అమలు చేయబడుతుంది, ఆపై మూసివేసే బ్రేస్ వరకు అన్ని ఇతర పంక్తులు అమలు చేయబడతాయి. అది సరైనదేనా?"

"అవును."

"పీస్ ఆఫ్ కేక్. అయితే నాకు if స్టేట్‌మెంట్‌లు మెరుగ్గా ఉపయోగించడం ఇష్టం. వారికి ఈ అర్ధంలేని బ్రేక్ స్టేట్‌మెంట్‌లు లేవు."

"స్టేట్‌మెంట్‌లు చాలా తరచుగా కాంపాక్ట్‌గా ఉన్నాయన్నది నిజం. కానీ స్విచ్ స్టేట్‌మెంట్ కొన్నిసార్లు మరింత చదవగలిగేలా ఉంటుంది."

"సరిపోల్చండి:"

public String getName(int i)
{
 switch(i)
 {
  case 1:
   return "one";
  case 2:
   return "two";
  case 3:
   return "three";
  default:
   return "many";
}

public String getName(int i)
{
 if (i == 1)
  return "one";

 if (i == 2)
  return "two";

 if (i == 3)
  return "three";

return "many"
}

"ఇది మరింత చదవదగినదని నేను చెప్పను."

"సరే, కానీ ఈ ఉదాహరణ గురించి ఏమిటి?"

public String getName(int i)
{
 switch(i)
 {
  case 1:
  case 2:
   return "one or two";
  case 3:
  case 4:
  case 5:
   return "three to five";
  default:
   return "many";
}

public String getName(int i)
{
 if (i == 1 || i == 2)
  return "one or two";

 if (i == 3 || i == 4 || i == 5)
  return "three to five";

return "many"
}

"బిలాబో, మీ ఉదాహరణ సరిగ్గా కనిపించడం లేదు. కాబట్టి, నేను రిటర్న్ ఉపయోగిస్తే బ్రేక్ స్టేట్‌మెంట్‌ను వదిలివేయవచ్చా?"

"అది నిజమే. రిటర్న్ స్టేట్‌మెంట్ వెంటనే పద్ధతి నుండి నిష్క్రమిస్తుంది."

"స్టేట్‌మెంట్‌లు ఎల్లప్పుడూ మరింత కాంపాక్ట్‌గా ఉంటే అనిపిస్తోంది. కానీ స్విచ్ స్టేట్‌మెంట్ ఈసారి మరింత చదవగలిగేదిగా మారింది."

"ఫూ, చివరగా."

"ఇంకో విషయం. మీరు చివరిలో డిఫాల్ట్‌గా వ్రాయవలసిన అవసరం లేదు. అలా చేయకపోతే, లేబుల్‌లు ఏవీ సరిపోలకపోతే ఏమీ జరగదు."

"ఉహ్, సరిగ్గా. ఐతే-ఇలా అయితే, చదవగలిగేది-చాలా ఎక్కువ చదవగలిగేది!"

"గ్రేట్. నా పాఠం మీకు నచ్చినందుకు నేను సంతోషిస్తున్నాను."

"ఓహ్, నేను దాదాపు మర్చిపోయాను. ప్రారంభంలో, మీరు స్విచ్ స్టేట్‌మెంట్‌లలో ఆదిమ రకాలు మరియు ఎనమ్‌లను మాత్రమే ఉపయోగించగలరు. కానీ ఇప్పుడు వారు స్ట్రింగ్‌లకు మద్దతుని జోడించారు."

"ఇది నేను వ్రాస్తానని మీ ఉద్దేశ్యం?"

public int getNumber(String number)
{
 switch(number)
 {
  case "one":
   return 1;
  case "two":
   return 2;
  case "three":
   return 3;
  default:
   return -1;
 }
}

"అవును. అనుకూలమైనది, సరియైనదా?"

"అవును. స్విచ్ స్టేట్మెంట్స్ చాలా బాగున్నాయి!"