优化太多的if-else

来源java小当家

• 第1种方法：提前return，减少else判断

 1  // 1.优化前
 2     private int handlerPre1(boolean flag) {
 3         if(flag){
 4             // TODO
 5             return 0;
 6         }else{
 7             // TODO
 8             return -1;
 9         }
10     }
11     // 第1种方法：提前return，减少else判断
12     // 这个做法，将可以return的状态提到if中，直接干掉else
13     private int handlerAfter1(boolean flag) {
14         if(!flag){
15             // TODO
16             return -1;
17         }
18         return 0;
19     }

• 第2种方法：使用三目运算符

 1 // 2.优化前
 2     private int handlerPre2(boolean flag) {
 3         if(flag){
 4             return 0;
 5         }else{
 6             return -1;
 7         }
 8     }
 9     // 第2种方法：使用三目运算符
10     // 对那些依据状态直接返回某个值的情况非常适用，但如果三目运算符中还镶嵌三目运算，建议不要使用
11     private int handlerAfter2(boolean flag) {
12         return flag?0:-1;
13     }

• 第3种方法：使用Optional

 1     // 3.优化前
 2     private Integer handlerPre3(){
 3         User user = new User();
 4         if(user != null){
 5             return user.getAge();
 6         }
 7         return null;
 8     }
 9     // 第3种方法：使用Optional
10     // Optional让非空校验更加优雅，代码层面减少了if判断。
11     private Integer handlerAfter3(){
12         User user = new User();
13         Optional<User> optional = Optional.ofNullable(user);
14         return optional.map(User::getAge).orElse(null);
15     }

• 第4种方法：使用switch

 1 // 4.优化前
 2     private String getCnPre(String en){
 3         String cn;
 4         if("student".equals(en)){
 5             cn = "学生";
 6         }else if("teacher".equals(en)){
 7             cn = "教师";
 8         }else{
 9             cn = "未知";
10         }
11         return cn;
12     }
13
14     // 4.1 优化后 使用switch
15     private String getCnAfter1(String en){
16         switch (en) {
17             case "student":
18                 return "学生";
19             case "teacher":
20                 return "教师";
21             default:
22                 return "未知";
23         }
24     }

• 第5种方法：使用枚举

 1 public enum CnEnum {
 2     STUDENT("student","学生"),
 3     TEACHER("teacher","教师"),
 4     UNKNOWN("unknown","未知");
 5     private String en;
 6     private String cn;
 7
 8     public String getEn() {
 9         return en;
10     }
11     public void setEn(String en) {
12         this.en = en;
13     }
14     public String getCn() {
15         return cn;
16     }
17     public void setCn(String cn) {
18         this.cn = cn;
19     }
20     CnEnum(String en, String cn) {
21         this.en = en;
22         this.cn = cn;
23     }
24
25     static String of(String en){
26         for (CnEnum temp : CnEnum.values()){
27             if(temp.getEn().equals(en)){
28                 return temp.getCn();
29             }
30         }
31         return CnEnum.UNKNOWN.getCn();
32     }
33 }

1  // 4.2 优化前 使用枚举
2     private String getCnAfter2(String en){
3         return CnEnum.of(en);
4     }

• 第6种方法：使用工厂模式

　　　　（1）定义一个职业接口，里面定义一个输出方法

1 public interface Profession {
2     String output();// 输出
3 }

　　　　（2）每增加一种职业，都实现这个接口(策略模式)

 1 public class Teacher implements Profession{
 2     @Override
 3     public String output() {
 4         return "教书";
 5     }
 6 }
 7
 8 public class Student implements Profession{
 9     @Override
10     public String output() {
11         return "学习";
12     }
13 }

　　　　（3）定义一个工厂类，用来根据具体情况生产各种职业类(工厂模式)

 1 public class ProfessionFactory {
 2
 3     private static Map<String,Profession> map = new HashMap<>();
 4     private static final Profession DEFAULT_PROFESSION = new DefaultProfession();
 5     static {
 6         map.put("student",new Student());
 7         map.put("teacher",new Teacher());
 8         map.put("default",DEFAULT_PROFESSION);
 9     }
10     public static Profession getProfession(String en){
11         Profession profession = map.get(en);
12         return profession == null?DEFAULT_PROFESSION:profession;
13     }
14
15     static class DefaultProfession implements Profession {
16         @Override
17         public String output() {
18             return "未知";
19         }
20     }
21
22 }

　　　　（4）测试

1  // 5.优化后 使用 策略模式+工厂模式
2     // 1.定义一个职业接口，里面定义一个输出方法
3     // 2.每增加一种职业，都实现这个接口(策略模式)
4     // 3.定义一个工厂类，用来根据具体情况生产各种职业类(工厂模式)
5     private void handlerAfter5(String en){
6         Profession profession = ProfessionFactory.getProfession(en);
7         System.out.println(profession.output());
8     }