If else

你可能认为太多的 if-else 语句显得不够优雅，想要解决这个问题。但是，什么才是优雅呢？

并非一定要为了重构而替换 if-else，只有在必要的时候才进行。

以下是一些替代 if-else 的技巧。

two branches

code like this.

  [java]
1
2
3
4
5
if(condition) {
    //do sth1
} else {
    //do sth2
}

can be replaced by

  [java]
1
2
3
4
5
if(condition) {
    //do sth1
    return;
}
//do sth2

Notice

有些人认为在函数中多次使用返回语句并不是一种好的做法，您可以在这里阅读更多信息：一个返回语句。

or can replaced by

  [java]
1
condition? doSth() : doAnother();

Notice

这并不是一种通用的方式。总的来说，当有必要时，可以随心所欲地使用 if-else。

many branches

EnumColor.java

  [java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * Created by 侯彬彬 on 2016/6/2.
 */
public enum EnumColor {
    BLACK("black"),
    WHITE("white"),
    GRAY("gray");

    private String colorName;
    EnumColor(String colorName) {
        this.colorName = colorName;
    }

    public String getColorName() {
        return colorName;
    }
}

ColorInfo.java by if,else

  [java]
1
2
3
4
5
6
7
8
9
10
11
12
13
public class ColorInfo {
    public void showInfo(String colorName) {
        if(colorName.equals(EnumColor.BLACK.getColorName())) {
            System.out.println("I'm afraid of black...");
        } else if(colorName.equals(EnumColor.WHITE.getColorName())) {
            System.out.println("I like white very much");
        } else if(colorName.equals(EnumColor.GRAY.getColorName())) {
            System.out.println("Gray is black to white..");
        } else {
            System.out.println("Never seen color!");
        }
    }
}

switch

你可以使用 switch-case 来解决这个问题，这个例子中的 switch(String) 是依赖于 JDK 1.7。

  [java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ColorInfoEnum {
    public void showInfo(String colorName) {
        switch (colorName) {
            case "black":
                System.out.println("I'm afraid of black...");
                break;
            case "white":
                System.out.println("I like white very much");
                break;
            case "gray":
                System.out.println("Gray is black to white..");
                break;
            default:
                System.out.println("Never seen color!");
        }
    }
}

Map

  [java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ColorInfoMap {
    public static final String UNKNOWN_COLOR_INFO = "Never seen color!";
    public static final Map<String, String> map = new HashMap();

    static {
        map.put(EnumColor.BLACK.getColorName(), "I'm afraid of black...");
        map.put(EnumColor.GRAY.getColorName(), "Gray is black to white..");
        map.put(EnumColor.WHITE.getColorName(), "I like white very much");
    }

    public void showInfo(String colorName) {
        String infoResult = map.get(colorName);
        String info = infoResult == null ? UNKNOWN_COLOR_INFO : infoResult;
        System.out.println(info);
    }
}

polymorphic

  [java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class ColorInfoPloy {
    public void showInfo(Color color) {
        color.showInfo();
    }

    interface Color {
        void showInfo();
    }
    class BlackColor implements Color {
        @Override
        public void showInfo() {
            System.out.println("I'm afraid of black...");
        }
    }

    class WhiteColor implements Color {
        @Override
        public void showInfo() {
            System.out.println("I like white very much");
        }
    }

    class GrayColor implements Color {
        @Override
        public void showInfo() {
            System.out.println("Gray is black to white..");
        }
    }
}

ColorInfoTest.java

  [java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class ColorInfoTest extends TestCase{
    @Test
    public void testShowInfo() {
        ColorInfo colorInfo = new ColorInfo();

        colorInfo.showInfo("white");
        colorInfo.showInfo("black");
        colorInfo.showInfo("gray");
        colorInfo.showInfo("blue");
    }


    @Test
    public void testShowInfoMap() {
        ColorInfoMap colorInfoMap = new ColorInfoMap();

        colorInfoMap.showInfo("white");
        colorInfoMap.showInfo("black");
        colorInfoMap.showInfo("gray");
        colorInfoMap.showInfo("blue");
    }

    /**
     * @version jdk1.7
     */
    @Test
    public void testShowInfoEnum() {
        ColorInfoEnum colorInfoEnum = new ColorInfoEnum();
        
        colorInfoEnum.showInfo("white");
        colorInfoEnum.showInfo("black");
        colorInfoEnum.showInfo("gray");
        colorInfoEnum.showInfo("blue");
    }

    @Test
    public void testShowInfoPoly() {
        ColorInfoPloy colorInfoPloy = new ColorInfoPloy();

        colorInfoPloy.showInfo(colorInfoPloy.new BlackColor());
        colorInfoPloy.showInfo(colorInfoPloy.new WhiteColor());
        colorInfoPloy.showInfo(colorInfoPloy.new GrayColor());
    }
}

chat

简单谈一谈代码重构

代码重构是指对现有代码进行修改、调整，以改进其结构、设计和可读性，而不改变其外部行为。

重构的目标是提高代码质量、可维护性和可扩展性，减少bug和增加代码的可理解性。

以下是一些关于代码重构的重要方面：

目的： 代码重构的主要目的是改进代码质量，使其更易于理解、修改和维护。这可能包括消除重复代码、提高性能、改进算法等。
时机： 代码重构并非总是必要的，而是在特定的时机进行。常见的触发因素包括添加新功能时、修复bug时、代码审查时，或者在团队决定进行技术债务管理时。
步骤： 重构通常是一个渐进的过程，可以通过小步骤逐渐实施，每一步都确保代码仍然能够正常工作。这有助于降低引入错误的风险。
代码评审： 在进行代码重构之前，最好通过代码评审来确保团队对于重构的目的和计划有共识。这有助于避免不必要的争议，并提供有益的反馈。
工具支持： 有许多工具可以辅助代码重构，例如IDE中的重构工具或第三方工具。这些工具可以自动执行一些常见的重构操作，减轻了手动修改代码的负担。
测试： 重构时需要确保代码的行为不会发生意外变化。因此，在进行重构之前，最好有一套充分的测试覆盖，以确保修改不会引入新的bug。
模式： 有一些常见的代码重构模式，如提取方法、内联方法、重命名变量等。了解这些模式可以帮助程序员更有效地进行重构。
文档更新： 随着代码的修改，相关的文档也应该进行更新，以确保文档与代码保持一致。
学习机会： 通过参与代码重构，团队成员有机会学习和理解代码库的不同部分。这有助于知识传递和团队的整体技术提升。

总体而言，代码重构是软件开发中不可或缺的一部分，它有助于保持代码库的健康状态，促使团队更好地适应变化和不断提高代码质量。

If else
- two branches
- many branches
chat
- 简单谈一谈代码重构

qa-02-Refactoring

If else

two branches

many branches

chat

简单谈一谈代码重构

更多学习