波动拳式代码优化问题(一)、简单型

何为波动拳式代码？玩过街霸的或者看过龙珠的小伙伴都知道，就是代码像是被龟波气功打过一样，呈现”>”形式。

这种代码主要表现为有3个以上判断语句，加上业务代码后，逻辑十分复杂。常见的波动拳式有三种，下面我们来具体分析一下。

第一种

    private int HadokenStyle1() {
        boolean flag1 = true;
        boolean flag2 = true;
        boolean flag3 = true;
        boolean flag4 = true;
        boolean flag5 = true;
        boolean flag6 = true;
        int res = 0;

        if (flag1) {
            if (flag2) {
                if (flag3) {
                    if (flag4) {
                        if (flag5) {
                            if (flag6) {
                                res = 1;
                            }
                        }
                    }
                }
            }
        }
        return res;
    }

这种样式的代码变现为需要业务同时满足多个标记，那么如何来优化呢？

    private int HadokenStyle1Mod() {
        boolean flag1 = true;
        boolean flag2 = true;
        boolean flag3 = true;
        boolean flag4 = true;
        boolean flag5 = true;
        boolean flag6 = true;
        int res = 0;

        if (flag1 && flag2 && flag3 && flag4 && flag5 && flag6) {
            res = 1;
        }
        return res;
    }

这种情况只要放入一行，同时满足就好了，因为是&，只要有一个不满足，程序就退出判读语句。

第二种

这种形式的代码表现为满足条件时，继续向下，不满足是获得一个返回结果

    private int HadokenStyle2() {
        boolean flag1 = true;
        boolean flag2 = true;
        boolean flag3 = true;
        boolean flag4 = true;
        boolean flag5 = true;
        boolean flag6 = true;
        int res = 0;

        if (flag1) {
            if (flag2) {
                if (flag3) {
                    if (flag4) {
                        if (flag5) {
                            if (flag6) {
                                res = 7;
                            } else {
                                res = 6;
                            }
                        } else {
                            res = 5;
                        }
                    } else {
                        res = 4;
                    }
                } else {
                    res = 3;
                }
            } else {
                res = 2;
            }
        }
        return res;
    }

那么该如何优化呢？

    private int HadokenStyle2Mod() {
        boolean flag1 = true;
        boolean flag2 = true;
        boolean flag3 = true;
        boolean flag4 = true;
        boolean flag5 = true;
        boolean flag6 = true;

        boolean flagAll = true;
        flagAll = flagAll && flag1;
        if (!flagAll) {
            return 1;
        }
        flagAll = flagAll && flag2;
        if (!flagAll) {
            return 2;
        }
        flagAll = flagAll && flag3;
        if (!flagAll) {
            return 3;
        }
        flagAll = flagAll && flag4;
        if (!flagAll) {
            return 4;
        }
        flagAll = flagAll && flag5;
        if (!flagAll) {
            return 5;
        }
        flagAll = flagAll && flag6;
        if (!flagAll) {
            return 6;
        } else {
            return 7;
        }
    }

这种情况下，我们采取反向思维，直接找到他的反面返回，满足条件继续推进。

第二种

这种属于变种，有大于三个平行分支

 private int HadokenStyle3() {
        int style = 0;
        int res = 0;

        if (style == 1) {
            res = 1;
        } else if (style == 2) {
            res = 2;
        } else if (style == 3) {
            res = 3;
        } else if (style == 4) {
            res = 4;
        } else if (style == 5) {
            res = 5;
        } else if (style == 6) {
            res = 6;
        }

        return res;
    }

这种情况当我们明确知道条件的判断值时，我们一般采用switch case语法来替换，通常来说多分支的情况下swich的效率要高一点，也没高多少。还有一个重要原因switch是的语义更加直接、清晰，我们来看下。

    private int HadokenStyle3Mod() {
        int style = 0;
        int res = 0;

        switch (style) {
            case 1:
                res = 1;
                break;
            case 2:
                res = 2;
                break;
            case 3:
                res = 3;
                break;
            case 4:
                res = 4;
                break;
            case 5:
                res = 5;
                break;
            case 6:
                res = 6;
                break;

            default:
                break;
        }
        return res;
    }

以上三种形式的代码，我们在实际开发过程中，会经常遇到，刚开始可能条件很少，随着业务的演变，今天你加一条，明天我加一条，慢慢的越来越多，最终累积出波动拳式。还有一些其他的变种，比如循环和条件合并型的等。