java - Java 中 Switch Case 的替代方案

Question

除了看起来不太好的 if else 之外，是否有任何其他方法可以在 Java 中实现 switch case。一组值组合在一起，根据选择执行相应的方法。

Answer 1

如果您的代码周围有大量 switch/case 语句，它们会让您发疯。

您可以选择重构: Replace conditional with polymorphism.

假设您有一个用于将信息保存到不同设备的软件:定义了 4 个持久性操作:获取、保存、删除、更新，其中可以通过 N 种持久化机制(平面文件、网络、RDBMS、XML 等)来实现。

你的代码必须支持它们，所以在 4 个不同的地方你有这个:

之前

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

保存/删除/更新相同

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

等等....

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

使用 switch/case 语句会出现问题:

• 每次您想要添加新类型时，您都必须在每个部分中插入新的 switch/case。

• 很多时候，有些类型是相似的，它们不需要不同的 switch/case(你可以级联它们)

• 有些不同，有时略有不同

• 您甚至可能需要在运行时加载不同类型(如插件)

因此这里的重构将是添加一个接口(interface)或抽象类型，并让不同的类型实现该接口(interface)并将责任委托(delegate)给该对象。

所以你会得到这样的东西:

之后

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

和不同的实现

  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 ){
          ....
        }
  }

而其他类型将根据它们的逻辑实现。网络将处理套接字和流，数据库将处理 JDBC、结果集等。XML 与节点等。

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

最后，您只需委托(delegate)调用即可。

后来:

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

因此，您只需根据类型为持久性管理器创建正确的实例一次。然后所有的调用都通过多态来解决。这是面向对象技术的关键特征之一。

如果您决定需要另一个持久性管理器，您只需创建新的实现并将其分配给该类即可。

 public WavePersistance implements PersistanceManager {

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