这篇总结了 Google Java Style 的大概内容。代码风格的统一是很重要的事情，不一样的风格往往造成阅读上的不快。(自动格式化工具往往会造成意想不到的后果，慎用！)

1. 命名规范
2. 文件结构
3. 基本格式
4. 大括号
5. 空格
6. 数组和枚举
7. 其他

1. 命名规范

• 包名全小写字母 com.example.deepspace
• 类名使用大写开头的驼式命名 UpperCamelCase 比如：ImmutableList
• 方法名使用小写开头的驼式命名 lowerCamelCase 比如：sendMessage 或者 stop
• 常量使用大写+下划线组合 CONSTANT_CASE
• 函数参数使用小写开头驼式命名 indexOf(CharSequence s, char ch) {

2. 文件结构

• 文件名格式：HelloWorld.java
• 编码：UTF-8
• 空格取代Tab，空白字符一律用空格 0x20
• 文件结构如下，每个部分用空行分开，import按组空行分开
  1. License or copyright information, if present
  2. Package statement
  3. Import statements
  4. Exactly one top-level class

典型例子如下SparseArray.java：

/*
 * Copyright (C) 2006 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.util;

import com.android.internal.util.ArrayUtils;
import com.android.internal.util.GrowingArrayUtils;

import libcore.util.EmptyArray;

/**
 * SparseArrays map integers to Objects.  Unlike a normal array of Objects,
 * there can be gaps in the indices.  It is intended to be more memory efficient
 * than using a HashMap to map Integers to Objects, both because it avoids
 * auto-boxing keys and its data structure doesn't rely on an extra entry object
 * for each mapping.
 */
public class SparseArray<E> implements Cloneable {
}

3. 格式化

• 缩进2个空格(有待自定义)
• 单行最多一条语句
• 单行长度限制（Google是80~100字符，可以自定义）
• 分行代码，缩进4个空格(确实缩进了4个，显示有问题)

SharedPreferences.edit()
    .putBoolean("key_name1", true)
    .putInt("key_name2", "int value")
    .putFloat("key_name3", "float value")
    .commit();

4. 大括号

• 大括号采用 K&R风格 (Egyptian brackets) 大概是这样子：

if (a == b) {
    printf("hello");
}

• 大括号为空的时候保持简洁 void doNothing() {}

5. 空格

空格最复杂了,使用场景最多的还是for循环和函数定义&使用，记住下面的示例足矣：

    public static String join(CharSequence delimiter, Iterable tokens) {
        StringBuilder sb = new StringBuilder();
        boolean firstTime = true;
        for (Object token: tokens) {
            if (firstTime) {
                firstTime = false;
            } else {
                sb.append(delimiter);
            }
            sb.append(token);
        }
        return sb.toString();
    }

    public static String[] split(String text, String expression) {
        if (text.length() == 0) {
            return EMPTY_STRING_ARRAY;
        } else {
            return text.split(expression, -1);
        }
    }

前者展示函数定义和for循环的格式，后者有多参函数调用格式。

• if , for , catch , else ... 关键词前后需要加空格

if (a == b) {
  printf("hello");
}

• { 左大括号前面也要加空格，如上代码 if (a == b) {
• 两元或者三元操作符前后都要加空格，包括一些类似操作符的东东

int a = b > c ? 1 : 2;
<T extends Foo & Bar>
catch (FooException | BarException e)
for (Object token: tokens) {}

• ,:; 或者是 ) 之后

int count = segend - start;
for (int i = 0; i < count; i++) {
    if (temp[i] == ch) {
        recycle(temp);
        return i + start;
     }
}

• // 注释后面 char[] ELLIPSIS = { '\u2026' }; // this is "..."
• 类型定义，这个最常用 List<String> list

6. 数组、枚举类型

• 数组比较宽松，new int[] {5, 6} 和 new int[] { 5, 6 } 都是可以的
• 枚举 enum Suit { CLUBS, HEARTS, SPADES, DIAMONDS }
• 对于数组来说，可以写成多种形式方便理解

new int[] {           new int[] {
    0, 1, 2, 3            0,
}                       1,
                          2,
new int[] {             3,
      0, 1,             }
      2, 3
}                     new int[]
                            {0, 1, 2, 3}

• 不要写C-Style的数组声明比如 “String args[]在Java中[]`是类型的一部分

7. 其他

• swith 语句,贯穿的时候需要注释说明，基本缩进两个空格

switch (input) {
    case 1:
    case 2:
      prepareOneOrTwo();
      // fall through
    case 3:
      handleOneTwoOrThree();
      break;
    default:
      handleLargeNumber(input);
}

• 注释，下面各种风格都是OK的

/*
 * This is          // And so           /* Or you can
 * okay.            // is this.          * even do this. */
 */

• 修饰符顺序

public protected private abstract static final transient volatile synchronized native strictfp