Alternative à l'Interrupteur de Cas en Java

Si vous avez beaucoup de switch/case états autour de votre code et ils sont vous rend fou.

Vous pouvez opter pour le Refactoring: Remplacer le conditionnel avec le polymorphisme.

Disons que vous avez un morceau de logiciel qui est utilisé pour enregistrer les informations de différents dispositifs: 4 opérations de persistance sont définis: extraire, enregistrer, supprimer, mettre à jour, qui pourrait être mis en œuvre par le nombre N de mécanisme de persistance ( fichiers plats, réseau, SGBD, XML, etc ) .

Votre code à l'appui de tous dans 4 endroits différents, vous avez la ce:

AVANT

class YourProblematicClass { 

....

     public void fetchData( Object criteria ) {

          switch ( this.persitanceType ) {
              case FilePersistance:
                  //open file
                  //read it
                  //find the criteria
                  //build the data
                  //close it.
                  break;
               case NetWorkPersistance: 
                   //Connect to the server
                   //Authenticate
                   //retrieve the data 
                   //build the data 
                   //close connection
                   break(); 
                case DataBasePersistace:
                   //Get a jdbc connection
                   //create the query
                   //execute the query
                   //fetch and build data
                   //close connection
                   break;
           }
           return data;
         }    

Même pour enregistrer/supprimer/mettre à jour

 public void saveData( Object data) {

      switch ( this.persitanceType ) {
          case FilePersistance:
              //open file, go to EOF, write etc.
              break;
           case NetWorkPersistance: 
               //Connect to the server
               //Authenticate
               //etc
               break(); 
            case DataBasePersistace:
               //Get a jdbc connection, query, execute...
               break;
       }
     }

Et ainsi de suite....

 public void deleteData( Object data) {

      switch ( this.persitanceType ) {
          case FilePersistance:
              break;
           case NetWorkPersistance: 
               break(); 
            case DataBasePersistace:
               break;
       }
  }

 public  void updateData( Object data) {

      switch ( this.persitanceType ) {
          case FilePersistance:
              break;
           case NetWorkPersistance: 
               break(); 
            case DataBasePersistace:
               break;
       }
  }

Utilisez le commutateur/instruction de cas devient problématique:

• Chaque fois que vous voulez ajouter un nouveau type, vous devez insérer le nouveau switch/case dans chaque section.

• À de nombreuses reprises, certains types sont similaires, et ils n'ont pas besoin d'un autre switch/case ( vous pourriez cascade )

• Quelques autres qu'ils sont, et quelques fois ils diffèrent légèrement
• Vous pouvez même avoir besoin de charger différents type à l'exécution ( comme des plugins )

De sorte que le refactoring ici serait d'ajouter une interface ou un type abstrait et les différents types d'implémenter cette interface, et en déléguer la responsabilité à cet objet.

De sorte que vous auriez quelque chose comme ceci:

APRÈS

   public interface PersistenceManager {
        public void fetchData( Object criteria );
        public void saveData( Object toSave );
        public void deleteData( Object toDelete );
        public void updateData( Object toUpdate );
   }  

Et les différentes implémentations

  public class FilePersistence implements PersistanceManager {
        public void fetchData( Object criteria ) {
                  //open file
                  //read it
                  //find the criteria
                  //build the data
                  //close it.
         }
        public void saveData( Object toSave ) {
                 //open file, go to EOF etc. 
        }
        public void deleteData( Object toDelete ){
           ....
        }
        public void updateData( Object toUpdate ){
          ....
        }
  }

Et les autres types permettrait de mettre en œuvre en fonction de leur logique. Réseau de traiter avec les sockets et les ruisseaux, les DB de traiter avec JDBC, jeux de résultats etc. XML avec nœud etc.etc.

  public class NetworkPersistence implements PersistanceManager {
        public void fetchData( Object criteria ) {
             //Socket stuff
         }
        public void saveData( Object toSave ) {
             //Socket stuff
        }
        public void deleteData( Object toDelete ){
           //Socket stuff
        }
        public void updateData( Object toUpdate ){
           //Socket stuff
        }
  }


  public class DataBasePersistence implements PersistanceManager {
        public void fetchData( Object criteria ) {
             //JDBC stuff
         }
        public void saveData( Object toSave ) {
             //JDBC  stuff
        }
        public void deleteData( Object toDelete ){
           //JDBC  stuff
        }
        public void updateData( Object toUpdate ){
           //JDBC  stuff
        }
  }

Et, enfin, vous avez juste à déléguer les invocations.

Plus tard:

public YouProblematicClass { //not longer that problematic

    PersistamceManager persistance = //initialize with the right one.


        public void fetchData( Object criteria ) {
             //remove the switch and replace it with:
             this.persistance.fetchData( criteria );
         }
        public void saveData( Object toSave ) {
             //switch removed
             this.persistance.saveData(  toSave );
        }
        public void deleteData( Object toDelete ){
           this.persistance.deleteData( toDelete );
        }
        public void updateData( Object toUpdate ){
           this.persistance.updateData( toUpdate );
        }
  }

Donc, vous avez juste à créer l'instance appropriée pour le gestionnaire de persistance en fonction du type qu'une seule fois. Ensuite, tous les appels sont résolus par le polymorphisme. C'est l'une des principales caractéristiques de la Technologie Orientée Objet.

Si vous décidez que vous avez besoin d'un autre gestionnaire de persistance, il vous suffit de créer la nouvelle de la mise en œuvre et affectés à la classe.

 public WavePersistance implements PersistanceManager {

        public void fetchData( Object criteria ) {
             //....
         }
        public void saveData( Object toSave ) {
             // ....
        }
        public void deleteData( Object toDelete ){
           // ....
        }
        public void updateData( Object toUpdate ){
           // ....
        }
   }

OriginalL'auteur OscarRyz

une vilaine série de if,else if,else ?

OriginalL'auteur Pierre

Je suppose que "Code Propre" a un beau chapitre selon switch/case vs si/d'autre.

D'ailleurs: je pense qu'il est judicieux de décider si vous pouvez réduire le "bruit" et rendre le code plus propre en utilisant l'interrupteur cas, le polymorphisme ou même un bon ol' si/d'autre. Le nombre de cas joue un rôle majeur ici, je suppose.

OriginalL'auteur gia

Hashmap est considéré comme n'ayant pas de mémoire conviviale, de sorte que vous pouvez utiliser Enum pour ce but.

Exemple:

class EnumExample4{
enum Season{ 
WINTER(5), SPRING(10), SUMMER(15), FALL(20); 

private int value;
private Season(int value){
this.value=value;
}
}
public static void main(String args[]){

System.out.println(Season.WINTER.value); //This gives you 5
}}

Ce sera l'organe de vous, de l'écriture Commutateur Cas ou si des instructions.

OriginalL'auteur ksinghit

Que voulez-vous faire? Pourquoi n'est pas le Cas de Commutateur assez bon?

La rapide réponse est: utiliser des if-else

OriginalL'auteur Carlos Tasada

Un if (avec else if et else) déclaration? Alors que switch vous permettra seulement de commutateur à l'aide de l'égalité contre les entiers ou les types Enum, if vous permet d'utiliser toute la logique booléenne.

OriginalL'auteur Adam Batkin

Si les chaînes sont statiques, Vous pouvez faire un ENUM.
et faire un switch sur elle.

OriginalL'auteur Eyal