田海立

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.14)中描述。
同一import分组内部按照字母次序排列。

二、缩进（Indentation）

2.1 总则

缩进只用空格，不用制表符（TAB）。缩进用4个空格，按下TAB键用4个空格代替。

2.2 示例代码

[java] view plain copy

/**
*Indentation
*/
classExample{
int[]myArray={
1,2,3,4,5,6
};
inttheInt=1;
StringsomeString="Hello";
doubleaDouble=3.0;
voidfoo(inta,intb,intc,intd,inte,intf){
switch(a){
case0:
Other.doFoo();
break;
default:
Other.doBaz();
}
}
voidbar(Listv){
for(inti=0;i<10;i++){
v.add(newInteger(i));
}
}
}
enumMyEnum{
UNDEFINED(0){
voidfoo(){
}
}
}
@interfaceMyAnnotation{
intcount()default1;
}

2.3 规则说明

1) 域不用对齐

若对齐的话，则myArray,theInt, someString和aDouble都在同一列上对齐。

2)类体内部的声明全都缩进

Class Example内的定义[#5 ~ #29]相对classExample[#4]都有缩进

3)枚举的声明要缩进

UNDEFINED(0) [#33]前面有缩进

4)枚举内的常量要缩进

voidfoo() [#34]前面有缩进

5)注解的声明要缩进

intcount()[#39]前面有缩进

6)方法/构造体内的语句要缩进

方法foo和bar内的语句[#16 ~ #22, #26 ~ #28]都有缩进

7)程序块内的语句要缩进

for循环内的v.add(newInteger(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 示例代码

[java] view plain copy

/**
*Braces
*/
interfaceEmpty{
}
enumMyEnum{
UNDEFINED(0){
voidfoo(){
}
}
}
@interfaceSomeAnnotationType{
}
classExample{
SomeClassfField=newSomeClass(){
};
int[]myArray={
1,2,3,4,5,6
};
int[]emptyArray=newint[]{};
Example(){
}
voidbar(intp){
for(inti=0;i<10;i++){
}
switch(p){
case0:
fField.set(0);
break;
case1:{
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 类

[java] view plain copy

classMyClassimplementsI0,I1,I2{
}
AnonClass=newAnonClass(){
voidfoo(Somes){
}
};

·类的左大括号的前面加空格；

·匿名类的左大括号的前面加空格；

·implements语句中逗号的前面，不加空格；

·implements语句中逗号的后面，加上空格；

4.1.2 域

[java] view plain copy

inta=0,b=1,c=2,d=3;

·多个域声明中逗号的前面，不加空格；

·多个域声明中逗号的后面，加上空格。

4.1.3 临时变量

[java] view plain copy

inta=0,b=1,c=2,d=3;

·多个临时变量声明中逗号的前面，不加空格；

·多个临时变量声明中逗号的后面，加上空格；

4.1.4 构造体

[java] view plain copy

MyClass()throwsE0,E1{
this(0,0,0);
}
MyClass(intx,inty,intz)throwsE0,E1{
super(x,y,z,true);
}

·左小括号的前面，不加空格；

·左小括号的后面，不加空格；

·右小括号的前面，不加空格；

·小括号内为空，则它们之间不加空格；

·左大括号前面，加上空格；

·参数列表中逗号之前，不加空格；

·参数列表中逗号之后，加上空格；

·throws语句中逗号之前，不加空格；

·throws语句中逗号之后，加上空格。

4.1.5 方法

[java] view plain copy

voidfoo()throwsE0,E1{
};
voidbar(intx,inty)throwsE0,E1{
}
voidformat(Strings,Object...args){
}

·左小括号的前面，不加空格；

·左小括号的后面，不加空格；

·右小括号的前面，不加空格；

·小括号内为空，则它们之间不加空格；

·左大括号前面，加上空格；

·参数列表中逗号之前，不加空格；

·参数列表中逗号之后，加上空格；

·可变参数列表省略号之前，不加空格；

·可变参数列表省略号之后，加上空格；

·throws语句中逗号之前，不加空格；

·throws语句中逗号之后，加上空格。

4.1.6 标号

[java] view plain copy

label:for(inti=0;i<list.length;i++){
for(intj=0;j<list[i].length;j++)
continuelabel;
}

·冒号之前，不加空格；

·冒号之后，加上空格

4.1.7 注解/Annotation

[java] view plain copy

@Annot(x=23,y=-3)
publicclassA{
}

·‘@’之后，不加空格；

·左小括号的前面，不加空格；

·左小括号的后面，不加空格；

·逗号前面，不加空格；

·逗号后面，加上空格；

·右小括号的前面，不加空格

4.1.8 枚举/Enumtypes

[java] view plain copy

enumMyEnum{
GREEN(0,1),RED(){
voidprocess(){
}
}
}

·声明中左大括号的前面[#1]，加上空格；

·常量之间的逗号[#2 RED前]前面，不加空格；

·常量之间的逗号[#2 RED前]后面，加上空格；

·常量参数的左小括号[#2 GREEN后]前面，不加空格；

·常量参数的左小括号[#2 GREEN后]后面，不加空格；

·常量参数的小括号[#2 RED后]中间为空，括号之间不加空格；

·常量参数之间的逗号[#2 GREEN()里面]前面，不加空格；

·常量参数之间的逗号[#2 GREEN()里面]后面，加上空格；

·常量参数的右小括号[#2 GREEN()后]前面，不加空格；

·常量体左大括号[#2 RED后]前面，加上空格。

4.1.9 注解类型/Annotationtypes

[java] view plain copy

@interfaceMyAnnotation{
Stringvalue();
}
@interfaceOtherAnnotation{
}

·‘@’之前，不加空格；

·‘@’之后，不加空格

·左大括号的前面，加上空格；

·注解类型成员的左小括号的前面，不加空格；

·注解类型成员的小括号的之间，不加空格；

4.2 控制语句

4.2.1 程序块

[java] view plain copy

if(true){
return1;
}else{
return2;
}

·左大括号前面，加上空格；

·右大括号后面，加上空格。

4.2.2 if else语句

[java] view plain copy

if(condition){
returnfoo;
}else{
returnbar;
}

·左小括号前加上空格；

·左小括号后不加空格；

·右小括号前不加空格【左大括号前的空格是规则#4.2.1】

4.2.3 for语句

[java] view plain copy

for(inti=0,j=array.length;i<array.length;i++,j--){
}
for(Strings:names){
}

·左小括号前加上空格；

·左小括号后不加空格；

·右小括号前不加空格【左大括号前的空格是规则#4.2.1】

·初始化语句的逗号前不加空格；

·初始化语句的逗号后加上空格

·增量语句的逗号前不加空格；

·增量语句的逗号后加上空格

·语句之间的分号前不加空格；

·语句之间的分号后加上空格；

·冒号前面加上空格；

·冒号后面加上空格。

4.2.4 switch语句

[java] view plain copy

switch(number){
caseRED:
returnGREEN;
caseGREEN:
returnBLUE;
caseBLUE:
returnRED;
default:
returnBLACK;
}

· case和default的冒号（‘:’）前不加空格；

·左括号（‘(’）和左大括号（‘{’）前都加上空格；

·左括号（‘(’）后和右括号（‘)’）前都不加空格。

4.2.5 while和dowhile语句

[java] view plain copy

while(condition){
}
;
do{
}while(condition);

·左括号前加上空格；

·左括号后不加空格；

·右括号前不加空格【#1左大括号前的空格是规则#4.2.1】

4.2.6 同步（synchronized）语句

[java] view plain copy

synchronized(list){
list.add(element);
}

·左括号前加上空格；

·左括号后不加空格；

·右括号前不加空格【左大括号前的空格是规则#4.2.1】

4.2.7 catch语句

[java] view plain copy

try{
number=Integer.parseInt(value);
}catch(NumberFormatExceptione){
}

·左括号前加上空格；

·左括号后不加空格；

·右括号前不加空格【左大括号前的空格是规则#4.2.1】

4.2.8 assert语句

[java] view plain copy

assertcondition:reportError();

冒号前后都加上空格

4.2.9 return语句

[java] view plain copy

return(o);

括号表达式前加上空格

4.2.10 throw语句

[java] view plain copy

throw(e);

括号表达式前加上空格

4.3 表达式

4.2.1 函数调用

[java] view plain copy

foo();
bar(x,y);
Stringstr=newString();
Pointpoint=newPoint(x,y);
MyClass()throwsE0,E1{
this(0,0,0);
}
MyClass(intx,inty,intz)throwsE0,E1{
super(x,y,z,true);
}

·左括号的前后都不加空格；

·右括号前不加空格；

·空的参数的左右括号之间不加空格；

·方法调用时多个参数之间分割的逗号前面不加空格，逗号后面加空格；

·对象申请时多个参数之间分割的逗号前面不加空格，逗号后面加空格；

·显示调用构造函数时多个参数之间分割的逗号前面不加空格，逗号后面加空格；

4.3.2 赋值

[java] view plain copy

Listlist=newArrayList();
inta=-4+-9;
b=a++/--number;
c+=4;
booleanvalue=true&&false;

赋值操作（=）前后都加上空格。【注意：‘+=’是一个操作数】

4.3.3 操作数

[java] view plain copy

Listlist=newArrayList();
inta=-4+-9;
b=a++/--number;
c+=4;
booleanvalue=true&&false;

·二元操作（#2的‘+’；#3的‘/’；#5的‘&&’）前后都加上空格；

·一元操作（#2 ‘4’和‘9’前面的‘-’）前后都不加空格【示例中‘-’前的空格不是这个规则里的】；

·前置操作的（#3的‘--number’）前后都不加空格【示例中‘--’前的空格不是这个规则里的】；

·后置操作的（#3的‘a++’）前后都不加空格【示例中‘++’后的空格不是这个规则里的】。

4.3.4 加括号的表达式

[java] view plain copy

result=(a*(b+c+d)*(e+f));

左括号前，左括号后和右括号前都不加空格【示例中左括号前的空格不是这个规则里的】

4.3.5 类型转换

[java] view plain copy

Strings=((String)object);

·右括号后加上空格；

·左括号后和右括号前都不加空格。

4.3.6 三元条件表达式

[java] view plain copy

Stringvalue=condition?TRUE:FALSE;

问号前，问号后，冒号前，冒号后都要加上空格

4.4 数组

[java] view plain copy

int[]array0=newint[]{};
int[]array1=newint[]{
1,2,3
};
int[]array2=newint[3];
array[i].foo();

4.4.1 声明

·左中括号前不加空格；

·左右中括号中间不加空格

示例中：arrayX前的‘[]’

4.4.2 申请

·左中括号前后都不加空格；

·右中括号前不加空格；

·空的左右中括号中间不加空格；

示例中：等号‘=’后面的‘[]’

4.4.3 初始化体

·左大括号前后都加上空格；

·右大括号前加上空格；

·逗号前不加空格；

·逗号后加上空格；

·空的大括号中间不加空格

4.4.4 数组元素的访问

·左中括号前后都不加空格；

·右中括号前面不加空格

4.5 泛型

[java] view plain copy

Map<String,Element>map=newHashMap<String,Element>();
x.<String,Element>foo();
classMyGenericType<S,TextendsElement&List>{
}
Map<X<?>,Y<?extendsK,?superV>>t;

五、空白行（BlankLines）

5.1 示例代码

[java] view plain copy

/**
*BlankLines
*/
packagefoo.bar.baz;
importjava.util.List;
importjava.util.Vector;
importjava.net.Socket;
publicclassAnother{
}
publicclassExample{
publicstaticclassPair{
publicStringfirst;
publicStringsecond;
//Betweenhere...
//...andhereare10blanklines
};
privateLinkedListfList;
publicintcounter;
publicExample(LinkedListlist){
fList=list;
counter=0;
}
publicvoidpush(Pairp){
fList.add(p);
++counter;
}
publicObjectpop(){
--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 示例代码

[java] view plain copy

/**
*NewLines
*/
publicclassEmpty{
}
classExample{
staticint[]fArray={
1,2,3,4,5
};
ListenerfListener=newListener(){
};
@Deprecated
@Override
publicvoidbar(@SuppressWarnings("unused")inti){
@SuppressWarnings("unused")
intk;
}
voidfoo(){
;
;
label:do{
}while(false);
for(;;){
}
}
}
enumMyEnum{
UNDEFINED(0){
}
}
enumEmptyEnum{
}
@interfaceEmptyAnnotation{
}

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 示例代码

[java] view plain copy

/**
*If...else
*/
classExample{
voidbar(){
do{
}while(true);
try{
}catch(Exceptione){
}finally{
}
}
voidfoo2(){
if(true){
return;
}
if(true){
return;
}elseif(false){
return;
}else{
return;
}
}
voidfoo(intstate){
if(true)
return;
if(true)
return;
elseif(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）

[java] view plain copy

/**
*Element-valuepairs
*/
@MyAnnotation(value1="thisisanexample",value2="ofanannotation",value3="withseveralarguments",value4="byHailiTIAN(haili.tian@gmail.com)")
classExample{
}

注解不换行：value1、value2、value3和value4都在同一行上。

8.3 类声明

[java] view plain copy

/**
*'extends'clause
*/
classExampleextends
OtherClass{
}
/**
*'implements'clause
*/
classExampleimplementsI1,
I2,I3{
}

extends子句在需要换行的地方，用缺省换行方式换行：#5OtherClass处换行，且OtherClass相对class缩进了8个空格；
implements子句在需要换行的地方，用缺省换行方式换行：#12I2处换行，且I2相对class缩进了8个空格。

8.4 构造体声明

[java] view plain copy

/**
*Parameters
*/
classExample{
Example(intarg1,intarg2,
intarg3,intarg4,
intarg5,intarg6){
this();
}
Example(){
}
}
/**
*'throws'clause
*/
classExample{
Example()throwsFirstException,
SecondException,
ThirdException{
returnOther.doSomething();
}
}

构造体的参数在需要换行的地方，用缺省换行方式换行：参数[#6 &#7]相对Example[#5]缩进了8个空格；
构造体throws子句在需要换行的地方，用缺省换行方式换行：子句[#20& #21]相对Example[#19]缩进了8个空格。

8.5 方法声明

[java] view plain copy

/**
*Declaration
*/
classExample{
publicfinalsynchronizedjava.lang.Stringa_method_with_a_long_name(){
}
}
/**
*Parameters
*/
classExample{
voidfoo(intarg1,intarg2,
intarg3,intarg4,
intarg5,intarg6){
}
}
/**
*'throws'clause
*/
classExample{
intfoo()throwsFirstException,
SecondException,
ThirdException{
returnOther.doSomething();
}
}

方法声明处不换行：#5 很长，但不分行；
方法声明处的参数在需要换行的地方，用缺省换行方式换行：参数[#14& #15]相对voidfoo [#13]缩进了8个空格；
方法声明处的throws子句在需要换行的地方，用缺省换行方式换行：子句[#24& #25]相对intfoo [#23]缩进了8个空格。

8.6 枚举声明

[java] view plain copy

/**
*Constants
*/
enumExample{
CANCELLED,RUNNING,WAITING,FINISHED
}
enumExample{
GREEN(0,255,0),RED(
255,0,0)
}
/**
*'implements'clause
*/
enumExampleimplementsA,B,
C{
}
/**
*Constantarguments
*/
enumExample{
GREEN(0,255,0),RED(
255,0,0)
}

枚举常量定义的地方，不换行：#5不换行；
implements子句在需要换行的地方，用缺省换行方式换行：#17 C处换行，且C相对enum缩进了8个空格；
常量参数在需要换行的地方，用缺省换行方式换行：#10 和#25处换行，且相对GREEN缩进了8个空格。

8.7 函数调用

[java] view plain copy

/**
*Arguments
*/
classExample{
voidfoo(){
Other.bar(
100,
nested(200,300,400,
500,600,700,
800,900));
}
}
/**
*Qualifiedinvocations
*/
classExample{
intfoo(Somea){
returna.getFirst();
}
}
/**
*Explicitconstructorinvocations
*/
classExampleextendsAnotherClass{
Example(){
super(100,200,300,400,500,
600,700);
}
}
/**
*Objectallocationarguments
*/
classExample{
SomeClassfoo(){
returnnewSomeClass(100,200,
300,400,500,600,
700,800,900);
}
}
/**
*Qualifiedobjectallocationarguments
*/
classExample{
SomeClassfoo(){
returnSomeOtherClass.newSomeClass(
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 表达式

[java] view plain copy

/**
*Binaryexpressions
*/
classExampleextendsAnotherClass{
intfoo(){
intsum=100+200+300+400
+500+600+700+800;
intproduct=1*2*

Eclipse环境下格式化Android的代码风格

一、Import的次序

二、缩进（Indentation）

2.1 总则

2.2 示例代码

2.3 规则说明

三、大括号（Braces）的位置

3.1 示例代码

3.2 规则说明

四、空格（White Space）

4.1 声明

4.1.1 类

4.1.2 域

4.1.3 临时变量

4.1.4 构造体

4.1.5 方法

4.1.6 标号

4.1.7 注解/Annotation

4.1.8 枚举/Enumtypes

4.1.9 注解类型/Annotationtypes

4.2 控制语句

4.2.1 程序块

4.2.2 if else语句

4.2.3 for语句

4.2.4 switch语句

4.2.5 while和dowhile语句

4.2.6 同步（synchronized）语句

4.2.7 catch语句

4.2.8 assert语句

4.2.9 return语句

4.2.10 throw语句

4.3 表达式

4.2.1 函数调用

4.3.2 赋值

4.3.3 操作数

4.3.4 加括号的表达式

4.3.5 类型转换

4.3.6 三元条件表达式

4.4 数组

4.4.1 声明

4.4.2 申请

4.4.3 初始化体

4.4.4 数组元素的访问

4.5 泛型

五、空白行（BlankLines）

5.1 示例代码

5.2 规则说明

5.2.1 编译单元之间的空白行

5.2.2 类内部的空白行

六、插入新行（NewLines）

6.1 示例代码

6.2 规则说明

6.2.1 插入新行

6.2.2 数组初始化

6.2.3 空的语句

6.2.4 注解

七、控制语句（ControlStatements）

7.1 示例代码

7.2 规则说明

八、换行（LineWrapping）

8.1 总则

8.2 注解（Annotation）

8.3 类声明

8.4 构造体声明

8.5 方法声明

8.6 枚举声明

8.7 函数调用

8.8 表达式

更多相关文章

随机推荐