> 怎么写出高效的java代码
怎么写出高效的java代码
maxitong & &
发布时间： & &
浏览：21 & &
回复：0 & &
悬赏：0.0希赛币
如何写出高效的java代码
最近的机器内存又爆满了，除了新增机器内存外，还应该好好review一下我们的代码，有很多代码编写过于随意化，这些不好的习惯或对程序语言的不了解是应该好好打压打压了。 下面是参考网络资源总结的一些在Java编程中尽可能要做到的一些地方。1. 尽量在合适的场合使用单例 使用单例可以减轻加载的负担，缩短加载的时间，提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面：第一，控制资源的使用，通过线程同步来控制资源的并发访问；第二，控制实例的产生，以达到节约资源的目的；第三，控制数据共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信。2. 尽量避免随意使用静态变量 要知道，当某个对象被定义为stataic变量所引用，那么gc通常是不会回收这个对象所占有的内存，如Java代码 1.public class A{&& 2.static B b = new B();&& 3.}& public class A{static B b = new B();} 此时静态变量b的生命周期与A类同步，如果A类不会卸载，那么b对象会常驻内存，直到程序终止。3. 尽量避免过多过常的创建Java对象 尽量避免在经常调用的方法，循环中new对象，由于系统不仅要花费时间来创建对象，而且还要花时间对这些对象进行垃圾回收和处理，在我们可以控制的范围内，最大限度的重用对象，最好能用基本的数据类型或数组来替代对象。4. 尽量使用final修饰符 带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了使用者覆盖length()方法。另外，如果一个类是final的，则该类所有方法都是final的。Java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50%。5. 尽量使用局部变量 调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。6. 尽量处理好包装类型和基本类型两者的使用场所 虽然包装类型和基本类型在使用过程中是可以相互转换，但它们两者所产生的内存区域是完全不同的，基本类型数据产生和处理都在栈中处理，包装类型是对象，是在堆中产生实例。在集合类对象，有对象方面需要的处理适用包装类型，其他的处理提倡使用基本类型。7. 慎用synchronized，尽量减小synchronize的方法 都知道，实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。synchronize方法被调用时，直接会把当前对象锁 了，在方法执行完之前其他线程无法调用当前对象的其他方法。所以synchronize的方法尽量小，并且应尽量使用方法同步代替代码块同步。8. 尽量使用StringBuilder和StringBuffer进行字符串连接 这个就不多讲了。9. 尽量不要使用finalize方法实际上，将资源清理放在finalize方法中完成是非常不好的选择，由于GC的工作量很大，尤其是回收Young代内存时，大都会引起应用程序暂停，所以再选择使用finalize方法进行资源清理，会导致GC负担更大，程序运行效率更差。10. 尽量使用基本数据类型代替对象 String str = "hello";上面这种方式会创建一个“hello”字符串，而且JVM的字符缓存池还会缓存这个字符串；String str = new String("hello");此时程序除创建字符串外，str所引用的String对象底层还包含一个char[]数组，这个char[]数组依次存放了h,e,l,l,o11. 单线程应尽量使用HashMap、ArrayList HashTable、Vector等使用了同步机制，降低了性能。12. 尽量合理的创建HashMap 当你要创建一个比较大的hashMap时，充分利用另一个构造函数public HashMap(int initialCapacity, float loadFactor)避免HashMap多次进行了hash重构,扩容是一件很耗费性能的事，在默认中initialCapacity只有16，而loadFactor是 0.75，需要多大的容量，你最好能准确的估计你所需要的最佳大小，同样的Hashtable，Vectors也是一样的道理。13. 尽量减少对变量的重复计算 如for(int i=0;i&list.size();i++)应该改为for(int i=0,len=list.size();i&i++)并且在循环中应该避免使用复杂的表达式，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。 14. 尽量避免不必要的创建 如A a = new A();if(i==1){list.add(a);}应该改为if(i==1){A a = new A();list.add(a);}15. 尽量在finally块中释放资源 程序中使用到的资源应当被释放，以避免资源泄漏。这最好在finally块中去做。不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。 16. 尽量使用移位来代替'a/b'的操作 "/"是一个代价很高的操作，使用移位的操作将会更快和更有效如int num = a / 4;int num = a / 8;应该改为int num = a $>$ 2;int num = a $>$ 3;但注意的是使用移位应添加注释，因为移位操作不直观，比较难理解17.尽量使用移位来代替'a*b'的操作 同样的，对于'*'操作，使用移位的操作将会更快和更有效如int num = a * 4;int num = a * 8;应该改为int num = a $<$ 2;int num = a $<$ 3;18. 尽量确定StringBuffer的容量 StringBuffer 的构造器会创建一个默认大小（通常是16）的字符数组。在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再 丢弃旧的数组。在大多数情况下，你可以在创建 StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。 如：StringBuffer buffer = new StringBuffer(1000);& 19. 尽量早释放无用对象的引用 大部分时，方法局部引用变量所引用的对象 会随着方法结束而变成垃圾，因此，大部分时候程序无需将局部，引用变量显式设为null。例如：Java代码 1.Public void test(){&& 2.Object obj = new Object();&& 3.……&& 4.Obj=&& 5.}& Public void test(){Object obj = new Object();……Obj=} 上面这个就没必要了，随着方法test()的执行完成，程序中obj引用变量的作用域就结束了。但是如果是改成下面：Java代码 1.Public void test(){&& 2.Object obj = new Object();&& 3.……&& 4.Obj=&& 5.//执行耗时，耗内存操作；或调用耗时，耗内存的方法&& 6.……&& 7.}& Public void test(){Object obj = new Object();……Obj=//执行耗时，耗内存操作；或调用耗时，耗内存的方法……} 这时候就有必要将obj赋值为null，可以尽早的释放对Object对象的引用。20. 尽量避免使用二维数组 二维数据占用的内存空间比一维数组多得多，大概10倍以上。21. 尽量避免使用split 除非是必须的，否则应该避免使用split，split由于支持正则表达式，所以效率比较低，如果是频繁的几十，几百万的调用将会耗费大量资源，如果确实需 要频繁的调用split，可以考虑使用apache的StringUtils.split(string,char)，频繁split的可以缓存结果。22. ArrayList & LinkedList 一 个是线性表，一个是链表，一句话，随机查询尽量使用ArrayList，ArrayList优于LinkedList，LinkedList还要移动指 针，添加删除的操作LinkedList优于ArrayList，ArrayList还要移动数据，不过这是理论性分析，事实未必如此，重要的是理解好2 者得数据结构，对症下药。23. 尽量使用System.arraycopy ()代替通过来循环复制数组 System.arraycopy() 要比通过循环来复制数组快的多 24. 尽量缓存经常使用的对象 尽可能将经常使用的对象进行缓存，可以使用数组，或HashMap的容器来进行缓存，但这种方式可能导致系统占用过多的缓存，性能下降，推荐可以使用一些第三方的开源工具，如EhCache，Oscache进行缓存，他们基本都实现了FIFO/FLU等缓存算法。25. 尽量避免非常大的内存分配 有时候问题不是由当时的堆状态造成的，而是因为分配失败造成的。分配的内存块都必须是连续的，而随着堆越来越满，找到较大的连续块越来越困难。26. 慎用异常 当创建一个异常时，需要收集一个栈跟踪(stack track)，这个栈跟踪用于描述异常是在何处创建的。构建这些栈跟踪时需要为运行时栈做一份快照，正是这一部分开销很大。当需要创建一个 Exception 时，JVM 不得不说：先别动，我想就您现在的样子存一份快照，所以暂时停止入栈和出栈操作。栈跟踪不只包含运行时栈中的一两个元素，而是包含这个栈中的每一个元素。如 果您创建一个 Exception ，就得付出代价。好在捕获异常开销不大，因此可以使用 try-catch 将核心内容包起来。从技术上讲，您甚至可以随意地抛出异常，而不用花费很大的代价。招致性能损失的并不是 throw 操作——尽管在没有预先创建异常的情况下就抛出异常是有点不寻常。真正要花代价的是创建异常。幸运的是，好的编程习惯已教会我们，不应该不管三七二十一就 抛出异常。异常是为异常的情况而设计的，使用时也应该牢记这一原则。相关回复： xuanyuan 写道7.慎用synchronized，尽量减小synchronize的方法re：同意，不过文中有个地方说错了，使用synchronized关键字并不一定都是锁定当前对象的，要看具体的锁是什么。如果是在方法上加的synchronized，则是以对象本身为锁的，如果是静态方法则锁的粒度是类。---------------9.尽量不要使用finalize方法re：同意，其实不推荐用finalize方法的根本原因在于，JVM的规范并不保证何时执行该方法，所以用这个方法来释放资源很不合适，有可能造成长时间资源得不到释放。---------------16.尽量使用移位来代替'a/b'的操作；17.尽量使用移位来代替'a*b'的操作re：个人不太同意这两条。这样做确实有更好的性能，但是却牺牲了可读性。这两个操作符对很多程序员来说并不直观。我认为在如今硬件价格不那么昂贵的情况下，略微牺牲一些性能，换来更好的可读性和可维护性是好的选择。 wuzhengju 写道19.尽量早释放无用对象的引用 大部分时，方法局部引用变量所引用的对象 会随着方法结束而变成垃圾，因此，大部分时候程序无需将局部，引用变量显式设为null。 例如： Public void test(){ Object obj = new Object(); …… Obj= } 上面这个就没必要了，随着方法test()的执行完成，程序中obj引用变量的作用域就结束了。但是如果是改成下面：Public void test(){ Object obj = new Object(); …… Obj= //执行耗时，耗内存操作；或调用耗时，耗内存的方法 …… } 如果Object obj = new Object(); 如果这对象并不是大对象，这有必要吗？Obj=只是告诉jvm这个对象已经成为垃圾，至于什么时候回收，还不能确定！ 这可读性也不好！
本问题标题：
本问题地址：
温馨提示：本问题已经关闭，不能解答。
暂无合适的专家
&&&&&&&&&&&&&&&
希赛网 版权所有 & &&Java进阶之 如何自动生成代码
一、前言：为什么要有代码的自动生成？
对于这个问题 最简洁直接的回答就是：代替手动编写代码、提高工作效率。
什么样的场景和代码适合用自动生成这种方式呢？
做过服务端的朋友一定都知道代码中我们需要编写与表映射的Java实体类（Entity）、需要编写与实体对应的DAO类（XxDao.java类中有包含对应实体的增、删、改、查基本操作）。在这些实体类中通常都是一些属性方法以及属性对应的get/set方法、而实体对应的DAO类中也基本会包含有增、删、改、查这些与数据库操作相关的方法。在编写了那么多的实体类和Dao类的过程中 你是否发现了这些代码中有很多地方都相似或者差不多、只是名字不同而已呢？对、那么这个时候其实我们可以定义一个模板、通过模板我们来让代码自动生成去吧。
二、FreeMarker的简单介绍
在进入正文前，让我们首先简单、快速了解一下FreeMarker。
（做过Web开发的朋友肯定都是相当熟悉的、小吕当时 也是在做Web开发的时候第一次接触了FreeMarker）
1、概述：FreeMarker是一款模板引擎：即一种基于模板、用来生成输出文本的通用工具。更多的是被用来设计生成HTML页面。
简单说就是：FreeMarker是使用模板生成文本页面来呈现已经准备好的数据。如下图表述
FreeMarker官网：http://freemarker.org/
2、通过一个简单的例子来展示如何使用FreeMarker定义模板、绑定模型数据、生成最终显示的Html页面：
1&.新建项目 在项目根目录下新建template文件夹，用来存放我们的Template file,
如我们新建模板文件test.ftl 内容如下：
Welcome ${user}&#if user == Big Joe&, our beloved leader!
Our latest product: !
2&.项目引入freemarker.jar（下载地址：/freemarker.html），
在Java类中使用FreeMarker API方法引用模板文件、创建数据模型、合并数据模型与模板文件最终输入，
代码如下：
import java.io.F
import java.io.IOE
import java.io.OutputStreamW
import java.io.W
import java.util.HashM
import java.util.M
import freemarker.template.C
import freemarker.template.DefaultObjectW
import freemarker.template.T
import freemarker.template.TemplateE
public class HtmlGeneratorClient {
public static void main(String[] args) {
Configuration cfg = new Configuration();
// 指定模板文件从何处加载的数据源，这里设置成一个文件目录
cfg.setDirectoryForTemplateLoading(new File(./template));
cfg.setObjectWrapper(new DefaultObjectWrapper());
// 获取或创建模板
Template template = cfg.getTemplate(test.ftl);
// 创建数据模型
Map root = new HashMap();
root.put(user, Big Joe);
Map latest = new HashMap();
root.put(latestProduct, latest);
latest.put(url, http://blog.csdn.net/janice0529/article/details/products/greenmouse.html);
latest.put(name, green mouse);
// 将模板和数据模型合并 输出到Console
Writer out = new OutputStreamWriter(System.out);
template.process(root, out);
out.flush();
} catch (IOException e) {
e.printStackTrace();
} catch (TemplateException e) {
e.printStackTrace();
3&.最终生成的HTML的页面代码如下：
Welcome Big Joe, our beloved leader!
Our latest product: !
三、如何使用FreeMerker完成Java类代码的自动生成
上面示例 我们的ftl模板文件定义的是HTML页面模板，那么我们将ftl模板定义为Java代码呢 通过数据模板的绑定不就可以生成Java类啦，
下面小吕将利用模板来自动创建实体对象的java类（编写实体类的模板文件相对逻辑简单，但简单归简单，最重要的还是我们要掌握它的思想）
1、属性类型的枚举类 PropertyType.java
* 属性类型枚举类
public enum PropertyType {
Byte, Short, Int, Long, Boolean, Float, Double, String, ByteArray, Date
2、实体对应的字段属性类 Property.java
* 实体对应的属性类
public class Property {
// 属性数据类型
private String javaT
// 属性名称
private String propertyN
private PropertyType propertyT
public String getJavaType() {
return javaT
public void setJavaType(String javaType) {
this.javaType = javaT
public String getPropertyName() {
return propertyN
public void setPropertyName(String propertyName) {
this.propertyName = propertyN
public PropertyType getPropertyType() {
return propertyT
public void setPropertyType(PropertyType propertyType) {
this.propertyType = propertyT
3、实体模型类 Entity.java
import java.util.L
public class Entity {
// 实体所在的包名
private String javaP
// 实体类名
private String classN
// 属性集合
// 是否有构造函数
public String getJavaPackage() {
return javaP
public void setJavaPackage(String javaPackage) {
this.javaPackage = javaP
public String getClassName() {
return classN
public void setClassName(String className) {
this.className = classN
public String getSuperclass() {
public void setSuperclass(String superclass) {
this.superclass =
public List getProperties() {
public void setProperties(List properties) {
this.properties =
public boolean isConstructors() {
public void setConstructors(boolean constructors) {
this.constructors =
4、在项目根目录下新建template文件夹，用来存放我们的Template file, 新建实体模板entity.ftl 内容如下：
package ${entity.javaPackage};
* This code is generated by FreeMarker
* @author lvzb.
public class ${entity.className}&#if entity.superclass?has_content& extends ${entity.superclass}
/********** attribute ***********/
&#list entity.properties as property&
private ${property.javaType} ${property.propertyName};
/********** constructors ***********/
&#if entity.constructors&
public ${entity.className}() {
public ${entity.className}(&#list entity.properties as property&${property.javaType} ${property.propertyName}&#if property_has_next&, ) {
&#list entity.properties as property&
this.${property.propertyName} = ${property.propertyName};
/********** get/set ***********/
&#list entity.properties as property&
public ${property.javaType} get${property.propertyName?cap_first}() {
return ${property.propertyName};
public void set${property.propertyName?cap_first}(${property.javaType} ${property.propertyName}) {
this.${property.propertyName} = ${property.propertyName};
5、自动生成实体类 客户端代码 EntityGeneratorClient.java
import java.io.F
import java.io.FileW
import java.io.IOE
import java.io.OutputStreamW
import java.io.W
import java.util.ArrayL
import java.util.HashM
import java.util.L
import java.util.M
import freemarker.template.C
import freemarker.template.DefaultObjectW
import freemarker.template.T
import freemarker.template.TemplateE
* 自动生成实体类客户端
* @author lvzb.
public class EntityGeneratorClient {
private static File javaFile =
public static void main(String[] args) {
Configuration cfg = new Configuration();
// 步骤一：指定 模板文件从何处加载的数据源，这里设置一个文件目录
cfg.setDirectoryForTemplateLoading(new File(./template));
cfg.setObjectWrapper(new DefaultObjectWrapper());
// 步骤二：获取 模板文件
Template template = cfg.getTemplate(entity.ftl);
// 步骤三：创建 数据模型
Map root = createDataModel();
// 步骤四：合并 模板 和 数据模型
// 创建.java类文件
if(javaFile != null){
Writer javaWriter = new FileWriter(javaFile);
template.process(root, javaWriter);
javaWriter.flush();
System.out.println(文件生成路径： + javaFile.getCanonicalPath());
javaWriter.close();
// 输出到Console控制台
Writer out = new OutputStreamWriter(System.out);
template.process(root, out);
out.flush();
out.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TemplateException e) {
e.printStackTrace();
* 创建数据模型
private static Map createDataModel() {
Map root = new HashMap();
Entity user = new Entity();
user.setJavaPackage(com.study.entity); // 创建包名
user.setClassName(User);
// 创建类名
user.setConstructors(true); // 是否创建构造函数
// user.setSuperclass(person);
List propertyList = new ArrayList();
// 创建实体属性一
Property attribute1 = new Property();
attribute1.setJavaType(String);
attribute1.setPropertyName(name);
attribute1.setPropertyType(PropertyType.String);
// 创建实体属性二
Property attribute2 = new Property();
attribute2.setJavaType(int);
attribute2.setPropertyName(age);
attribute2.setPropertyType(PropertyType.Int);
propertyList.add(attribute1);
propertyList.add(attribute2);
// 将属性集合添加到实体对象中
user.setProperties(propertyList);
// 创建.java类文件
File outDirFile = new File(./src-template);
if(!outDirFile.exists()){
outDirFile.mkdir();
javaFile = toJavaFilename(outDirFile, user.getJavaPackage(), user.getClassName());
root.put(entity, user);
* 创建.java文件所在路径 和 返回.java文件File对象
* @param outDirFile 生成文件路径
* @param javaPackage java包名
* @param javaClassName java类名
private static File toJavaFilename(File outDirFile, String javaPackage, String javaClassName) {
String packageSubPath = javaPackage.replace(&#39;.&#39;, &#39;/&#39;);
File packagePath = new File(outDirFile, packageSubPath);
File file = new File(packagePath, javaClassName + .java);
if(!packagePath.exists()){
packagePath.mkdirs();
6、运行程序 我们将会在项目根目录下 生成文件夹 src-template以及自动生成的实体类User.java
效果图如下：
--- 运行后 ---&
&程序运行前目录结构& &程序运行后目录结构&
自动生成的实体类User.java 代码如下：
package com.study.
* This code is generated by FreeMarker
* @author lvzb.
public class User
/********** attribute ***********/
/********** constructors ***********/
public User() {
public User(String name, int age) {
this.name =
this.age =
/********** get/set ***********/
public String getName() {
public void setName(String name) {
this.name =
public int getAge() {
public void setAge(int age) {
this.age =
四、背后的思考
通过上面两个简单的示例我们了解到所谓的自动生成代码其实就是：
1、定义java类模板文件 2、定义模板数据 3、引用模板文件（.ftl）与模板数据合并生成Java类。
上面的示例中 有的朋友可能会问不就是要编写一个实体对象吗？干嘛搞那么麻烦、又建.ftl文件、又写了那么多类、定义模板数据的过程也是那么麻烦、我还不如手动去写、声明几个属性、set/get快捷键一下子就编写好啦。 真的是这样吗？
从一个辅助工具和软件架构的方面去思考，假设做成一个开发的辅助工具或是插件去完成实体类和对应DAO类的自动生成。假设需要建10个实体类和对应含有增删改查基本操作的DAO类。我在C/S客户端上填写包名、类名、属性字段等信息 然后一键生成，想想那是多么爽、多么痛快的一件事（当然 前提是你的模板类要编写的非常强大、通用），而你也许还在不停的 Ctrl+C、Ctrl+V。
关于如何编写.ftl模板文件、就需要自己去翻阅资料自我学习啦！Java&程序代码书写风格及一些简单的注意事项
1.&风格务必保持一贯性(Consistent)
一位同胞顶着我的鼻子问，为什么我们的Java代码缩进格式非得是这样，而不能是他那样，他就是喜欢他自己的这一种，因此他写的代码总是用他自己习惯的风格。结果在Code
Review里被大家毙掉，责令修改。因此他是大大地不服。就是风格一贯性问题。其实他的风格，本来也没有什么问题，但在项目里，和其他程序员的程序的风格，显得扃异，那就存在问题了。比如这个缩进，又比如变量命名方法，不同的类，不同的Methods里，各自不同，这程序就很难看了。所以一旦你选择了某种风格，一定要贯彻始终。如果一个项目里规定了一个风格，即便很不符合你自己的习惯，也要贯彻始终，绝不应该有标新立异。
2.&缩进风格(indent)
既然是从缩进说起，就先说说缩进风格;一般来说，象Java这样的类C语言，都采用缩进风格。而常用的，有四种
这是C程序最早的缩进风格，由C的发明者Ritchie和他的合作者Kernighan率先使用：
if&(&cond&)&{
&&&&&body&
其特点，是大括号和if判断在同一行。通常，缩进为8个空格或一个tab键，但在C++和Java里，也常缩进4个空格。有人喜欢用两个空格，窃以为不好，不明显。
B.&BSD&风格
又称Allman&Style，源自Unix&BSD程序员Eric&Allman--他为BSD写过很多程序：
if&(&cond&)
&&&&&body&
特点：大括号和条件判断分在两行。
C.&Whitesmith风格
这种风格源于Whitesmith&C:
if&(&cond&)
&&&&&body&
D.&GNU风格
这种风格仅见于GNU&EMACS的源程序中：
if&(&cond&)
&&&&&body&
那么在Java里用哪种好呢？建议只采用A或B。SUN有一个Java&Code&Name&Convention，建议的是A。
3.&Tab还是空格(Tabs&vs&Space)
还是缩进问题。那么一次缩进应该多大距离？是八个空格键，还是一个Tab键？
Java有一个特点，就是跨平台性。不过跨平台指的是它的Class可以在不同平台的虚拟机上运行。Java的源程序，有时候可不是跨平台的。什么？源程序还能不跨平台？是的。有次一个程序员送来一些Code，在我的环境里打开，程序难看得一塌糊涂，有该缩进的地方，没有缩进，有的则缩进一大截，如同怪石一样，嶙峋参差。这样的代码质量可不行！叫来程序员一问，答曰在他那里漂亮得很啊，他还专门花时间去美化它们了呢？
原来他的缩进没有注意一个风格，在有的地方用Tab键，有的地方打空格。在一些不同的平台上，Tab键的宽度可是不一样的。
说道这里，相信大家比较清楚了，在缩进的时候，尽量不用Tab，而是用空格。好在许多编辑器，都可以把你的键盘上的Tab键定义成几个空格。赶紧去定义它！
每次用多少空格呢？4个。2个太少不明显，8个太多占空间。
说道8个空格键占空间，那么我一行有320列，8个空格算什么？打住！请寄住，一行尽量不要超过80列。许多终端一个屏幕只能显示80列，为它们想想巴。如果你的语句太长，想办法折断它，分几列来写。
5.&变量命名
SUN&Java&Code&Convention里定义了Java里package,&class,&method和普通变量的命名规则，
&方法、变量与常量的命名规则
关于包、类及接口的命名规则，在上面的章节中已经讲解过，在此就不再赘述了，本节讲解在Java程序设计中，有关方法、变量与常量的命名规则相关的知识。
1.10.1& 方法的命名规则
方法一般来说都是动词，第一个字母应该小写，在多个单词混合的情况下，第一个单词后的所有单词的第一个字母大写，其余字母小写，例如下面的代码：
runFast();
getBackground();
在方法的声明部分，通常要提供对方法功能的描述，以及方法中返回值与参数的说明，例如下面的代码：
&public String showMessage (String message)
&&&&&&&&&&&&&&&&
&// statements;
&return message;
如果该方法在软件产品的不断升级中已经不被建议使用了，可以通过在方法声明注释部分添加关键字@deprecated实现。
1.10.2& 变量的命名规则
变量的命名规则是，除了变量（variable），所有对象的实例（instance），类（class）与类的常量（constant）的第一个字母应该小写，在多个单词混合的情况下第一个单词后的所有单词的第一个字母大写，其余字母小写的规则之外。变量的第一个字母即使系统允许，也不要为_或者$。变量名字因该紧凑而有意义。变量的名字应该是易记忆、易于理解的，即使间隔较长的时间也可以依其名而知其意。另外单字符的变量名应该尽量避免，除非临时变量，例如，一些整数单字符临时变量：i,j,k,m,n等以及单字符变量：c,d,e等，如下所示的代码：
float imageW
1.10.3& 常量的命名规则
Java中的常量一般采用大写字母单词命名，单词与单词之间用下划线（_）加以分割，这符合ANSI的常量命名规则，如下所示的代码：
static final int MIN_WIDTH = 14;
static final int MAX_WIDTH = 1000;
static final int GET_THE_MEMORY = 128;
&关于关键字static与final的用法，我们将在下面章节做详细的讨论。
上面讨论了Java语言中的代码编写风格及相关格式与书写规则，下面做一个简单Java程序设计的实践，从中掌握所学过的知识。
1.11& Java编程实践
通过四个方面来讲解Java程序设计风格与格式规则，这是编写大师级代码的基础。
1.11.1& 访问实例与类中变量的规则
一般情况下，都不要将类中的变量声明为公共类型（public），除非设计要求如此，如果变量不是公共类型的，这样只能通过public类型方法去访问相关变量，如：getXX()方法等。如果你创建的类中没有任何行为方法，此时你不得不将这个类中的变量声明为公共（public）类型，以供外界访问。
1.11.2& 引用类中的静态变量与方法的规则
当你试图在你的代码中引用类的静态方法或静态成员变量时，不要通过该类的实例对象引用它们，尽管这样是允许的。你应该通过类来引用它们，如下所示的代码：
public static
classMethod();&&&&&&&&&&&&
MyClass.classMethod();&&&&&
myObject.classMethod();&&&
// 不正确（应该避免）
1.11.3& 变量赋值规则
尽量避免在一个单行语句中将一个变量赋多个值，这样将使代码变得艰涩、难懂，例如下面的代码：
userName = user1.name = 'jerry lin'; // 这种赋值方式应尽量避免
尽量避免对一元表达式赋值，例如下面的代码在Java中是绝对不允许的：
if (i++ = m++)
当然可以修改为下面的方式，便可以逃避语法错误，不过这是不被推荐使用的：
if ((c++ = d++) != 0) {
尽量避免嵌套赋值，这样会浪费编译器较多的时间，例如下面的代码：
d = (a = b + c) +
上面的赋值方式应修改为下面的方式：
1.11.4& 综合规则
1．括号规则
应尽量使用括号()来界定表达式的结合顺序，避免由于运算符优先级的问题而导致非主观意图错误，即使你对运算符优先级比较了解而且代码看起来也比较清晰，但是其他程序员看这段代码未必像你一样清楚，例如下面的代码：
if (i == j && m ==
// 应尽量避免
if ((i == j) && (m == n)) //
2．返回值规则
应尽量使程序结构与你的意图匹配，例如：
if (isTrue) {
&&& return
上面的程序有些“受累不讨好”的感觉，应该修改为：
return isT
相似的有，
if (condition) {
&&& return
应该修改为：
return (condition ? x : y);
3．特殊注释规则
你可以在程序中通过一些特殊注释来表示你的伪代码，例如，用EXECUTE表示该代码有问题但是可执行，用FIXME表示代码有问题切不可执行，例如下面的代码：
if (isTrue) {
// EXECUTE
int i = 0;
// FIXME 因为i没有被声明
到此为止，关于Java程序设计的代码风格与格式规则就全部讲解完了，希望你们在自己的代码中尽量应用，开始应用可能不太习惯，但是只要坚持下去，相信你会发现采用良好代码风格进行程序设计的种种好处，并且逐渐会对它产生倾慕与依恋。
本章详细地讲解了有关Java程序设计风格的知识，其中包括：Java文件名与文件组织结构，Java文件注释头，包的声明与引用，类（class）与接口（interface）的声明，Java源文件编排格式，Java程序注释，变量的声明初始化与放置，Java程序语句编写规则，空格与空行的应用规则，以及Java程序设计中方法、变量与常量的命名规则等相关知识，本章最后还给出了在Java编程实践中的三个规则（&#9312;
访问实例与类中变量的规则；&#9313; 引用类中的静态变量与方法的规则；&#9314;
变量赋值规则）。通过对上述知识的学习，只要你能够坚持上面的编写规则，仅从代码风格上来讲你已经具备了编写大师级Java代码风格的能力了，这就是你学习本章的收获。要继续向大师级Java代码的核心靠近，就请继续认真学习本书下面的章节。
这里提提一些注意事项和一些SUN没提到但大家常用的方式。
a.&用有意义的名字命名变量
首先，用完整的英语单词或约定俗成的简写命名你的变量，如：
如果英语不够好，至少用别人看得懂的拼音命名，如
zhuZhi&(住址）
胡乱简写，或者胡乱命名，则没有人看得懂你的变量的含义：
b.&常量用全大写加下画线命名Java里的常量，就是static&final:
static&final&SMTH_BBS="bbs.";
c.&用复数命名collection类变量
collection包括数组，vector等。命名时请用复数：
classMates
也可以用一些修饰词命名：
someStudents
allDepartments
d.&循环变量
一般大家都用i,&j,&k等做循环变量。
e.&Stream变量一般习惯用in,&out作为Stream变量，对应inputStream,&outputStream
类。如果即读又写的ioStream，可以用inOut。
f.&变量的命名习惯
习惯MFC的人喜欢采用匈牙利命名法(Hungarian&Notation)。如果你习惯这样，尽管用，但注意要和同Project的人保持一致。还有些人习惯C++里的下画线方式，也可以采用。
Hungarian&Notation:
sFirstName
Under&Score&Style:
_firstName
这里提供一个Hungarian&Notation的前缀命名习惯：
int&&&&&&&&&&&&&&&&&&
byte&&&&&&&&&&&&&&&&&&b
char&&&&&&&&&&&&&
double&&&&&&&&&&&&&&d
float&&&&&&&&&&&&&&&&
long&&&&&&&&&&&&&
offset&&&&&&&&&
length&&&&&&&&&&&
Object&&&&&&&&&
String&&&&&&&&&&&&&&&s&(or&str)
Arbitray&value&&&
6.&Java文件格式
有许多方式定义你的文件语句格式，以下是一个例子：
a.&文件头说明&(可无)
b.&Package定义
d.&Import语句
package&com.
//Java&Classes
import&java.awt.*;
import&java.io.*;
import&javax.swing.event.*;
//WebLogic&Classes
import&weblogic.internal.*;
public&class&MyFirst&extends&JFrame&{
class&Foo&{
7.&import顺序
杂乱无章的顺序，看起来很不顺眼。应该对你要import的classes归类，按顺序罗列：
a.&Java标准类(java.*)
b.&Java扩充类(javax.*)
c.&第三方类
d.&你的应用程序的类
而且注意在第三方类里注释它们，说明它们的来源：
import&java.*;
import&java.util.D
import&java.util.E
import&javax.sql.*;
//Apache&Xerces
import&org.apache.xml.*;
import&org.apache.xerces.dom.*;
//Application&classes
import&com.midi.util.*;
8.&Classes的顺序
a.&Javadoc注释或者其它文件头注释
c.&Fields声明
e.&构造函数
g.&方法（不包括main)
i.&Inner类
public&class&MyParser&{
&&&&//&public&constants
&&&&public&static&final&String&TITLE&=&"MyParser";
&&&&public&static&final&String&VERSION&=&"0.0.1";
&&&&//&Private&variables
&&&&private&int&iSchemaV
&&&&public&MyParser&()&{
&&&&&&&&iSchemaVersion&=&1;
&&&&public&MyParser&(iSchemaVersion)&{
&&&&&&&&this.iSchemaVersion&=&iSchemaV
&&&&public&void&myInit&()&throws&Exception&{
&&&&&&&&....
&&&&public&static&void&main&(String[]&argvs)&{
&&&&&&&&...
9.&Field定义
请遵从以下顺序：
a.&Public常量
b.&Public变量
c.&Protected常量
d.&Protected变量
e.&Package常量
f.&Package变量
g.&Private常量
h.&Private变量
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。}