2012-10-05
Google对Android的编程规范在Code Style Guidelines for Contributors中做了描述,并在Android源码中release了import和Java的配置文件android.importorder与android-formatting.xml。本文分析这些配置文件在Eclipse环境下格式化Android编码规范都做了什么,在Java和XML文件中如何具体体现。
Android源码目录<android_src_root>/development/ide/eclipse/下有文件android.importorder和android-formatting.xml,可以在Eclipse中导入import次序及Java编码风格:
1) 打开Window > Preferences > Java > Code Style;
2) 在Organizer Imports中点击Imports,选择android.importorder导入;
3) 在Formatter中点击Imports,选择android-formatting.xml导入。
下面讲解这些配置都做了什么,在代码中如何具体体现的。
一、Import的次序
Google推荐的AndroidJava文件开头import的次序(按照先后)是:
- com
- org
- android
- java
- javax
排列原则:
- 这个次序也是根据看import语句的重要性来排定的:首先希望看到用了android里的哪些类;然后是其他第三方的;最后才关注标准Java库里的。
- 不同的import分组之间是有一个空白行,在5.2.1 4)中描述。
- 同一import分组内部按照字母次序排列。
二、缩进(Indentation)
2.1 总则
缩进只用空格,不用制表符(TAB)。缩进用4个空格,按下TAB键用4个空格代替。
2.2 示例代码
- /**
- * Indentation
- */
- class Example {
- int[] myArray = {
- 1, 2, 3, 4, 5, 6
- };
- int theInt = 1;
- String someString = "Hello";
- double aDouble = 3.0;
- void foo(int a, int b, int c, int d, int e, int f) {
- switch (a) {
- case 0:
- Other.doFoo();
- break;
- default:
- Other.doBaz();
- }
- }
- void bar(List v) {
- for (int i = 0; i <10; i++) {
- v.add(new Integer(i));
- }
- }
- }
- enum MyEnum {
- UNDEFINED(0) {
- void foo() {
- }
- }
- }
- @interface MyAnnotation {
- int count() default 1;
- }
2.3 规则说明
1) 域不用对齐
若对齐的话,则myArray,theInt, someString和aDouble都在同一列上对齐。
2) 类体内部的声明全都缩进
Class Example内的定义[#5 ~ #29]相对class Example[#4]都有缩进
3) 枚举的声明要缩进
UNDEFINED(0) [#33]前面有缩进
4) 枚举内的常量要缩进
void foo() [#34]前面有缩进
5) 注解的声明要缩进
int count()[#39]前面有缩进
6) 方法/构造体内的语句要缩进
方法foo和bar内的语句[#16 ~ #22, #26 ~ #28]都有缩进
7) 程序块内的语句要缩进
for循环内的v.add(new Integer(i))[#27]有缩进
8) switch内的语句要缩进
switch内的语句[#17 ~ #21]相对switch有缩进
9) case内的语句要缩进
Other.doFoo()[#18]相对于case;Other.doBaz()[#21]相对于default都有缩进
10) break语句要缩进
break[#19]相对于case有缩进
11) 空白行不用缩进
域和方法之间的空白行[#8, #10, #12, #14, #24]是没有缩进的
三、大括号(Braces)的位置
3.1 示例代码
- /**
- * Braces
- */
- interface Empty {
- }
- enum MyEnum {
- UNDEFINED(0) {
- void foo() {
- }
- }
- }
- @interfaceSomeAnnotationType {
- }
- class Example {
- SomeClass fField = new SomeClass() {
- };
- int[] myArray = {
- 1, 2, 3, 4, 5, 6
- };
- int[] emptyArray = new int[] {};
- Example() {
- }
- void bar(int p) {
- for (int i = 0; i <10; i++) {
- }
- switch (p) {
- case 0:
- fField.set(0);
- break;
- case 1: {
- break;
- }
- default:
- fField.reset();
- }
- }
- }
3.2 规则说明
1) 类或接口的声明跟左大括号在同一行上
#4 Empty以及 #17 Example后面{的位置
2) 匿名类的声明跟左大括号在同一行上
#18 SomeClass后面{的位置
3) 构造体的声明跟左大括号在同一行上
#27 Example()后面{的位置
4) 方法的声明跟左大括号在同一行上
#9 foo和#30 bar后面{的位置
5) 枚举的声明跟左大括号在同一行上
#7 MyEnum 后面{的位置
6) 枚举常量体跟左大括号在同一行上
#8 UNDEFINED(0) 后面{的位置
7) 注解类型的声明跟左大括号在同一行上
#14 SomeAnnotationType后面{的位置
8) 程序块跟左大括号在同一行上
#31 for后面{的位置
9) case语句中的程序块跟左大括号在同一行上
#37 case 1后面{的位置
10) switch语句跟左大括号在同一行上
#33 switch后面{的位置
11) 数组的初始化常量跟左大括号在同一行上
#21和#25 {的位置
四、空格(White Space)
4.1 声明
4.1.1 类
- class MyClass implements I0, I1, I2 {
- }
- AnonClass = new AnonClass() {
- void foo(Some s) {
- }
- };
· 类的左大括号的前面加空格;
· 匿名类的左大括号的前面加空格;
· implements语句中逗号的前面,不加空格;
· implements语句中逗号的后面,加上空格;
4.1.2 域
- int a = 0, b = 1, c= 2, d = 3;
· 多个域声明中逗号的前面,不加空格;
· 多个域声明中逗号的后面,加上空格。
4.1.3 临时变量
- int a = 0, b = 1, c= 2, d = 3;
· 多个临时变量声明中逗号的前面,不加空格;
· 多个临时变量声明中逗号的后面,加上空格;
4.1.4 构造体
- MyClass() throws E0, E1 {
- this(0, 0, 0);
- }
- MyClass(int x, int y, int z) throws E0, E1 {
- super(x, y, z, true);
- }
· 左小括号的前面,不加空格;
· 左小括号的后面,不加空格;
· 右小括号的前面,不加空格;
· 小括号内为空,则它们之间不加空格;
· 左大括号前面,加上空格;
· 参数列表中逗号之前,不加空格;
· 参数列表中逗号之后,加上空格;
· throws语句中逗号之前,不加空格;
· throws语句中逗号之后,加上空格。
4.1.5 方法
- void foo() throws E0, E1 {
- };
- void bar(int x, int y) throws E0, E1 {
- }
- void format(Strings, Object... args) {
- }
· 左小括号的前面,不加空格;
· 左小括号的后面,不加空格;
· 右小括号的前面,不加空格;
· 小括号内为空,则它们之间不加空格;
· 左大括号前面,加上空格;
· 参数列表中逗号之前,不加空格;
· 参数列表中逗号之后,加上空格;
· 可变参数列表省略号之前,不加空格;
· 可变参数列表省略号之后,加上空格;
· throws语句中逗号之前,不加空格;
· throws语句中逗号之后,加上空格。
4.1.6 标号
- label: for (int i = 0; i < list.length; i++) {
- for (int j = 0; j < list[i].length; j++)
- continue label;
- }
· 冒号之前,不加空格;
· 冒号之后,加上空格
4.1.7 注解/Annotation
- @Annot(x = 23, y = -3)
- public class A {
- }
· ‘@’之后,不加空格;
· 左小括号的前面,不加空格;
· 左小括号的后面,不加空格;
· 逗号前面,不加空格;
· 逗号后面,加上空格;
· 右小括号的前面,不加空格
4.1.8 枚举/Enumtypes
- enum MyEnum {
- GREEN(0, 1), RED() {
- void process() {
- }
- }
- }
· 声明中左大括号的前面[#1],加上空格;
· 常量之间的逗号[#2 RED前]前面,不加空格;
· 常量之间的逗号[#2 RED前]后面,加上空格;
· 常量参数的左小括号[#2 GREEN后]前面,不加空格;
· 常量参数的左小括号[#2 GREEN后]后面,不加空格;
· 常量参数的小括号[#2 RED后]中间为空,括号之间不加空格;
· 常量参数之间的逗号[#2 GREEN()里面]前面,不加空格;
· 常量参数之间的逗号[#2 GREEN()里面]后面,加上空格;
· 常量参数的右小括号[#2 GREEN()后]前面,不加空格;
· 常量体左大括号[#2 RED后]前面,加上空格。
4.1.9 注解类型/Annotationtypes
- @interface MyAnnotation {
- String value();
- }
- @interface OtherAnnotation {
- }
· ‘@’之前,不加空格;
· ‘@’之后,不加空格
· 左大括号的前面,加上空格;
· 注解类型成员的左小括号的前面,不加空格;
· 注解类型成员的小括号的之间,不加空格;
4.2 控制语句
4.2.1 程序块
- if (true) {
- return 1;
- } else {
- return 2;
- }
· 左大括号前面,加上空格;
· 右大括号后面,加上空格。
4.2.2 if else语句
- if (condition) {
- return foo;
- } else {
- return bar;
- }
· 左小括号前加上空格;
· 左小括号后不加空格;
· 右小括号前不加空格【左大括号前的空格是规则#4.2.1】
4.2.3 for语句
- for (int i = 0, j = array.length; i < array.length; i++, j--) {
- }
- for (String s : names) {
- }
· 左小括号前加上空格;
· 左小括号后不加空格;
· 右小括号前不加空格【左大括号前的空格是规则#4.2.1】
· 初始化语句的逗号前不加空格;
· 初始化语句的逗号后加上空格
· 增量语句的逗号前不加空格;
· 增量语句的逗号后加上空格
· 语句之间的分号前不加空格;
· 语句之间的分号后加上空格;
· 冒号前面加上空格;
· 冒号后面加上空格。
4.2.4 switch语句
- switch (number) {
- case RED:
- return GREEN;
- case GREEN:
- return BLUE;
- case BLUE:
- return RED;
- default:
- return BLACK;
- }
· case和default的冒号(‘:’)前不加空格;
· 左括号(‘(’)和左大括号(‘{’)前都加上空格;
· 左括号(‘(’)后和右括号(‘)’)前都不加空格。
4.2.5 while和dowhile语句
- while (condition) {
- }
- ;
- do {
- } while (condition);
· 左括号前加上空格;
· 左括号后不加空格;
· 右括号前不加空格【#1左大括号前的空格是规则#4.2.1】
4.2.6 同步(synchronized)语句
- synchronized (list) {
- list.add(element);
- }
· 左括号前加上空格;
· 左括号后不加空格;
· 右括号前不加空格【左大括号前的空格是规则#4.2.1】
4.2.7 catch语句
- try {
- number = Integer.parseInt(value);
- } catch (NumberFormatException e) {
- }
· 左括号前加上空格;
· 左括号后不加空格;
· 右括号前不加空格【左大括号前的空格是规则#4.2.1】
4.2.8 assert语句
- assert condition : reportError();
冒号前后都加上空格
4.2.9 return语句
- return (o);
括号表达式前加上空格
4.2.10 throw语句
- throw (e);
括号表达式前加上空格
4.3 表达式
4.2.1 函数调用
- foo();
- bar(x, y);
- String str = new String();
- Point point = new Point(x, y);
- MyClass() throws E0, E1 {
- this(0, 0, 0);
- }
- MyClass(int x, int y, int z) throws E0, E1 {
- super(x, y, z, true);
- }
· 左括号的前后都不加空格;
· 右括号前不加空格;
· 空的参数的左右括号之间不加空格;
· 方法调用时多个参数之间分割的逗号前面不加空格,逗号后面加空格;
· 对象申请时多个参数之间分割的逗号前面不加空格,逗号后面加空格;
· 显示调用构造函数时多个参数之间分割的逗号前面不加空格,逗号后面加空格;
4.3.2 赋值
- List list = new ArrayList();
- int a = -4 + -9;
- b = a++ / --number;
- c += 4;
- boolean value = true && false;
赋值操作(=)前后都加上空格。【注意:‘+=’是一个操作数】
4.3.3 操作数
- List list = new ArrayList();
- int a = -4 + -9;
- b = a++ / --number;
- c += 4;
- boolean value = true && false;
· 二元操作(#2的‘+’;#3的‘/’;#5的‘&&’)前后都加上空格;
· 一元操作(#2 ‘4’和‘9’前面的‘-’)前后都不加空格【示例中‘-’前的空格不是这个规则里的】;
· 前置操作的(#3的‘--number’)前后都不加空格【示例中‘--’前的空格不是这个规则里的】;
· 后置操作的(#3的‘a++’)前后都不加空格【示例中‘++’后的空格不是这个规则里的】。
4.3.4 加括号的表达式
- result = (a * (b + c + d) * (e + f));
左括号前,左括号后和右括号前都不加空格【示例中左括号前的空格不是这个规则里的】
4.3.5 类型转换
- String s = ((String) object);
· 右括号后加上空格;
· 左括号后和右括号前都不加空格。
4.3.6 三元条件表达式
- String value = condition ? TRUE : FALSE;
问号前,问号后,冒号前,冒号后都要加上空格
4.4 数组
- int[] array0 = new int[] {};
- int[] array1 = new int[] {
- 1, 2, 3
- };
- int[] array2 = new int[3];
- array[i].foo();
4.4.1 声明
· 左中括号前不加空格;
· 左右中括号中间不加空格
示例中:arrayX前的‘[]’
4.4.2 申请
· 左中括号前后都不加空格;
· 右中括号前不加空格;
· 空的左右中括号中间不加空格;
示例中:等号‘=’后面的‘[]’
4.4.3 初始化体
· 左大括号前后都加上空格;
· 右大括号前加上空格;
· 逗号前不加空格;
· 逗号后加上空格;
· 空的大括号中间不加空格
4.4.4 数组元素的访问
· 左中括号前后都不加空格;
· 右中括号前面不加空格
4.5 泛型
- Map<String, Element> map = newHashMap<String, Element>();
- x.<String, Element> foo();
- classMyGenericType<S, T extends Element & List> {
- }
- Map<X<?>, Y<? extendsK, ? super V>> t;
五、空白行(BlankLines)
5.1 示例代码
- /**
- * Blank Lines
- */
- package foo.bar.baz;
- import java.util.List;
- import java.util.Vector;
- import java.net.Socket;
- public class Another {
- }
- public class Example {
- public static class Pair {
- public String first;
- public String second;
- // Between here...
- // ...and here are 10 blank lines
- };
- private LinkedList fList;
- public int counter;
- publicExample(LinkedList list) {
- fList = list;
- counter = 0;
- }
- public void push(Pair p) {
- fList.add(p);
- ++counter;
- }
- public Object pop() {
- --counter;
- return (Pair)fList.getLast();
- }
- }
5.2 规则说明
5.2.1 编译单元之间的空白行
1) 包声明之前有一空白行[#4]
2) 包声明之后有一空白行[#6]
3) import声明之前有一空白行[#6]
4) import各个分组之间有一空白行[#9]
5) import声明之后有一空白行[#11]
6) 类声明之间有一空白行[#14]
5.2.2 类内部的空白行
1) 第一个声明之间无空白行[#15 & #16之间]
2) 相同分类声明之前有一空白行[#24, #28]
3) 成员类声明之前有一空白行
4) 域声明之前有一空白行[#18, #24, #26]
5) 方法声明之前有一空白行[#28,#33, #38]
6) 方法内的开始处没有空白行[#29和#30之间;#34与#35之间;#39与#40之间]
六、插入新行(NewLines)
6.1 示例代码
- /**
- * New Lines
- */
- public class Empty {
- }
- class Example {
- static int[] fArray = {
- 1, 2, 3, 4, 5
- };
- Listener fListener = new Listener() {
- };
- @Deprecated
- @Override
- public void bar(@SuppressWarnings("unused") int i) {
- @SuppressWarnings("unused")
- int k;
- }
- void foo() {
- ;
- ;
- label: do {
- } while (false);
- for (;;) {
- }
- }
- }
- enum MyEnum {
- UNDEFINED(0) {
- }
- }
- enum EmptyEnum {
- }
- @interface EmptyAnnotation{
- }
6.2 规则说明
6.2.1 插入新行
1) 类体内为空,插入新行[#5是另起的一行]
2) 匿名类体内为空,插入新行[#13是另起的一行]
3) 方法内为空,插入新行
4) 空的程序块,插入新行[#26是另起的一行;#28是另起的一行]
5) 标号后面不插入新行[#25 do与label在同一行]
6) 在空的枚举声明中,插入新行[#38是另起的一行]
7) 在空的枚举常量体中,插入新行[#34是另起的一行]
8) 在空的注解体中,插入新行[#41是另起的一行]
9) 在文件结尾,插入新行[#42是另起的一行]
6.2.2 数组初始化
1) 数组初始化体的左大括号后,插入新行[#9是另起的一行]
2) 数组初始化体的右大括号前,插入新行[#10是另起的一行]
6.2.3 空的语句
空的语句放在新行上[#24是另起的一行]
6.2.4 注解
1) 对成员的注解之后,插入新行[#16 & #17都是另起的一行]
2) 对参数的注解之后,不插入新行[#17 int i与@SuppressWarnings("unused")在同一行]
3) 对临时变量的注解之后,插入新行[#19是另起的一行]
七、控制语句(ControlStatements)
7.1 示例代码
- /**
- * If...else
- */
- class Example {
- void bar() {
- do {
- } while (true);
- try {
- } catch (Exception e) {
- } finally {
- }
- }
- void foo2() {
- if (true) {
- return;
- }
- if (true) {
- return;
- } else if (false) {
- return;
- } else {
- return;
- }
- }
- void foo(int state) {
- if (true)
- return;
- if (true)
- return;
- else if (false)
- return;
- else
- return;
- }
- }
7.2 规则说明
1) if语句的else之前,不插入新行[#20& #22的else与‘}’在同一行]
2) try语句的catch之前,不插入新行[#9的catch与‘}’在同一行]
3) try语句的finally之前,不插入新行[#10的finally与‘}’在同一行]
4) do语句的while之前,不插入新行[#7的while与‘}’在同一行]
5) #29的‘then’语句与#28的if在不同行,#31的‘then’语句与#30的if在不同行;
6) #35的else语句与#34的else在不同行;
7) #20和#32的else if中‘else与‘if’在同一行;
8) ‘return’或‘throw’语句不需要在一行上[#16与#15在两行上]
八、换行(LineWrapping)
8.1 总则
- 每行最多100个字符;
- 超过100个字符的行要换行,新行缺省缩进2个缩进单位。一个缩进单位是4个空格,所以这里总共缩进8个空格。
- 缺省数组初始化值缺省缩进2个缩进单位。
8.2 注解(Annotation)
- /**
- * Element-value pairs
- */
- @MyAnnotation(value1 = "this isan example", value2 = "of an annotation", value3 = "withseveral arguments", value4 = "by Haili TIAN (haili.tian@gmail.com)")
- class Example {
- }
注解不换行:value1、value2、value3和value4都在同一行上。
8.3 类声明
- /**
- * 'extends' clause
- */
- class Example extends
- OtherClass {
- }
- /**
- * 'implements' clause
- */
- class Example implements I1,
- I2, I3 {
- }
- extends子句在需要换行的地方,用缺省换行方式换行:#5OtherClass处换行,且OtherClass相对class缩进了8个空格;
- implements子句在需要换行的地方,用缺省换行方式换行:#12I2处换行,且I2相对class缩进了8个空格。
8.4 构造体声明
- /**
- * Parameters
- */
- class Example {
- Example(int arg1, int arg2,
- int arg3, int arg4,
- int arg5, int arg6) {
- this();
- }
- Example() {
- }
- }
- /**
- * 'throws' clause
- */
- class Example {
- Example() throws FirstException,
- SecondException,
- ThirdException {
- returnOther.doSomething();
- }
- }
- 构造体的参数在需要换行的地方,用缺省换行方式换行:参数[#6 ]相对Example[#5]缩进了8个空格;
- 构造体throws子句在需要换行的地方,用缺省换行方式换行:子句[#20& #21]相对Example[#19]缩进了8个空格。
8.5 方法声明
- /**
- * Declaration
- */
- class Example {
- public final synchronizedjava.lang.String a_method_with_a_long_name() {
- }
- }
- /**
- * Parameters
- */
- class Example {
- void foo(int arg1, int arg2,
- int arg3, int arg4,
- int arg5, int arg6) {
- }
- }
- /**
- * 'throws' clause
- */
- class Example {
- int foo() throws FirstException,
- SecondException,
- ThirdException {
- returnOther.doSomething();
- }
- }
- 方法声明处不换行:#5 很长,但不分行;
- 方法声明处的参数在需要换行的地方,用缺省换行方式换行:参数[#14& #15]相对voidfoo [#13]缩进了8个空格;
- 方法声明处的throws子句在需要换行的地方,用缺省换行方式换行:子句[#24& #25]相对intfoo [#23]缩进了8个空格。
8.6 枚举声明
- /**
- * Constants
- */
- enum Example {
- CANCELLED, RUNNING, WAITING, FINISHED
- }
- enum Example {
- GREEN(0, 255, 0), RED(
- 255, 0, 0)
- }
- /**
- * 'implements' clause
- */
- enum Example implements A, B,
- C {
- }
- /**
- * Constant arguments
- */
- enum Example {
- GREEN(0, 255, 0), RED(
- 255, 0, 0)
- }
- 枚举常量定义的地方,不换行:#5不换行;
- implements子句在需要换行的地方,用缺省换行方式换行:#17 C处换行,且C相对enum缩进了8个空格;
- 常量参数在需要换行的地方,用缺省换行方式换行:#10 和#25处换行,且相对GREEN缩进了8个空格。
8.7 函数调用
- /**
- * Arguments
- */
- class Example {
- void foo() {
- Other.bar(
- 100,
- nested(200, 300, 400,
- 500, 600, 700,
- 800, 900));
- }
- }
- /**
- * Qualified invocations
- */
- class Example {
- int foo(Some a) {
- return a.getFirst();
- }
- }
- /**
- * Explicit constructor invocations
- */
- class Example extends AnotherClass {
- Example() {
- super(100, 200, 300,400, 500,
- 600, 700);
- }
- }
- /**
- * Object allocation arguments
- */
- class Example {
- SomeClass foo() {
- return new SomeClass(100,200,
- 300, 400, 500, 600,
- 700, 800, 900);
- }
- }
- /**
- * Qualified object allocation arguments
- */
- class Example {
- SomeClass foo() {
- return SomeOtherClass.new SomeClass(
- 100, 200, 300, 400, 500);
- }
- }
- 函数调用参数处,在需要换行的地方,用缺省换行方式换行:#7, #8和#9, #10处换行,且#7,#8相对Other.bar缩进了8个空格, #9, #10相对nested缩进了8个空格;
- 对象的方法调用处,在需要换行的地方,用缺省换行方式换行:#19这个例子不太好,如果这句很长,可以在a和getFirst之间换行,且.放在getFirst前;
- 显示的构造函数调用处,在需要换行的地方,用缺省换行方式换行:#29处换行,且相对#30的super缩进8个空格;
- 对象创建参数处,在需要换行的地方,用缺省换行方式换行:#39, #40处换行,且相对#38的return缩进8个空格;
- 对象方法构造对象参数处,在需要换行的地方,用缺省换行方式换行:#50处换行,且相对#49的return缩进8个空格.
8.8 表达式
- /**
- * Binary expressions
- */
- class Example extends AnotherClass {
- int foo() {
- int sum = 100 + 200 + 300 + 400
- + 500 + 600 + 700 + 800;
- int product = 1 * 2 * 3 * 4 * 5
- * 6 * 7 * 8 * 9 * 10;
- boolean val = true && false
- && true && false
- && true;
- return product / sum;
- }
- }
- /**
- * Conditionals
- */
- class Example extends AnotherClass {
- int Example(boolean Argument) {
- return argument ?100000
- : 200000;
- }
- }
- /**
- * Array initializers
- */
- class Example {
- int[] fArray = {
- 1, 2, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, 12
- };
- }
- /**
- * Assignments
- */
- class Example {
- private static final String string ="TextTextText";
- void foo() {
- for (int i = 0; i <10; i++) {
- }
- String s;
- s = "TextTextText";
- }
- }
- 二元表达式,在需要换行的地方,用缺省换行方式换行:#7, #9和#11,#12处换行,且#7相对int sum缩进了8个空格,且#9相对int product缩进了8个空格,且#11& #12相对boolean val缩进了8个空格;
- 三元条件表达式,除了第一个元素,用缺省换行方式换行所有其他元素:#22& #23;
- 数组初始化体,在需要换行的地方,用缺省换行方式换行:#32 !处换行,且#32& #33相对int[] fArray缩进了8个空格;
- 赋值语句,不需要换行:#41行很长也不需要换行。
8.9 语句
- /**
- * Compact 'if else'
- */
- class Example {
- int foo(int argument) {
- if (argument == 0)
- return 0;
- if (argument == 1)
- return 42;
- else
- return 43;
- }
- }
九、注释(Comments)
- /**
- * An example for comment formatting. This example is meant to illustrate the various possibilities offered by <i>Haili TIAN</i> in order to format comments.
- */
- package mypackage;
- /**
- * This is the comment for the example interface.
- */
- interface Example {
- // This is a long comment with white space that should be split in multiple
- // line comments in case the linecomment formatting is enabled
- int foo3();
- // void commented() {
- // System.out.println("indented");
- // }
- // void indentedCommented() {
- // System.out.println("indented");
- // }
- /* block comment on first column */
- int bar();
- /*
- * These possibilities include:<ul><li>Formatting of header
- * comments.</li><li>Formatting of Javadoc tags</li></ul>
- */
- int bar2(); // This is along comment that should be split in multiple line
- // comments in case the linecomment formatting is enabled
- /**
- * The following is some sample code whichillustrates source formatting
- * within javadoc comments:
- *
- * <pre>
- * public class Example {
- * final int a = 1;
- *
- * final boolean b = true;
- * }
- * </pre>
- *
- * Descriptions of parameters and returnvalues are best appended at end of
- * the javadoc comment.
- *
- * @param a The first parameter. For an optimum result, this should be an
- * odd number between 0 and 100.
- * @param b The second parameter.
- * @return The result of the foo operation, usually within 0 and 1000.
- */
- int foo(int a, int b);
- }
- 注释每行长度是80个字符;
- 开启对Javadoc注释的格式化;
- 用html的TAG;
- 开启对‘pre’TAG里的Java代码片段进行格式化;
#37 ~ #43
- Javadoc TAG前面插入空白行;
#47是插入的行
- Javadoc Tag缩进
- § ‘@param’TAG后面的描述缩进
#49的odd相对#48的a缩进了4个空格。
- 不对‘@param’TAG插入新行;
#48和#50的描述与参数在同一行。
- ‘/**’和‘*/’在不同的行;
- 移除空白行;
Javadoc注释形式见#33~ #52
- 开启对块注释的格式化;
- ‘/*’和‘*/’在不同的行;
- 移除空白行;
块注释形式见#26~ #29
- 开启对行注释的格式化;
- 注释在行的第一列
#15, #16 和#17是行注释,且‘//’与原程序之间的空格仍旧保持。
- 关闭对头注释的格式化;
#1, #2和#3的头注释保持不变。
- 关闭对块注释缩进到第一列;
#23是块注释,与程序有相同的缩进,不是缩进到第一列。
- 关闭对行注释缩进到第一列;
注:笔者对行注释验证,发现Eclipse中无论如何设置,基本不会改变其行为。
十、Android中XML文件的格式化
前面讲了那么多都是针对Java程序的,Android中有大量的XML文件。对XML的格式也要进行排版格式化。
打开Window> Preferences,可以通过两个地方对XML文件进行格式化:
1) XML > XML Files > Editor
对其中的各项设置进行配置
2) Android > Editors
对其中的各项设置进行配置
总结
本文分析了Android编码风格在Eclipse环境中具体实施,通过对Eclipse环境的配置可以方便的格式化Android程序:Java文件和XML文件,特别是Java文件,其配置是基于JDT实现的,所以对Java的方方面面的配置都覆盖了。
但是,只有这些还不够,对一般的Java设计编码原则和Android中推荐的风格还不能完全自动执行,还需要人的参与,依赖于团队风格规范的制定,成员的设计能力和领悟执行能力。下面是这些工具所不能解决的风格和原则:
- 对Exception的处理;
- 写短小的方法;
- 域的命名规则;
- 程序块内的逻辑分组;
- 等等。
相关推荐
在软件开发过程中,代码规范的重要性不言而喻。它不仅有助于提高代码的可读性和可维护性,还能确保团队成员之间的代码风格一致,减少沟通成本。Java作为一种广泛使用的编程语言,同样强调代码规范。本篇文章将详细...
在MATLAB编程中,代码规范是提升代码可读性、可维护性和团队协作效率的关键因素。这份名为"Matlab之代码规范"的压缩包资源,包含了一份详细的MATLAB代码规范指南,以及相关的编程实例,旨在帮助程序员遵循最佳实践,...
在软件开发过程中,代码规范和模板的使用是至关重要的,它们能够提高代码的可读性、可维护性和团队协作效率。华为作为全球领先的ICT解决方案提供商,对于代码质量有着极高的要求,因此制定了一套详尽的代码规范。这...
阿里巴巴代码规范,又被称为阿里巴巴Java开发手册泰山版,是一份由阿里巴巴技术团队编写的、旨在规范Java开发者编程行为和提高代码质量的文档。该手册不仅关注编码细节,还涉及软件开发的多个方面,如异常处理、日志...
iOS 软件代码规范 iOS 软件代码规范是一份详细的编程规范,旨在指导 iOS 软件开发过程,提高代码质量和可维护性。这份规范涵盖了编程指引原则、布局、注释、命名规则、变量、常量、宏与类型、表达式与语句、函数、...
Java代码规范文档中涉及的知识点涵盖了Java编程实践中的命名风格和代码组织方式,旨在为Java开发人员提供一份行业内部开发的准则,确保代码的可读性、一致性和维护性。以下是从提供的文档内容中提炼出的相关知识点:...
单片机程序编写是电子工程和嵌入式系统开发中的重要环节,良好的代码规范对于项目的可维护性、可读性和团队协作至关重要。本工具旨在帮助开发者遵循一定的编码标准,提高代码质量,降低后期维护难度。以下是一些关于...
### 代码规范详解 #### 一、引言 在软件开发过程中,良好的代码规范对于确保项目的可维护性、可读性和一致性至关重要。本篇将基于《代码规范代码规范.txt》的内容,详细介绍其中提及的各项规范要点及其重要性。 #...
### 浅析框架与代码规范 #### 代码规范的重要性及实践方法 在现代软件开发过程中,代码规范扮演着至关重要的角色。它不仅有助于提高代码的可读性和可维护性,还能促进团队之间的协作效率,减少潜在的错误和缺陷。...
《华为代码规范-C C++开发》是一份详细指导C++和C语言开发人员遵循的编程准则,旨在提高代码质量、可读性和维护性。这份规范不仅适用于华为内部的开发项目,也对广大的C++和C开发者具有重要的参考价值。其中涵盖了从...
首先,标题为《代码规范.pdf》,这表明该文档是一份关于编程代码规范的文件,它很可能详述了在编写代码时应遵循的规则和标准。代码规范是为了统一开发人员的编码风格,提高代码的可读性、可维护性,从而确保项目的...
《阿里巴巴Java代码规范》是Java开发者们遵循的一套专业编程指南,旨在提高代码质量、可读性和维护性。这份规范由阿里巴巴集团内部的专家团队制定,经过多年的实践和完善,已经成为业界广泛参考的标准之一。以下是对...
前端代码规范
本篇文章将详细阐述C++代码规范,旨在提升团队协作效率,确保代码质量。 1. **命名规范**:C++中的变量、函数、类等标识符应遵循清晰、简洁的命名规则。推荐使用驼峰式命名(CamelCase)或下划线连接命名(snake_...
《阿里代码规范13213.pdf》是一个重要的资源,主要针对Java开发人员,旨在提供一套标准和指导原则,以确保代码的质量、可读性和可维护性。在Java开发过程中,遵循良好的编码规范至关重要,因为它有助于团队协作,...
Java代码规范是编程实践中至关重要的一个方面,它旨在确保代码的质量、可读性和维护性。以下是一些核心的Java代码规范要点: 1. **命名规范**: - 类名使用大驼峰命名法,所有单词首字母大写,例如`ClassName`。 ...
在前端开发领域,代码规范是确保团队协作效率、提高代码可读性和维护性的关键。"前端代码规范"这个压缩包文件很可能包含了一系列关于如何编写整洁、一致且易于理解的前端代码的指南。以下是对这些规范的一些核心内容...
这是借鉴、引用的是京东前端代码规范。
在编程世界中,代码规范是确保团队协作效率和软件质量的重要组成部分。对于Python这样的语言,遵循良好的代码规范可以使代码更具可读性、可维护性和一致性。"代码规范.zip"这个压缩包包含了多个版本的Python开发代码...
代码规范是编程实践中至关重要的部分,它不仅关乎代码的整洁性和可读性,还直接影响到软件的可维护性和团队合作的效率。以下是一些关键的代码规范要点: 1. **代码格式化**:保持代码的格式一致性是基本要求。对于...