写出漂亮的java代码

写出漂亮代码的七种方法 

首先我想说明我本文阐述的是纯粹从美学的角度来写出代码，而非技术、逻辑等。以下为写出漂亮代码的七种方法： 



1， 尽快结束 if语句 



例如下面这个JavaScript语句，看起来就很恐怖： 

Java代码  

1. 1 function findShape(flags, point, attribute, list) {  
2.   
3. 2    if(!findShapePoints(flags, point, attribute)) {  
4.   
5. 3        if(!doFindShapePoints(flags, point, attribute)) {  
6.   
7. 4            if(!findInShape(flags, point, attribute)) {  
8.   
9. 5                if(!findFromGuide(flags,point) {  
10.   
11. 6                    if(list.count() > 0 && flags == 1) {  
12.   
13. 7                          doSomething();  
14.   
15. 8                    }  
16.   
17. 9                }  
18.   
19. 10            }  
20.   
21. 11       }  
22.   
23. 12    }     
24.   
25. 13  }  

但如果这么写就好看得多： 

Java代码  

1. 1 function findShape(flags, point, attribute, list) {  
2.   
3. 2    if(findShapePoints(flags, point, attribute)) {  
4.   
5. 3        return;  
6.   
7. 4    }  
8.   
9. 5   
10.   
11. 6    if(doFindShapePoints(flags, point, attribute)) {  
12.   
13. 7        return;  
14.   
15. 8    }  
16.   
17. 9   
18.   
19. 10    if(findInShape(flags, point, attribute)) {   
20.   
21. 11        return;  
22.   
23. 12    }  
24.   
25. 13   
26.   
27. 14    if(findFromGuide(flags,point) {  
28.   
29. 15        return;  
30.   
31. 16    }  
32.   
33. 17   
34.   
35. 18    if (!(list.count() > 0 && flags == 1)) {  
36.   
37. 19        return;  
38.   
39. 20    }  
40.   
41. 21   
42.   
43. 22    doSomething();  
44.   
45. 23   
46.   
47. 24 }  

你可能会很不喜欢第二种的表述方式，但反映出了迅速返回if值的思想，也可以理解为：避免不必要的else陈述。 



2， 如果只是简单的布尔运算（逻辑运算），不要使用if语句 



例如： 

Java代码  

1. 1 function isStringEmpty(str){  
2.   
3. 2    if(str === "") {   
4.   
5. 3        return true;  
6.   
7. 4    }  
8.   
9. 5    else {  
10.   
11. 6        return false;  
12.   
13. 7    }  
14.   
15. 8 }  

可以写为： 

Java代码  

1. 1 function isStringEmpty(str){  
2.   
3. 2    return (str === "");  
4.   
5. 3 }  

3， 使用空白，这是免费的 

例如： 

1

Java代码  

1.  function getSomeAngle() {  
2.   
3. 2    // Some code here then  
4.   
5. 3    radAngle1 = Math.atan(slope(center, point1));  
6.   
7. 4    radAngle2 = Math.atan(slope(center, point2));  
8.   
9. 5    firstAngle = getStartAngle(radAngle1, point1, center);  
10.   
11. 6    secondAngle = getStartAngle(radAngle2, point2, center);  
12.   
13. 7    radAngle1 = degreesToRadians(firstAngle);  
14.   
15. 8    radAngle2 = degreesToRadians(secondAngle);  
16.   
17. 9    baseRadius = distance(point, center);  
18.   
19. 10    radius = baseRadius + (lines * y);  
20.   
21. 11    p1["x"] = roundValue(radius * Math.cos(radAngle1) + center["x"]);  
22.   
23. 12    p1["y"] = roundValue(radius * Math.sin(radAngle1) + center["y"]);  
24.   
25. 13    pt2["x"] = roundValue(radius * Math.cos(radAngle2) + center["y"]);  
26.   
27. 14    pt2["y"] = roundValue(radius * Math.sin(radAngle2) + center["y");  
28.   
29. 15    // Now some more code  
30.   
31. 16 }  

很多开发者不愿意使用空白，就好像这要收费一样。我在此并非刻意地添加空白，粗鲁地打断代码的连贯性。在实际编写代码的过程中，会很容易地发现在什么地方加入空白，这不但美观而且让读者易懂，如下： 

Java代码  

1. 1 function getSomeAngle() {  
2.   
3. 2    // Some code here then  
4.   
5. 3    radAngle1 = Math.atan(slope(center, point1));  
6.   
7. 4    radAngle2 = Math.atan(slope(center, point2));  
8.   
9. 5   
10.   
11. 6    firstAngle = getStartAngle(radAngle1, point1, center);  
12.   
13. 7    secondAngle = getStartAngle(radAngle2, point2, center);  
14.   
15. 8   
16.   
17. 9    radAngle1 = degreesToRadians(firstAngle);  
18.   
19. 10    radAngle2 = degreesToRadians(secondAngle);  
20.   
21. 11   
22.   
23. 12    baseRadius = distance(point, center);  
24.   
25. 13    radius = baseRadius + (lines * y);  
26.   
27. 14   
28.   
29. 15    p1["x"] = roundValue(radius * Math.cos(radAngle1) + center["x"]);  
30.   
31. 16    p1["y"] = roundValue(radius * Math.sin(radAngle1) + center["y"]);  
32.   
33. 17   
34.   
35. 18    pt2["x"] = roundValue(radius * Math.cos(radAngle2) + center["y"]);  
36.   
37. 19    pt2["y"] = roundValue(radius * Math.sin(radAngle2) + center["y");  
38.   
39. 20    // Now some more code  
40.   
41. 21 }  
42.   
43.   
44.   
45. 4， 不要使用无谓的注释  
46.   
47. 无谓的注释让人费神，这实在很讨厌。不要标出很明显的注释。在以下的例子中，每个人都知道代码表达的是“students id”，因而没必要标出。  
48.   
49. 1 function existsStudent(id, list) {  
50.   
51. 2    for(i = 0; i < list.length; i++) {  
52.   
53. 3       student = list[i];  
54.   
55. 4   
56.   
57. 5       // Get the student's id  
58.   
59. 6       thisId = student.getId();  
60.   
61. 7   
62.   
63. 8       if(thisId === id) {  
64.   
65. 9           return true;  
66.   
67. 10       }  
68.   
69. 11    }  
70.   
71. 12    return false;     
72.   
73. 13 }  

5， 不要在源文件中留下已经删除的代码，哪怕你标注了 

如果你使用了版本控制，那么你就可以轻松地找回前一个版本的代码。如果别人大费周折地读了你的代码,却发现是要删除的代码，这实在太恨人了。 

Java代码  

1. //function thisReallyHandyFunction() {  
2.   
3. //      someMagic();  
4.   
5. //      someMoreMagic();  
6.   
7. //      magicNumber = evenMoreMagic();  
8.   
9. //      return magicNumber;  
10.   
11. //}  

6，不要有太长的代码 



看太长的代码实在太费劲，尤其是代码本身的功能又很小。如下： 

Java代码  

1. 1 public static EnumMap<Category, IntPair> getGroupCategoryDistribution(EnumMap<Category, Integer> sizes, int groups) {  
2.   
3. 2        EnumMap<Category, IntPair> categoryGroupCounts = new EnumMap<Category,IntPair>(Category.class);  
4.   
5. 3   
6.   
7. 4        for(Category cat : Category.values()) {  
8.   
9. 5            categoryGroupCounts.put(cat, getCategoryDistribution(sizes.get(cat), groups));  
10.   
11. 6        }  

# 



我并不是说非要坚持70个字符以内，但是一个比较理想的长度是控制在120个字符内。如果你把代码发布在互联网上，用户读起来就很困难。 

7，不要在一个功能（或者函数内）有太多代码行 

我的一个老同事曾经说Visual C++很臭，因为它不允许你在一个函数内拥有超过10，000行代码。我记不清代码行数的上限，不知道他说的是否正确，但我很不赞成他的观点。如果一个函数超过了50行，看起来有多费劲你知道么，还有没完没了的if循环，而且你还的滚动鼠标前后对照这段代码。对我而言，超过35行的代码理解起来就很困难了。我的建议是超过这个数字就把一个函数代码分割成两个。