java代码风格

1 java文件注释头
/***************************************
*该功能及特点描述（例如: 该类是用来……）
*
*该类未编译通过
*@see (与该类相关的类)：author.java
* 开发公司或单位或部门 ：××公司
* 版权 本文件版权归属 ×公司开发中心
*
* @author （作者）:name
* @since (该文件的jdk版本)
* @version(版本): 1.0
* @date （开发日期）：2008-10-11
* ◎lastModify(最后修改日期)：2008-11-13
* 修改人：name
* 复审人：name
* ************************************/
package java.util;

/**
* 进行必要的说明
*
* This class is a member of the
* <a href="{@docRoot}/../guide/collections/index.html">
* Java Collections Framework</a>.
*
* @author Josh Bloch
* @author Neal Gafter
* @version 1.50, 09/02/05
* @see Collection
* @see List
* @see LinkedList
* @see Vector
* @see Collections#synchronizedList(List)
* @since 1.2
* copy from jdk source
*/
2 方法与方法之间插入一个空白行
3 类和接口的声明规则：大写字母开头其他字母小写，如果由多个单词组成，则每个单词的首字母大写
4 类变量的声明顺序：先private ,protected ,public
5 方法的顺序：功能相似的方法放在一起
6 Java文件的编排格式
7 行间缩进一般用 4个空格或一个tab键（8个空格）
8 行长度：小于80个字符，一般是50～65个字符
9 拆行规则：
9.1 逗号后拆行
9.2 运算符号前拆行
9.3 拆下的代码应该和上行同等级的代码左对齐
9.4 如果代码右侧差距大并且混乱，可以在适当的用tab键
10 程序注释 块注释和行注释
11 块注释一般在方法前面
/*
*块注释
*1
* 2
* 3
*/
12 行注释
if ( true ){
/* 处理代码模块 */
}

if( I == 10){
return true; /* 注释 */
}else{
return false; /* 注释 */
}

if ( i>1 ){
// 对接下来的代码进行说明
}
13 变量的声明
14 Int level ; // 部门级别
15 Int size; //长度
16 不同的类型避免声明在同一行
17 避免底层的声明和高层的声明重复，赋值
18 程序语句编写规则
19 分支语句
19.1 单行也要添加{}
If ( condition){
Statements;
}
20 Try –catch-finally 结构的异常处理
21 空格的应用
21.1 关键字与括号之间
21.2 在参数列表中的逗号后面插入空格
21.3 myMethod(arg1, arg2, argn)
22 数学算式的操作数与运算符之间应该添加空格
22.1 x = x>>3;
23 for 语句中的表达式应该用逗号分开
24 空行的应用
24.1 两个方法之间
24.2 方法内部的本地变量与第一个语句之间
24.3 在块注释和单行注释之间
24.4 在方法内部的逻辑片段之间
25 方法，变量与常量的命名规则
25.1 方法命名
25.2 第一个字母小写，在多个单词混合的情况下，第一个单词后的所有单词的第一个字母大写，其余小写
25.3 在方法前有相应的注释
/**
* 必要的说明
*◎param message 系统参数信息
*/
Public void method(){
Statements;
}
26 变量的命名规则
26.1 第一个字母小写，在多个单词混合的情况下，第一个单词后的所有单词的第一个字母大写，其余小写
26.2 Static final 型的常量 全部用大写
java的内存管理
1 垃圾回收 避免用户频繁的进行垃圾回收
a) 堆内存 存放对象的实例与变量
i. 分为三个区域 伊甸园区(Eden), From 区域，To区域
ii. JVM做对象的区域转换的时候性能低下。
b) 栈内存 存放静态的方法
2 JVM中的对象生命周期
2.1 为对象分配存储空间
2.2 构造对象
2.3 递归调用其超类的构造方法
2.4 进行对象实例初始化与变量初始化
2.5 执行构造方法体
3 对象创建阶段
创建对象时候的几个关键的应用规则
1、在循环中初始化对象
For( int i = 0 ; i<sise ; i++){
Object obj = new Object();
} // 避免此情形

Object obj = null;
For( int i = 0 ; i<sise ; i++){
obj = new Object();
}
2、尽量及时的使对象复核垃圾回收标准
3、不要采用深层次的继承层次
4、访问本地变量优于访问类中的变量
5、不要同一对象初始化多次
4 应用阶段
4.1 强引用
4.2 软引用
4.2.1 软引用具有较强的，当内存不够的时候才被回收，通常都不回收。此外，在这些对象还能够在抛出 java.outOfMemery异常前被设置为null;
4.2.2 在处理一些占用内存较大而且声明周期较长，但是使用并不频繁的对象应该尽量应用该技术
4.2.3 在不合适的时候用该技术会影响性能
4.2.4 具体的代码
……
Import java.lang.ref.SoftReference;
A a = new A();
// 使用a
// 完了后 将它设置成softReference引用类型，释放强引用
SoftReference sr ＝ new SoftReference(a);
a = null;
// 下次使用时
If(sr != null){
a = sr.get();
}else{
// 这个时候可能已经回收了 a 的软引用
a = new A();
sr ＝ new SoftReference(a);

}
4.3 弱引用(weakReference)
4.3.1 对于该类型，GC总是进行回收
4.3.2 代码同上
……
Import java.lang.ref.Soft.WeakReference;
……
4.4 虚拟引用
4.4.1 很少用
5 不可视阶段
5.1 如果一个对象已使用完，而且在其他的区域内不再使用，此时应该主动将其设置为空 null;
6 不可到达阶段
6.1.1 JVM从根集合在也照不到直接或间接的强引用，通常是临时变量，已装载的类的静态变量或者对本地代码接口（JNI）的引用
6.1.2 此时的对象还不能够被JVM回收
7 可收集阶段，终结阶段，释放阶段
7.1 垃圾回收器发现该对象已经不可到达
7.2 Finalize方法已经执行
7.3 对象被置空
7.4 处于上面三中情况时，JVM就可以回收了。
8 Java中的析构方法 finalize
8.1 不要在类的构造器中创建，初始化大量的对象或执行复杂，耗时的运算

9 数组的创建
9.1 Int[] intArray = new int[1024]
9.2 Int[] intArray = obj.getIntArray(); 由系统分配合适的长度，适用于接受某个方法返回值为数组的情况。
9.3 如果数组较大 Object obj = new char[1000000]; 则可用软引用来处理
9.3.1 softReference ref = new SoftRefence();
10 共享静态变量的存储空间
10.1 静态变量在内存中只保留一份
10.2 在具备下列全部条件的情况下，尽量使用静态变量
10.2.1 变量所包含的对象体积较大，占内存较多
10.2.2 变量所包含的对象生命周期很长
10.2.3 变量所包含的对象数据稳定
10.2.4 该类的对象实例有该变量所包含的对象的共享需求
11 对象的重用和GC
11.1 对象池和JDBC连接池
11.2 System.gc(); 强制JVM进行垃圾回收
12 瞬时值
12.1 Transient 被声明为瞬时值的变量不会被传递
12.2 Java.lang.Serializable 了解
13 JVM内存参数调优
13.1

第三章 表达式、语句、关键字
3 表达式、语句、关键字
3.1 表达式
3.1.1 运用括号使代码清晰，增加可读性
3.1.2 字符串的比较 用 equals 方法
3.1.3 字符串驻留
3.1.4 Str = str.intern(); 经过驻留的字符串可以用 ＝＝来进行比较是否相等
3.2 Java中的关键字
3.2.1 静态的 static
3.2.1.1 静态代码块用来超前处理一些必要的初始化工作
² Static { …… }
3.2.1.2 静态变量的引用规则
² 非静态方法中引用静态的变量
² 在静态方法体中不能引用非静态变量
² 可在静态方法体中创建非静态变量
3.2.2 超类
3.2.3 最终类 final
3.2.3.1 最终类只保证被声明为final 类型的对象、变量本身不能改变，但是不能保证其内部不能修改
3.2.3.2 声明不可覆盖的方法
3.2.3.3 当一个方法被声明为 static final类型时可以提高JVM的系统效率
3.2.4 同步synchronized 合理利用同步
3.2.5 实例识别 (instanceof)
3.2.5.1 常用于util包中的对象识别
3.3 判断语句与循环
3.3.1 判断语句
3.3.1.1 注意不要写代码的死块
3.3.2 循环
3.3.2.1 不用循环copy大的数组，用System.arraycopy()
3.3.2.2 避免再循环体中调用方法（ 这个是不可能的 ）
3.3.2.3 用0值作为循环的终结条件，提高循环语句的性能
3.3.2.4 尽量在循环体外做判断操作
3.4 正则表达式
4 Java核心类与性能优化
4.1 散列表类与性能的优化
4.1.1 Vector 与arrayList
4.1.1.1 注意两者功能的区别和性能的差异
4.1.1.2 区分两者应用的场合
4.1.2 设置ArrayList的初始容量提高对象创建时的性能
4.1.3 ArrayList 与 LinkedList的
4.1.3.1 注意两者功能的区别和性能的差异
4.1.3.2 区分两者应用的场合
4.1.3.3 在按照顺序插入对象的时候但不会移动 ArrayList > LinkedList
4.1.3.4 若要移动对象的时候 LinkedList > ArrayList
4.1.3.5 查询对象 ArraryList > LinkedList
4.2 String类与性能优化
4.2.1 String 与StringBuffer
4.2.1.1 字符相加用StringBuffer代替String 的 “＋”运算提高性能

4.3 系统I/O类
4.3.1 输入流与输出流
4.3.1.1 用缓冲区减少文件读写次数，提高性能
4.3.1.2 I/O性能提高还有待仔细研究
4.3.1.3 默认的数据输入/输出 < 使用缓冲类 < 自定制合适的缓冲区的性能提升
4.3.2 使用数据压缩的方式提高性能
4.3.2.1 Java.util.zip.ZipInputStream
5 类与接口
5.1 类的构造器
5.1.1 构造器编写规则
避免在类中初始化其他的类，可能会引起类初始化的“链式反应”
类的继承层次不能太深
不要给构造器添加返回值
不要在构造器中初始化静态的变量，会引起反复的初始化静态变量
不要在类的构造器中创建类的实例，这样会引起严重的死循环
5.2 类的继承规则
尽量采用单线继承规则
包内部继承规则
内部类的继承规则（略）
继承与组合，优先使用组合
5.3 接口与抽象类

多重继承	可实现多个接口	单线继承原则
默认实现	没有	可以实现
常量定义	Public final 类型，一般不用	可以引用常量进行计算
功能区别	接口描述一个类的外部行为，不能隐藏内在的行为，实现接口的类必须实现接口中声明的方法。这些类没有一个特定的表示范围，也许它们之间也没有任何联系	抽象类定义了其核心的特征，扩展这个类都会具有这个特征，它的子类构成一个群体

在实际中，如果是属于关系就用抽象类，如果是角色分配关系就用接口

5.4 与性能有关的其他建议
5.4.1 避免复杂的构造过程
5.4.2 内部类的创建相对比一般的类要复杂、耗时。最好用非public的具体类代替
5.4.3 程序设计中尽量使用接口，接口的结构容易被交换
5.4.4 原数据类型的包装类要比使用原数据低效
5.4.5 通过 Class.forname()动态的装载类
6 多线程的优化
6.1 应用线程池
6.2 通常将线程池的大小设置成为最大并发访问量的近似值
6.3 其他没什么说的
7 JDBC性能优化
7.1 选择合适的驱动程序 ，首选JDBC驱动
7.2 合理的预取值
7.3 连接池结束
7.4 合理的事务
7.5 选择合适的事务隔离层与及时关闭连接对象
7.6 优化Statement对象
7.6.1 选择正确的Statement接口
7.6.1.1 Statement
² 创建和执行动态的SQL命令比较简单
² 每次执行SQL都要重新编译
² 执行单挑SQL语句的时候适用
7.6.1.2 PrepareStatement
² 成批的执行SQL
² 执行重复的SQL时候只编译一次
² 在有大量重复的SQL需要执行的时候
² 在有成批处理重复的插入或者更新操作时
² 执行成批或者大量重复的SQL时候适用
一般来将后者比前者效率要高

7.6.2 尽可能的执行批处理的操作
² Statement ，PrepareStatement ， CallableStatement三个对象执行批处理的用法一样
……
Statement stmt = null;
……
Stmt.addBatch(“ sql String 1 ”);
Stmt.addBatch(“ sql String 1 ”);
Stmt.addBatch(“ sql String 1 ”);
Stmt.executeBatch();
……
7.6.3 适当缓冲数据行
RS 的 setFetchSize() , getFetchSize()方法
ResultSet rs = ……
Rs. setFetchSize(100);
While( rs.next){
//处理数据
}
Rs.colse();
7.6.4 通过合适的getXXX()方法
² 对于数据库里面的数据才用相对应的getXXX();不要都使用getString()来代替，这样数据库会做相应的转换，在数据量很大的时候会影响性能
² 只取有用的数据，切忌取全部的数据来做挑选