从各处收集的switch语句

 重构之重复代码：

     1.(重复代码是)语义一致的逻辑
         反例：语义一致的逻辑产生了多个实体
         缺点：如果你为语义一致的逻辑产生了多个实体，那么当需要修改这个逻辑时，你必须保证同时修改所有的实体，并确保它们是一致的。否则，程序就会产生bug。无疑，这么做会额外增加很多的不必要的工作量。

         原则：语义一致的逻辑之应该只产生唯一实体，在需要的地方进行调用。

 反面案例：
     jdbc操作数据库时，在每个访问方法中写driverClass, url, username, password。

     2.（重复代码是）非语义一致的逻辑。
         当你的程序中存在多个实体，表示的是非语义一致的逻辑，当修改其中一个不需要维护另一个，因为它们本身就没有语义一致的要求。

 重构之switch语句：

 程序中出现switch语句，就是不好的设计吗？

 一个需要重构的switch语句的案例
     Movie类
     priceCode域
     getCharge(int daysRent):
     存在switch语句：
         根据priceCode域的值的不同计算租片费用。
         其中每个分支中的逻辑的共同点：
             输入是租期，输出是费用。

 方案：
     使用状态模式或策略模式对该switch语句进行重构。

 商城案例：根据会员不同的等级，给与不同的折扣，会员等级是变化点
     会员等级，折扣计算。
 影片案例：根据影片类型，计算积分和费用（租用时间），影片类型是变化点
     影片类型，计算积分，计算费用。

 静态的方法：
     charge getCharge(movieType, daysRent){
         switch(movieType)
             case x1: xx
             case x2: xx
             case x3: xx
     }

     points getPoints(movieType, daysRent){
         switch(movieType)
             case x1: xx
             case x2: xx
             case x3: xx
     }
     类型作为条件，影响方法的行为。

 满减
     amount getAmount(amount, customerType){
         amount > x1
             xxx
         amount > x2
             xxx
         amount > x3
             xxx

         switch(customerType)
             case x1: xx
             case x2: xx
             case x3: xx
     }
     金额作为条件，影响方法的行为。
     会员类型作为条件，影响方法的行为。

 满减+打折(大话设计模式中案例)

     amount getAmount(code, amount){
         switch(code)
             case 打折x1: xx
             case 打折x2: xx
             case 满减x1: xx
             case 满减x2: xx
     }

     amount getAmount(amount){
         switch(code)
             case 打折x1: cashRebate(折扣)
             case 打折x2: cashRebate(折扣)
             case 满减x1: cashReturn(满, 减)
             case 满减x2: cashReturn(满, 减)
     }
     cashRebate(折扣);
     cashReturn(满, 减);//考虑，满减可能有多对，这时可以用一个数组来表示。

     //可能的过度设计,使用策略模式
     CashSuper, CashRebate, CashReturn acceptCash()    

 Rental中保存daysRent信息，Movie中保存type信息

 程序中有个元素，该元素有限个值，程序中受该元素的值影响的行为。
 元素是影片类型，并且该影片类型作为条件影响程序的行为是计算费用和计算积分。

     例如，如下场景，switch case分支语句过多：

     /**
      * 获取地市编码对应的地市名称
      *
      * @param cityId 地市编码
      * @return String 地市名称
      */
     public static String getCityName(int cityId) {
         switch (cityId) {
             //苏州
             case GlobalDefine.DATUM_CITY_ID_SZ: {
                 return "sz";
             }
             //淮安
             case GlobalDefine.DATUM_CITY_ID_HA: {
                 return "hz";
             }
             //宿迁
             case GlobalDefine.DATUM_CITY_ID_SQ: {
                 return "sq";
             }
             //南京
             case GlobalDefine.DATUM_CITY_ID_NJ: {
                 return "nj";
             }
             //连云港
             case GlobalDefine.DATUM_CITY_ID_LYG: {
                 return "lyg";
             }
             //徐州
             case GlobalDefine.DATUM_CITY_ID_XZ: {
                 return "xz";
             }
             //常州
             case GlobalDefine.DATUM_CITY_ID_CZ: {
                 return "cz";
             }
             //镇江
             case GlobalDefine.DATUM_CITY_ID_ZJ: {
                 return "zj";
             }
             //无锡
             case GlobalDefine.DATUM_CITY_ID_WX: {
                 return "wx";
             }
             //南通
             case GlobalDefine.DATUM_CITY_ID_NT: {
                 return "nt";
             }
             //泰州
             case GlobalDefine.DATUM_CITY_ID_TZ: {
                 return "tz";
             }
             //盐城
             case GlobalDefine.DATUM_CITY_ID_YC: {
                 return "yc";
             }
             //扬州
             case GlobalDefine.DATUM_CITY_ID_YZ: {
                 return "yz";
             }
             //所有地市
             case GlobalDefine.DATUM_CITY_ALL: {
                 return "all";
             }
             default:
                 return "";
         }

      使用HashMap来解决switch case 分支语句过多的情况

     /**
      * 获取地市编码对应的地市名称
      *
      * @param cityId 地市编码
      * @return String 地市名称
      */
     public static String getCityName(int cityId) {

         Map<Short, String> cityMap = new HashMap<Short, String>();
         //苏州
         cityMap.put(GlobalDefine.DATUM_CITY_ID_SZ, "sz");

         //淮安
         cityMap.put(GlobalDefine.DATUM_CITY_ID_HA, "ha");

         //宿迁
         cityMap.put(GlobalDefine.DATUM_CITY_ID_SQ, "sq");

         //南京
         cityMap.put(GlobalDefine.DATUM_CITY_ID_NJ, "nj");

         //连云港
         cityMap.put(GlobalDefine.DATUM_CITY_ID_LYG, "lyg");

         //徐州
         cityMap.put(GlobalDefine.DATUM_CITY_ID_XZ, "xz");

         //常州
         cityMap.put(GlobalDefine.DATUM_CITY_ID_CZ, "cz");

         //镇江
         cityMap.put(GlobalDefine.DATUM_CITY_ID_ZJ, "zj");

         //无锡
         cityMap.put(GlobalDefine.DATUM_CITY_ID_WX, "wx");

         //南通
         cityMap.put(GlobalDefine.DATUM_CITY_ID_NT, "nt");

         //泰州
         cityMap.put(GlobalDefine.DATUM_CITY_ID_TZ, "tz");

         //盐城
         cityMap.put(GlobalDefine.DATUM_CITY_ID_YC, "yc");

         //扬州
         cityMap.put(GlobalDefine.DATUM_CITY_ID_YZ, "yz");

         //所有地市
         cityMap.put(GlobalDefine.DATUM_CITY_ALL, "all");

         if (cityMap.containsKey((short) cityId)) {
             return cityMap.get((short) cityId);
         } else {
             return "cityId is error and not find this cityName by cityId";
         }

     public static int getServiceCode(String str){
          int code = 0;
          if(str.equals("Age")){
              code = 1;
          }else if(str.equals("Address")){
              code = 2;
          }else  if(str.equals("Name")){
              code = 3;
          }else if(str.equals("No")){
              code = 4;
          }
          return  code;
      }

     public static void initialMap(){
          map.put("Age",1);
          map.put("Address",2);
          map.put("Name",3);
          map.put("No",4);
      }

收集的switch语句