优化if-else代码的八种方案

也想出现在这里？点击联系我~

前言

代码中如果if-else比较多，阅读起来比较困难，维护起来也比较困难，很容易出bug，接下来，本文将介绍优化if-else代码的八种方案。

优化方案一：提前return，去除不必要的else

如果if-else代码块包含return语句，可以考虑通过提前return，把多余else干掉，使代码更加优雅。

优化前：

1. if(condition){
2. //doSomething
3. }else{
4. return;
5. }

优化后：

1. if（!condition）{
2. return;
3. }
4. //doSomething

优化方案二：使用条件三目运算符

使用条件三目运算符可以简化某些if-else,使代码更加简洁，更具有可读性。

优化前：

1. intprice;
2. if(condition){
3. price=80;
4. }else{
5. price=100;
6. }

优化后：

1. intprice=condition?80:100;

优化方案三：使用枚举

在某些时候，使用枚举也可以优化if-else逻辑分支，按个人理解，它也可以看作一种表驱动方法。

优化前：

1. StringOrderStatusDes;
2. if(orderStatus==0){
3. OrderStatusDes="订单未支付";
4. }elseif(OrderStatus==1){
5. OrderStatusDes="订单已支付";
6. }elseif(OrderStatus==2){
7. OrderStatusDes="已发货";
8. }
9. …

优化后：

先定义一个枚举

1. publicenumOrderStatusEnum{
2. UN_PAID(0,"订单未支付"),
3. PAIDED(1,"订单已支付"),
4. SENDED(2,"已发货"),
5. ;
6. privateintindex;
7. privateStringdesc;
8. publicintgetIndex(){
9. returnindex;
10. }
11. publicStringgetDesc(){
12. returndesc;
13. }
14. OrderStatusEnum(intindex,Stringdesc){
15. this.index=index;
16. this.desc=desc;
17. }
18. OrderStatusEnumof(intorderStatus){
19. for(OrderStatusEnumtemp:OrderStatusEnum.values()){
20. if(temp.getIndex()==orderStatus){
21. returntemp;
22. }
23. }
24. returnnull;
25. }
26. }

有了枚举之后，以上if-else逻辑分支，可以优化为一行代码

1. StringOrderStatusDes=OrderStatusEnum.0f(orderStatus).getDesc();

优化方案四：合并条件表达式

如果有一系列条件返回一样的结果，可以将它们合并为一个条件表达式，让逻辑更加清晰。

优化前

1. doublegetVipDiscount(){
2. if(age<18){
3. return0.8;
4. }
5. if("深圳".equals(city)){
6. return0.8;
7. }
8. if(isStudent){
9. return0.8;
10. }
11. //dosomethig
12. }

优化后

1. doublegetVipDiscount(){
2. if(age<18||"深圳".equals(city)||isStudent){
3. return0.8;
4. }
5. //doSomthing
6. }

优化方案五：使用 Optional

有时候if-else比较多，是因为非空判断导致的，这时候你可以使用java8的Optional进行优化。

优化前：

1. Stringstr="jay@huaxiao";
2. if(str!=null){
3. System.out.println(str);
4. }else{
5. System.out.println("Null");
6. }

优化后：

1. Optional<String>strOptional=Optional.of("jay@huaxiao");
2. strOptional.ifPresentOrElse(System.out::println,()->System.out.println("Null"));

优化方案六：表驱动法

表驱动法，又称之为表驱动、表驱动方法。表驱动方法是一种使你可以在表中查找信息，而不必用很多的逻辑语句（if或case）来把它们找出来的方法。以下的demo，把map抽象成表，在map中查找信息，而省去不必要的逻辑语句。

优化前：

1. if(param.equals(value1)){
2. doAction1(someParams);
3. }elseif(param.equals(value2)){
4. doAction2(someParams);
5. }elseif(param.equals(value3)){
6. doAction3(someParams);
7. }
8. //…

优化后：

1. Map<?,Function<?>action>actionMappings=newHashMap<>();
2. //这里泛型?是为方便演示，实际可替换为你需要的类型
3. //初始化
4. actionMappings.put(value1,(someParams)->{
5. doAction1(someParams)
6. });
7. actionMappings.put(value2,(someParams)->{
8. doAction2(someParams)
9. });
10. actionMappings.put(value3,(someParams)->{
11. doAction3(someParams)
12. });
13. //省略多余逻辑语句
14. actionMappings.get(param).apply(someParams);

优化方案七：优化逻辑结构，让正常流程走主干

优化前：

1. publicdoublegetAdjustedCapital(){
2. if(_capital<=0.0){
3. return0.0;
4. }
5. if(_intRate>0&&_duration>0){
6. return(_income/_duration)*ADJ_FACTOR;
7. }
8. return0.0;
9. }

优化后：

1. publicdoublegetAdjustedCapital(){
2. if(_capital<=0.0){
3. return0.0;
4. }
5. if(_intRate<=0||_duration<=0){
6. return0.0;
7. }
8. return(_income/_duration)*ADJ_FACTOR;
9. }

将条件反转使异常情况先退出，让正常流程维持在主干流程，可以让代码结构更加清晰。

优化方案八：策略模式+工厂方法消除if else

假设需求为，根据不同勋章类型，处理相对应的勋章服务，优化前有以下代码：

1. StringmedalType="guest";
2. if("guest".equals(medalType)){
3. System.out.println("嘉宾勋章");
4. }elseif("vip".equals(medalType)){
5. System.out.println("会员勋章");
6. }elseif("guard".equals(medalType)){
7. System.out.println("展示守护勋章");
8. }
9. …

首先，我们把每个条件逻辑代码块，抽象成一个公共的接口，可以得到以下代码：

1. //勋章接口
2. publicinterfaceIMedalService{
3. voidshowMedal();
4. StringgetMedalType();
5. }

我们根据每个逻辑条件，定义相对应的策略实现类，可得以下代码：

1. //守护勋章策略实现类
2. publicclassGuardMedalServiceImplimplementsIMedalService{
3. @Override
4. publicvoidshowMedal(){
5. System.out.println("展示守护勋章");
6. }
7. @Override
8. publicStringgetMedalType(){
9. return"guard";
10. }
11. }
12. //嘉宾勋章策略实现类
13. publicclassGuestMedalServiceImplimplementsIMedalService{
14. @Override
15. publicvoidshowMedal(){
16. System.out.println("嘉宾勋章");
17. }
18. @Override
19. publicStringgetMedalType(){
20. return"guest";
21. }
22. }
23. //VIP勋章策略实现类
24. publicclassVipMedalServiceImplimplementsIMedalService{
25. @Override
26. publicvoidshowMedal(){
27. System.out.println("会员勋章");
28. }
29. @Override
30. publicStringgetMedalType(){
31. return"vip";
32. }
33. }

接下来，我们再定义策略工厂类，用来管理这些勋章实现策略类，如下：

1. //勋章服务工产类
2. publicclassMedalServicesFactory{
3. privatestaticfinalMap<String,IMedalService>map=newHashMap<>();
4. static{
5. map.put("guard",newGuardMedalServiceImpl());
6. map.put("vip",newVipMedalServiceImpl());
7. map.put("guest",newGuestMedalServiceImpl());
8. }
9. publicstaticIMedalServicegetMedalService(StringmedalType){
10. returnmap.get(medalType);
11. }
12. }
13. …

使用了策略+工厂模式之后，代码变得简洁多了，如下：

1. publicclassTest{
2. publicstaticvoidmain(String[]args){
3. StringmedalType="guest";
4. IMedalServicemedalService=MedalServicesFactory.getMedalService(medalType);
5. medalService.showMedal();
6. }
7. }

原文地址：https://mp.weixin.qq.com/s/tK0r0jNbYpvezNqWft5ydA