Java8和enum枚举简单使用 优化代码

1.减少大量的 if/else，switch/case

使用枚举，可以减少我们的判断，枚举也能简单封装成策略模式

public enum Season {

    SPRING(1){
        @Override
        public void run() {

            Log.i("Season","SPRING");
        }
    },SUMMER(2){
        @Override
        public void run() {
            Log.i("Season","SUMMER");
        }
    },AUTUMN(3){
        @Override
        public void run() {
            Log.i("Season","AUTUMN");
        }
    },WINTER(4){
        @Override
        public void run() {
            Log.i("Season","WINTER");
        }
    };

    public abstract void run();

    int i;

    Season(int index) {
        this.i = index;
    }
}

使用：

  Season.SPRING.run();
  Season.valueOf("SPRING").run();

2. java 8 的 Optional<T> 操作

Optional 减少 代码中 Object 判 空，

if（null！=obj）{

}else{

}

public class Season {

    public Season() {
    }

    public int run(){
        Log.i("Season","---run----");
        return 0;
    }
}

        Season season = new Season();
        //ofNullable 可以传空
        Optional<Season> optional1 = Optional.ofNullable(season);

        // season 的run()方法必须有返回值，根据返回值的不同在调用orElse时候类型就不同，
           可以做到类型转化。
        optional1.map(u->u.run()).orElse(Log.i("--Season---","----orElse---"));

        //orElse()方法不管之前的流程是否成功失败，orElse()这个方法最终都会走。
          orElseGet()这个方法只有关键时刻才会走，只有之前的map()
        //粗错了，才会走orElseGet()。
        optional1.map(u->u.run()).orElseGet(()->Log.i("-----","----orElse---"));

Optional 实现简单的责任链模式：

比如我们现在有个需求 要登录A服务器然后再登录B服务器...等等(可能更多)：

public class LoginA {

    public LoginA() {
    }

    public LoginB loginA(){
        Log.i("loginA","---run----");
        if (成功){
            return new LoginB();
        }
        return null;
    }
}

class LoginB {

    public LoginB() {
    }

    public int loginB(){
        Log.i("loginB","---run----");
        return 0;
    }
}

使用：

     LoginA loginA = new LoginA();
     Optional<LoginA> loginAOp = Optional.ofNullable(loginA);

     loginAOp.map(l->l.loginA()).map(lb->lb.loginB())
                .orElseGet(()->Log.i("登录失败",""));
     //上述可分解成
     //map()里面调用了loginA() 返回值是 LoginB，所以我们就能得
     //到Optional<LoginB>loginBOp。
     Optional<LoginB> loginBOp = loginAOp.map(l->l.loginA());
     Optional<Integer> loginInt = loginBOp.map(lb->lb.loginB());
     loginInt.orElseGet(()->Log.i("登录失败",""));

总结：

1.  java8中的 -> lanmda表达式 和c++中的指针操作很相似
2.  OPtional 在java中可以减少 类判空，并且里面的方法可以做到代码更有序
3. 双冒号：：调用静态方法，和c++中的 作用域 的方式很像