優化If else(簡化程式碼)

if else 是我們寫程式碼時，使用頻率最高的關鍵詞之一，然而有時過多的 if else 會讓我們感到頭暈。
當我們回過頭看程式碼或者欣賞他人程式碼時，感到煩人。我總結了幾種方式，可以參考呀。
1.使用 return
我們使用 return 去掉多餘的 else，實現程式碼如下。

優化前程式碼：

if ("java".equals(str)) {
    // 業務程式碼......
} else {
    return;
}

優化後程式碼：

if (!"java".equals(str)) {
    return;
}
// 業務程式碼......

2.使用 Map
使用 Map 陣列，把相關的判斷資訊，定義為元素資訊可以直接避免 if else 判斷，實現程式碼如下。
優化前程式碼

if (t == 1) {
    type = "name";
} else if (t == 2) {
    type = "id";
} else if (t == 3) {
    type = "mobile";
}

我們先定義一個 Map 陣列，把相關判斷資訊儲存起來：

Map<Integer, String> typeMap = new HashMap<>();
typeMap.put(1, "name");
typeMap.put(2, "id");
typeMap.put(3, "mobile");

之前的判斷語句可以使用以下一行程式碼代替了：

type = typeMap.get(t);

3.使用三元運算子
三元運算子也叫三元表示式或者三目運算子/表示式，不過代表的都是一個意思，優化程式碼如下。
優化前程式碼：

Integer score = 81;
if (score > 80) {
    score = 100;
} else {
    score = 60;
}

優化後程式碼：

score = score > 80 ? 100 : 60;

4.合併條件表示式

String city = "唐山";
String area = "888";
String province = "唐山";
if ("唐山".equals(city)) {
    return "tang'shan";
}
if ("020".equals(area)) {
    return "tang'shan";
}
if ("唐山".equals(province)){
    return "tang'shan";
}

優化後程式碼：

if ("唐山".equals(city) || "888".equals(area) || "唐山".equals(province)){
    return"tang'shan";
}

5.使用列舉

Integer typeId = 0;
String type = "Name";
if ("Name".equals(type)) {
    typeId = 1;
} else if ("Age".equals(type)) {
    typeId = 2;
} else if ("Address".equals(type)) {
    typeId = 3;
}

優化時，我們先來定義一個列舉：

public enum TypeEnum {
    Name(1), Age(2), Address(3);
    public Integer typeId;
    TypeEnum(Integer typeId) {
        this.typeId = typeId;
    }
}

之前的 if else 判斷就可以被如下一行程式碼所替代了：

typeId = TypeEnum.valueOf("Name").typeId;

6.使用 Optional

從 JDK 1.8 開始引入 Optional 類，在 JDK 9 時對 Optional 類進行了改進，增加了 ifPresentOrElse() 方法，我們可以藉助它，來消除 if else 的判斷，使用如下。

String str = "java";
if (str == null) {
    System.out.println("Null");
} else {
    System.out.println(str);
}

優化後程式碼：

Optional<String> opt = Optional.of("java");
opt.ifPresentOrElse(v -> 
	System.out.println(v), () -> System.out.println("Null"));

7.梳理優化判斷邏輯

// 年齡大於 18
if (age > 18) {
    // 工資大於 5000
    if (salary > 5000) {
        // 是否漂亮
        if (pretty == true) {
            return true;
        }
    }
}
return false;

優化後程式碼：

if (age < 18) {
    return false;
}
if (salary < 5000) {
    return false;
}
return pretty; 

8.使用多型
繼承、封裝和多型是 OOP（物件導向程式設計）的重要思想，我們使用多型的思想，提供一種去除 if else 方法。

Integer typeId = 0;
String type = "Name";
if ("Name".equals(type)) {
    typeId = 1;
} else if ("Age".equals(type)) {
    typeId = 2;
} else if ("Address".equals(type)) {
    typeId = 3;
}

使用多型，我們先定義一個介面，在介面中宣告一個公共返回 typeId 的方法，在新增三個子類分別實現這三個子類

public interface IType {
    public Integer getType();
}
 
public class Name implements IType {
    @Override
    public Integer getType() {
        return 1;
    }
}
 
public class Age implements IType {
    @Override
    public Integer getType() {
        return 2;
    }
}
 
public class Address implements IType {
    @Override
    public Integer getType() {
        return 3;
    }
}

注：為了簡便我們這裡把類和介面放到了一個程式碼塊中，在實際開發中應該分別建立一個介面和三個類分別儲存。

此時，我們之前的 if else 判斷就可以改為如下程式碼：

IType itype = (IType) Class.forName("com.example." + type).newInstance();
Integer typeId = itype.getType();

9.選擇性的使用 switch

if ("add".equals(cmd)) {
    result = n1 + n2;
} else if ("subtract".equals(cmd)) {
    result = n1 - n2;
} else if ("multiply".equals(cmd)) {
    result = n1 * n2;
} else if ("divide".equals(cmd)) {
    result = n1 / n2;
} else if ("modulo".equals(cmd)) {
    result = n1 % n2;
}

switch 程式碼：

switch (cmd) {
    case "add":
        result = n1 + n2;
        break;
    case "subtract":
        result = n1 - n2;
        break;
    case "multiply":
        result = n1 * n2;
        break;
    case "divide":
        result = n1 / n2;
        break;
    case "modulo":
        result = n1 % n2;
        break;
}

在Java更新中java14 switch可以這麼用：

// java 14
switch (cmd) {
    case "add" -> {
        result = n1 + n2;
    }
    case "subtract" -> {
        result = n1 - n2;
    }
    case "multiply" -> {
        result = n1 * n2;
    }
    case "divide" -> {
        result = n1 / n2;
    }
    case "modulo" -> {
        result = n1 % n2;
    }
}

有的時候程式碼寫多了，就可以體會到換一種方式，程式碼就會很清晰，遇到了一個判斷條件很多，邏輯稍微複雜的東西，if else用多了，看著特別難受，多用條件return跳出來，程式碼會好很多，且行且體會。