用设计模式来代替臃肿的ifelse层层判断

--------------------------------<代码优化之避免使用过多ifelse>---------------------------------


在www.infoq.com/cn网站上看了一本书叫《ThoughtWorks文集》，里边有一章讲的是“对象健身操”，其中提到了“拒绝使用else关键字”。那么如何“拒绝使用else关键字”呢？
      
       1、如果程序中只有一个else,如下：
            if(con){
                  dosomething();
            }else{
                  dootherthings();
            }
        可以如下拒绝else：
            if(con){
                  dosomething();
                  return;
            }
            dootherthings();
         或者使用三元运算符：con ? dosometing() : dootherthings();
 
        2、如果程序中有多个else,如下：
            if(con1){
                  dothing1();
            }else if(con2){
                  dothing2();
            }else if(con3){
                  dothing3();
            }......
        可是使用策略模式或多态机制来拒绝else（还有很多其他方式），下面先介绍“策略模式”的方式：
        首先讲一个使用if...else...的例子：
        package ifelse.use;
        public class UseIfElse {
            public static void main(String args[]){
                MyPaper myPaper = new MyPaper(PaperColor.RED);
                if(myPaper.getMyPaperColor() == PaperColor.BLACK){
                    System.out.println("You need a black pen!");
                }else if(myPaper.getMyPaperColor() == PaperColor.BLUE){
                    System.out.println("You need a blue pen!");
                }else if(myPaper.getMyPaperColor() == PaperColor.RED){
                    System.out.println("You need a red pen!");
                }else if(myPaper.getMyPaperColor() == PaperColor.WHITE){
                    System.out.println("You need a white pen!");
                }
           }
       }
       class MyPaper{
           private PaperColor paperColor;
           public MyPaper(PaperColor paperColor){
               this.paperColor = paperColor;
           }
           public PaperColor getMyPaperColor(){
               return this.paperColor;
           }
       }
       enum PaperColor{
           WHITE, BLACK, BLUE, RED
       }
 
       使用if...else...的弊端在于：不利于对程序的扩展，如果新添加了一个颜色类型，那么就得去修改程序再添加一个if...else...分支，根据“开-闭原则”的宗旨：对扩展开，对修改闭。显然是用if...else...已经go out了。
       下面讲一个使用“策略模式”解决上述问题的办法：
       package ifelse.no;
       public class NoIfElse {
           public static void main(String args[]){
               MyPaper myPaper = new MyPaper(new White());
               myPaper.choicePen();
          }
       }
       interface PaperColor{
           public void getPenColor();
       }
       class White implements PaperColor{
           public void getPenColor(){
               System.out.println("You need a white pen!");
           }
       }
       class Red implements PaperColor{
           public void getPenColor(){
               System.out.println("You need a red pen!");
           }
       }
       class Blue implements PaperColor{
           public void getPenColor(){
               System.out.println("You need a blue pen!");
           }
       }
       class Black implements PaperColor{
           public void getPenColor(){
               System.out.println("You need a black pen!");
           }
       }
       class MyPaper{
           private PaperColor paperColor;
           public MyPaper(PaperColor paperColor){
               this.paperColor = paperColor;
           }
           public PaperColor getPaperColor(){
               return this.paperColor;
           }
           public void choicePen(){
               this.paperColor.getPenColor();
           }
      }
 
总结：
     if...else...的每个分支语句都做一件事，因此我们可以把这么些事单独封装在一个类中，就有了White、Blue、Red、Black4个类，这四个类都实现了接口PaperColor，我们再定义一个MyPaper的类（此类具有类似负载均衡的作用，分按照不同的请求分别调用跟前面4个类中的一个）。这样就把if...else...屏蔽掉了。
 
    接下来介绍使用“多态”机制来实现拒绝else：
    package ifelse.no.Polymorphism;
    public class NoIfElse_Polymorphism {
        public static void main(String args[]){
            MyPaper myPaper = new MyPaper();
            myPaper.choice(new Black());
        }
    }
    class White {
        public void getPenColor(){
            System.out.println("You need a white pen!");
        }
    }
    class Red {
        public void getPenColor(){
            System.out.println("You need a red pen!");
        }
    }
    class Blue {
        public void getPenColor(){
            System.out.println("You need a blue pen!");
        }
    }
    class Black {
        public void getPenColor(){
            System.out.println("You need a black pen!");
        }
    }
    class MyPaper{
        public void choice(White white){
            white.getPenColor();
        }
        public void choice(Red red){
            red.getPenColor();
        }
        public void choice(Blue blue){
            blue.getPenColor();
        }
        public void choice(Black black){
            black.getPenColor();
        }
    }
总结：
      此处使用的多态机制指：方法的重构，根据方法名相同儿参数不同的机制，来实现拒绝关键字。
 
注意：上述两种方式适用于同时只有一个分支被执行的情况。
参考：“java设计模式”之“策略模式”。


=================================<代码优化之避免使用过多ifelse>======================================