जावा में नेस्टेड स्विच स्टेटमेंट्स के लिए वैकल्पिक

Question

इसलिए मैंने आज एक विधि लिखी है जिसमें नेस्टेड स्विच स्टेटमेंट्स का उपयोग शामिल है, और कोड मेरे लिए काफी साफ और संक्षिप्त दिखता है, लेकिन मुझे बताया गया कि नेस्टेड स्विच स्टेटमेंट आमतौर पर सबसे अच्छा तरीका नहीं है जाने के लिए क्योंकि वे आपके द्वारा जोड़े गए अधिक स्विच स्टेटमेंट्स के साथ भ्रमित हो सकते हैं।

EnumOne enumOne; 
EnumTwo enumTwo = null; 
EnumTwo enumThree = null; 

switch (enumOne) { 
    case CASE_ONE: 

     switch (enumTwo){ 
     case A: enumTwo = EnumTwo.B; break; 
     case C: enumTwo = EnumTwo.D; break; 
     default: break; 
     } 

     switch (enumThree) { 
     case AA: enumThree = EnumTwo.BB; break; 
     case CC: enumThree = EnumTwo.DD; break; 
     default: break; 
     } 

     break; 

    case CASE_TWO: 
    case CASE_THREE: 

     switch(EnumTwo) { 
     default: break; 
     } 

     switch (enumThree) { 
     case AA: enumThree = EnumTwo.XX; break; 
     case CC: enumThree = EnumTwo.YY; break; 
     default: break; 
     } 

     break; 

    default: 
     break; 
} 

तो मेरे सवाल हो, अनिवार्य रूप से, क्या इन बयानों स्विच करने के लिए एक उपयुक्त विकल्प होगा होगा: यहाँ क्या मेरी कोड की तरह दिखाई देता का एक नमूना है?

Answer 1

मैं आपको प्रत्येक नेस्टेड स्विच स्टेटमेंट को उस प्रक्रिया में कॉल के साथ प्रतिस्थापित करने की सलाह देता हूं जो तब नेस्टेड स्विच कोड निष्पादित करता है।

इस बजाय की तरह कुछ लिखें:

EnumOne enumOne; 
    EnumTwo enumTwo = null; 
    EnumTwo enumThree = null; 

    switch (enumOne) 
    { 
     case CASE_ONE: 

      nested_switch1(); 

     case CASE_TWO: 
     case CASE_THREE: 

      nested_switch2(); 

      break; 

     default: 
      break; 
    } 

    nested_switch1() { 
      switch (enumTwo) 
      { 
      case A: 
       enumTwo = EnumTwo.B; 
       break; 
      case C: 
       enumTwo = EnumTwo.D; 
       break; 
      default: 
       break; 
      } 

      switch (enumThree) 
      { 
      case AA: 
       enumTwo = EnumTwo.BB; 
       break; 
      case CC: 
       enumTwo = EnumTwo.DD; 
       break; 
      default: 
       break; 
      } 

      break; 
    } 

nested_switch2() { 
      switch(EnumTwo) 
      { 
      default: 
       break; 
      } 

      switch (enumThree) 
      { 
      case AA: 
       enumTwo = EnumTwo.XX; 
       break; 
      case CC: 
       enumTwo = EnumTwo.YY; 
       break; 
      default: 
       break; 
      } 
} 

Answer 2

1. स्विच का एक बहुत का उपयोग कर के रूप में बहुत पढ़ने के लिए मुश्किल हो जाता है।
2. और किसी भी समय एक नया मामला तब पैदा होती है हम हम इस तरह के मामलों

   में polymorphism का उपयोग कर मैं बस आपको यह बताने के लिए एक सरल वर्ग देने जा रहा हूँ पर विचार कर सकते

कोड को संशोधित करने और एक मामले में जोड़ने के लिए समझना। स्विच मामले से पहले एक वर्ग मान लीजिए

class Test 
{ 
    Animal a; 
    public Test(Animal a) 
    { 
     this.a=a; 
    } 

    public moveThisAnimal() 
    { 
     switch(this.a) 
     { 
      case fish: 
      System.out.println("swim"); 
      break; 

      case dog: 
      System.out.println("walk"); 
      break; 

      case bird: 
      System.out.println("fly"); 
      break; 
     } 
    } 
} 

अब हम की जगह ये हमारे बहुरूपता तर्क के साथ स्विच

Interface Animal 
{ 
    String move(); 
} 

Class Dog implements Animal 
{ 
    public String move() 
    { 
     return "walk"; 
    } 
} 


Class Bird implements Animal 
{ 
    public String move() 
    { 
     return "fly"; 
    } 
} 


Class Fish implements Animal 
{ 
    public String move() 
    { 
     return "swim"; 
    } 
} 

अब हम स्विच मामले के बिना टेस्ट वर्ग है

class Test 
{ 
    Animal a; 
    public Test(Animal a) 
    { 
     this.a=a; 
    } 
    public moveThisAnimal() 
    { 
     System.out.println(this.a.move()); // all switch case statements removed 
    } 
} 

और यहां तक ​​कि हम अगर आगे के मामलों को जोड़ना है, हमें केवल कार्यान्वयन को जोड़ना है, कोई बदलाव नहीं

अपना पूरा कोड देखें और देखें कि

Answer 3

यदि आपके पास एक्स और वाई पूर्णांक हैं और आपको दोनों को स्विच करने की आवश्यकता है, तो आप उन्हें कुछ स्पष्ट तरीके से संयोजित कर सकते हैं और संयोजन पर स्विच कर सकते हैं। उदाहरण के लिए, यदि y < 10:

switch (x*10+y) 
{ 
case 0: // x == y == 0 
case 1: // x ==0, y == 1 
/// 
case 10: // x == 1, y == 0 
case 11: // x == y == 1 
// 
}