Alternative aux instructions Switch imbriquées en Java

J'ai donc écrit une méthode aujourd'hui qui incorporait l'utilisation d'instructions switch imbriquées, et le code me semblait assez propre et concis, mais on m'a dit que les instructions switch imbriquées ne sont généralement pas la meilleure façon de procéder car elles peuvent devenir déroutantes avec les plus d'instructions switch que vous ajoutez. Voici un exemple de ce à quoi ressemblait mon code: 

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;
}

Ma question serait donc, essentiellement, quelle serait une alternative appropriée à ces instructions switch?

Author: Thilina Sampath, 2013-04-10
Source

3 answers

Je vous recommande de remplacer chaque instruction switch imbriquée par un appel à une procédure qui exécute ensuite le code switch imbriqué.

Écrivez quelque chose comme ceci à la place: 

    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;
          }
}
 13
Author: RouteMapper, 2013-04-10 16:18:44
  1. Comme l'utilisation de beaucoup de switch devient assez difficile à lire.
  2. Et chaque fois qu'un nouveau cas survient, nous devons modifier le code et ajouter un CAS

Nous pouvons envisager d'utiliser polymorphism dans de tels cas

Je vais donner un cours simple juste pour vous faire comprendre. Supposons une classe plus tôt avec interrupteur cas

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;
        }
    }
}

Maintenant, nous remplaçons ces commutateurs par notre logique de polymorphisme

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";
    }
}

Maintenant, nous avons une classe de test sans boîtier de commutation

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

Et même si nous devons ajouter d'autres cas nous devons simplement ajouter des implémentations pas de changement ici

Voir votre code complet et voir s'il est possible de Faire

 21
Author: Nirbhay Mishra, 2017-11-18 19:27:46

Si vous avez des entiers X et Y et que vous devez activer les deux, vous pouvez les combiner d'une manière non ambiguë et activer la combinaison. Par exemple, si y 

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
//
}
 4
Author: user207421, 2013-04-11 01:01:43