1.注释方式的分类
2.如何定义常量
3.变量命名规则
4.强制类型转换方法
5.标识符的命名规则
6.java关键字
7.计算各种表达式的运算结果
一. 注释方式的分类
在软件开发的过程中总是强调注释的规范，但是没有一个具体的标准进行说明，通常都是在代码编写规范中简单的描述几句，不能作为一个代码注释检查的标准和依据，做什么都要有一个依据吗:),现在我特整理了一个《Java的注释规范》，内容来自网络、书籍和自己的实际积累。
一、背景
1、当我们第一次接触某段代码，但又被要求在极短的时间内有效地分析这段代码，我们需要什么样的注释信息？
2、怎么样避免我们的注释冗长而且凌乱不堪呢？
3、在多人协同开发、维护的今天，我们需要怎么样的注释来保证高质、高交的进行开发和维护工作呢？
二、意义
程序中的注释是程序设计者与程序阅读者之间通信的重要手段。应用注释规范对于软件本身和软件开发人员而言尤为重要。并且在流行的敏捷开发思想中已经提出了将注释转为代码的概念。好的注释规范可以尽可能的减少一个软件的维护成本 , 并且几乎没有任何一个软件，在其整个生命周期中，均由最初的开发人员来维护。好的注释规范可以改善软件的可读性，可以让开发人员尽快而彻底地理解新的代码。好的注释规范可以最大限度的提高团队开发的合作效率。长期的规范性编码还可以让开发人员养成良好的编码习惯，甚至锻炼出更加严谨的思维能力。
三、注释的原则
1、注释形式统一
在整个应用程序中，使用具有一致的标点和结构的样式来构造注释。如果在其他项目组发现他们的注释规范与这份文档不同，按照他们的规范写代码，不要试图在既成的规范系统中引入新的规范。
2、注释的简洁
内容要简单、明了、含义准确，防止注释的多义性，错误的注释不但无益反而有害。
3、注释的一致性
在写代码之前或者边写代码边写注释，因为以后很可能没有时间来这样做。另外，如果有机会复查已编写的代码，在今天看来很明显的东西六周以后或许就不明显了。通常描述性注释先于代码创建，解释性注释在开发过程中创建，提示性注释在代码完成之后创建。修改代码的同时修改相应的注释，以保证代码与注释的同步。
4、注释的位置
保证注释与其描述的代码相邻，即注释的就近原则。对代码的注释应放在其上方相邻或右方的位置，不可放在下方。避免在代码行的末尾添加注释；行尾注释使代码更难阅读。不过在批注变量声明时，行尾注释是合适的；在这种情况下，将所有行尾注释要对齐。
5、注释的数量
注释必不可少，但也不应过多，在实际的代码规范中，要求注释占程序代码的比例达到20%左右。注释是对代码的“提示”，而不是文档，程序中的注释不可喧宾夺主，注释太多了会让人眼花缭乱，注释的花样要少。不要被动的为写注释而写注释。
6、删除无用注释
在代码交付或部署发布之前，必须删掉临时的或无关的注释，以避免在日后的维护工作中产生混乱。
7、复杂的注释
如果需要用注释来解释复杂的代码，请检查此代码以确定是否应该重写它。尽一切可能不注释难以理解的代码，而应该重写它。尽管一般不应该为了使代码更简单便于使用而牺牲性能，但必须保持性能和可维护性之间的平衡。
8、多余的注释
描述程序功能和程序各组成部分相互关系的高级注释是最有用的，而逐行解释程序如何工作的低级注释则不利于读、写和修改，是不必要的，也是难以维护的。避免每行代码都使用注释。如果代码本来就是清楚、一目了然的则不加注释，避免多余的或不适当的注释出现。
9、必加的注释
典型算法必须有注释。在代码不明晰或不可移植处必须有注释。在代码修改处加上修改标识的注释。在循环和逻辑分支组成的代码中添加注释。为了防止问题反复出现，对错误修复和解决方法的代码使用注释，尤其是在团队环境中。
10、注释在编译代码时会被忽略，不编译到最后的可执行文件中，所以注释不
会增加可执行文件的大小。
四、JAVA注释技巧
1、空行和空白字符也是一种特殊注释。利用缩进和空行，使代码与注释容易区
别，并协调美观。
2、当代码比较长，特别是有多重嵌套时，为了使层次清晰，应当在一些段落的
结束处加注释（在闭合的右花括号后注释该闭合所对应的起点），注释不能
写得很长，只要能表示是哪个控制语句控制范围的结束即可，这样便于阅读。
3、将注释与注释分隔符用一个空格分开，在没有颜色提示的情况下查看注释时，
这样做会使注释很明显且容易被找到。
4、不允许给块注释的周围加上外框。这样看起来可能很漂亮，但是难于维护。
5、每行注释（连同代码）不要超过120个字(1024×768)，最好不要超过80
字(800×600) 。
6、Java编辑器（IDE）注释快捷方式。Ctrl+/ 注释当前行,再按则取消注释。
7、对于多行代码的注释，尽量不采用“/*......*/”，而采用多行“//”注释，
这样虽然麻烦，但是在做屏蔽调试时不用查找配对的“/*......*/”。
8、注释作为代码切换开关，用于临时测试屏蔽某些代码。
例一：
//*/
codeSegement1;
//*/
改动第一行就成了：
/*/
codeSegement1;
//*/
例二：
//----------------------第一段有效，第二段被注释
//*/
codeSegement1;
/*/
codeSegement2;
//*/
只需删除第一行的/就可以变成：
//----------------------第一段被注释，第二段有效
/*/
codeSegement1;
/*/
codeSegement2;
//*/
五、JAVA注释方法及格式
1、单行(single-line)--短注释：//……
单独行注释：在代码中单起一行注释， 注释前最好有一行空行，并与其后的代码具有一样的缩进层级。如果单行无法完成，则应采用块注释。
注释格式：/* 注释内容 */
行头注释：在代码行的开头进行注释。主要为了使该行代码失去意义。
注释格式：// 注释内容
行尾注释：尾端(trailing)--极短的注释，在代码行的行尾进行注释。一般与代码行后空8（至少4）个格，所有注释必须对齐。
注释格式：代码 + 8（至少4）个空格 + // 注释内容
2、块(block)--块注释：/*……*/
注释若干行，通常用于提供文件、方法、数据结构等的意义与用途的说明，或者算法的描述。一般位于一个文件或者一个方法的前面，起到引导的作用，也可以根据需要放在合适的位置。这种域注释不会出现在HTML报告中。注释格式通常写成：
/*
* 注释内容
*/
3、文档注释：/**……*/
注释若干行，并写入javadoc文档。每个文档注释都会被置于注释定界符
/**......*/之中，注释文档将用来生成HTML格式的代码报告，所以注释文
档必须书写在类、域、构造函数、方法，以及字段(field)定义之前。注释文档由两部分组成——描述、块标记。注释文档的格式如下：
/**
* The doGet method of the servlet.
* This method is called when a form has its tag value method
* equals to get.
* @param request
* the request send by the client to the server
* @param response
* the response send by the server to the client
* @throws ServletException
* if an error occurred
* @throws IOException
* if an error occurred
*/
public void doGet (HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doPost(request, response);
}
前两行为描述，描述完毕后，由@符号起头为块标记注释。更多有关文档注
释和javadoc的详细资料，参见javadoc的主页： http://java.sun.com/javadoc/index.html ;
4、javadoc注释标签语法
@author 对类的说明 标明开发该类模块的作者
@version 对类的说明 标明该类模块的版本
@see 对类、属性、方法的说明 参考转向，也就是相关主题
@param 对方法的说明 对方法中某参数的说明
@return 对方法的说明 对方法返回值的说明
@exception 对方法的说明 对方法可能抛出的异常进行说明
六、JAVA注释具体实现
1、源文件注释
源文件注释采用 /** …… */，在每个源文件的头部要有必要的注释信息，包括：文件名；文件编号；版本号；作者；创建时间；文件描述包括本文件历史修改记录等。中文注释模版：
/**
* 文 件 名 :
* CopyRright (c) 2008-xxxx:
* 文件编号：
* 创 建 人：
* 日 期：
* 修 改 人：
* 日 期：
* 描 述：
* 版 本 号：
*/
2、类（模块）注释：
类（模块）注释采用 /** …… */，在每个类（模块）的头部要有必要的注释信息，包括：工程名；类（模块）编号；命名空间；类可以运行的JDK版本；版本号；作者；创建时间；类（模块）功能描述（如功能、主要算法、内部各部分之间的关系、该类与其类的关系等，必要时还要有一些如特别的软硬件要求等说明）；主要函数或过程清单及本类（模块）历史修改记录等。
英文注释模版：
/**
* CopyRright (c)2008-xxxx: <展望软件Forsoft >
* Project: <项目工程名 >
* Module ID: <(模块)类编号，可以引用系统设计中的类编号>
* Comments: <对此类的描述，可以引用系统设计中的描述>
* JDK version used: <JDK1.6>
* Namespace: <命名空间>
* Author： <作者中文名或拼音缩写>
* Create Date： <创建日期，格式:YYYY-MM-DD>
* Modified By： <修改人中文名或拼音缩写>
* Modified Date: <修改日期，格式:YYYY-MM-DD>
* Why & What is modified <修改原因描述>
* Version: <版本号>
*/
如果模块只进行部分少量代码的修改时，则每次修改须添加以下注释：
//Rewriter
//Rewrite Date：<修改日期:格式YYYY-MM-DD> Start1：
/* 原代码内容*/
//End1：
将原代码内容注释掉，然后添加新代码使用以下注释：
//Added by
//Add date：<添加日期，格式：YYYY-MM-DD> Start2：
//End2：
如果模块输入输出参数或功能结构有较大修改，则每次修改必须添加以下
注释：
//Log ID：<Log编号,从1开始一次增加>
//Depiction：<对此修改的描述>
//Writer：修改者中文名
//Rewrite Date：<模块修改日期，格式：YYYY-MM-DD>
2、接口注释：
接口注释采用 /** …… */，在满足类注释的基础之上，接口注释应该包含描述接口的目的、它应如何被使用以及如何不被使用，块标记部分必须注明作者和版本。在接口注释清楚的前提下对应的实现类可以不加注释。
3、构造函数注释：
构造函数注释采用 /** …… */，描述部分注明构造函数的作用，不一定有块标记部分。
注释模版一：
/**
* 默认构造函数
*/
注释模版二：
/**
* Description : 带参数构造函数,
* 初始化模式名,名称和数据源类型
* @param schema： 模式名
* @param name： 名称
* @param type： 数据源类型
*/
4、函数注释：
函数注释采用 /** ……*/，在每个函数或者过程的前面要有必要的注释信息，包括：函数或过程名称；功能描述；输入、输出及返回值说明；调用关系及被调用关系说明等。函数注释里面可以不出现版本号（@version）。
注释模版一：
/**
* 函 数 名 :
* 功能描述：
* 输入参数: <按照参数定义顺序>
* <@param后面空格后跟着参数的变量名字
* （不是类型），空格后跟着对该参数的描述。>
*
* 返 回 值: - 类型 <说明>
* <返回为空（void）的构造函数或者函数，
* @return可以省略; 如果返回值就是输入参数，必须 * 用与输入参数的@param相同的描述信息; 必要的时* 候注明特殊条件写的返回值。>
* 异 常：<按照异常名字的字母顺序>
* 创 建 人:
* 日 期:
* 修 改 人:
* 日 期:
*/
注释模版二：
/**
* FunName: getFirstSpell
* Description : 获取汉字拼音首字母的字符串，
* 被生成百家姓函数调用
* @param： str the String是包含汉字的字符串
* @return String：汉字返回拼音首字母字符串；
* 英文字母返回对应的大写字母；
* 其他非简体汉字返回 '0'；
* @Author: ghc
* @Create Date: 2008-07-02
*/
5、方法注释：
方法注释采用 /** …… */，对于设置 (Set 方法 ) 与获取 (Get 方法 ) 成员的方法，在成员变量已有说明的情况下，可以不加注释；普通成员方法要求说明完成什么功能，参数含义是什么且返回值什么；另外方法的创建时间必须注释清楚，为将来的维护和阅读提供宝贵线索。
6、方法内部注释：
控制结构，代码做了些什么以及为什么这样做，处理顺序等，特别是复杂的逻辑处理部分，要尽可能的给出详细的注释。
7、全局变量注释：
要有较详细的注释，包括对其功能、取值范围、哪些函数或者过程存取以及存取时注意事项等的说明。
8、局部（中间）变量注释：
主要变量必须有注释，无特别意义的情况下可以不加注释。
9、实参/参数注释：
参数含义、及其它任何约束或前提条件。
10、字段/属性注释： 字段描述，属性说明。
11、常量：常量通常具有一定的实际意义，要定义相应说明。
二.如何定义常量
常量定义的基本注意事项。
在Java语言中，主要是利用final关键字（在Java类中灵活使用Static关键字）来定义常量。当常量被设定后，一般情况下就不允许再进行更改。如可以利用如下的形式来定义一个常量：final double PI=3.1315。在定义这个常量时，需要注意如下内容：
一是常量在定义的时候，就需要对常量进行初始化。也就是说，必须要在常量声明时对其进行初始化。都跟局部变量或者成员变量不同。当在常量定义的 时候初始化过后，在应用程序中就无法再次对这个常量进行赋值。如果强行赋值的话，数据库会跳出错误信息，并拒绝接受这一个新的值。（接口中定义的常量的访问方法）
二是final关键字使用的范围。这个final关键字不仅可以用来修饰基本数据类型的常量，还可以用来修饰对象的引用或者方法。如数组就是一 个对象引用。为此可以使用final关键字来定义一个常量的数组。这就是Java语言中一个很大的特色。一旦一个数组对象被final关键字设置为常量数 组之后，它只能够恒定的指向一个数组对象，无法将其改变指向另外一个对象，也无法更改数组（有序数组的插入方法可使用的二分查找算法）中的值。
三是需要注意常量的命名规则。不同的语言，在定义变量或者常量的时候，都有自己一套编码规则。这主要是为了提高代码的共享程度与提高代码的易读 性。在Java语言中，定义常量的时候，也有自己的一套规则。如在给常量取名的时候，一般都用大写字符。在Java语言中，大小写字符是敏感的。之所以采 用大写字符，主要是跟变量进行区分。虽然说给常量取名时采用小写字符，也不会有语法上的错误。但是，为了在编写代码时能够一目了然的判断变量与常量，最好 还是能够将常量设置为大写字符。另外，在常量中，往往通过下划线来分隔不同的字符。而不想对象名或者类名那样，通过首字符大写的方式来进行分隔。这些规则 虽然不是强制性的规则，但是为了提高代码友好性，方便开发团队中的其他成员阅读，这些规则还是需要遵守的。没有规矩，不成方圆。
总之，Java开发人员需要注意，被定义为final的常量需要采用大写字母命名，并且中间最好使用下划线作为分隔符来进行连接多个单词。在定义final的数据不论是常量、对象引用还是数组，在主函数中都不可以改变。否则的话，会被编辑器拒绝并提示错误信息。
二、Final关键字与static关键字同时使用。
由于Javal是面向对象的语言，所以在定义常量的时候还有与其它编程语言不同的地方。如一段程序代码从编辑到最后执行，即使需要经过两个过程，分别为代码的装载与对象的建立。不同的过程对于常量的影响是不同的。现在假设有如下的代码：
Private static Random rd1=new Random(); //实例化一个随机数生成对象。
Private final int int1=rd1.nestInt(10); //生成随机数并赋值给常量int1
Private static final int int2=rd1.nestInt(10); //生成随机数并赋值给常量int2
这上面的语句的大致含义是，通过Java语言提供的随机数类对象，生成随机数。并把生成的随机数赋值给常量int1与int2。细心的读者会发 现，虽然同样是赋值语句，但是以上两个语句中有一个细小的差别，即在第二条语句中多了一个关键字static。关于关键字的用途，笔者在以前的文章中也有 谈到过。这个是一个静态的概念。即当利用这个关键字来修饰一个变量的时候，在创建对象之前就会为这个变量在内存中创建一个存储空间。以后创建对对象如果需 要用到这个静态变量，那么就会共享这一个变量的存储空间。也就是说，在创建对象的时候，如果用到这个变量，那么系统不会为其再分配一个存储空间，而只是将 这个内存存储空间的地址赋值给他。如此做的好处就是可以让多个对象采用相同的初始变量。当需要改变多个对象中变量值的时候，只需要改变一次即可。从这个特 性上来说，其跟常量的作用比较类似。不过其并不能够取代常量的作用。
三.变量命名规则
本文介绍的是java中的变量的命名规则，对于初学者来说，还是很重要的。希望对你有帮助，一起来看。
Java是一种区分字母的大小写(case-sensitive)的语言,下面谈谈Java语言中包、类、变量等的命名规范。
（一）Package(包)的命名:
Package的名字应该都是由一个小写单词组成,例如net.ebseries.modules。
（二）Class(类)的命名:
Class的名字首字母大写,通常由多个单词合成一个类名，要求每个单词的首字母也要大写,例如：DataFile或InfoParser。
（三）变量的命名:
变量的名字可大小写混用，但首字符应小写。词由大写字母分隔，限制用下划线，限制使用美元符（$），因为这个字符对内部类有特殊的含义。如：inputFileSize。
（四） Interface(接口)的命名:与Class的命名类似。
（五）Static Final 变量（相当于常量）的命名
Static Final 变量的名字应该都大写，并且指出完整含义，例如：final MAXUPLOADFILESIZE=1024。
（六）方法的命名
方法名的第一个单词应该是动词，大小写可混用，但首字母应小写。在每个方法名内，大写字母将词分隔并限制使用下划线。参数的名字必须和变量的命名规范一致。使用有意义的参数命名，如果可能的话，使用和要赋值的字段一样的名字：
- setCounter(int size){
- this.size = size;
- }
数组的命名
数组应该总是用下面的方式来命名：byte[] buffer;而不是：byte buffer[](习惯性问题而已)。
值得注意的是，命名时应尽量采用完整的英文描述符（也有特例）。此外，一般应采用小写字母，但类名、接口名以及任何非初始单词的第一个字母要大写。
四.强制类型转换方法
1、String型---->double型
Double.parseDouble("11.2");
2、String型---->int型
Integer.parseInt("44");
3、string->byte
Byte static byte parseByte(String s)
byte->string
Byte static String toString(byte b)
char->string
Character static String to String (char c)
string->Short
Short static Short parseShort(String s)
Short->String
Short static String toString(Short s)
String->Integer
Integer static int parseInt(String s)
Integer->String
Integer static String tostring(int i)
String->Long
Long static long parseLong(String s)
Long->String
Long static String toString(Long i)
String->Float
Float static float parseFloat(String s)
Float->String
Float static String toString(float f)
String->Double
Double static double parseDouble(String s)
Double->String
Double static String toString(Double)
在JSP网页程序的编写过程中，随时会遇到各种数据类型转换及强制转换。下面就一般的转换情况作出一定的分析。
因为String的范围比int要大，所以强制类型转换是不行的，这时就用到了“缩小转换”
String RDMoney ;
int Money = Integer.parseInt(RDMoney) ;
这样就把String转成int了，其他类型同理
有必要看看下面的文章：
低级变量转换为高级变量就不说了，拿个例子一看就懂了
byte b;
int i=b;
而将高级变量转换为低级变量时，可以使用强制类型转换。
int i;
byte b=(byte)i;
这种转换肯定可能会导致溢出或精度的下降，不推荐使用这种转换。
Java的包装类，不兼容类型的强制转换
在了解其它变量类型之间的相互转换时，需要先了解一下Java的包装类，包装类就是可以直接将简单类型的变量表示为一个类，在执行变量类型的相互转换时，我们会大量使用这些包装类。Java共有六个包装类，分别是Boolean、Character、Integer、Long、Float和 Double，从字面上我们就可以看出它们分别对应于 boolean、char、int、long、float和double。而String和Date本身就是类。所以也就不存在什么包装类的概念了。
简单类型变量和包装类之间的相互转换
简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。即：
Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)
而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。利用这种方法，也可以实现不同数值型变量间的转换，例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。
String类和其它数据类型的相互转换
对于上面的这些包装类，除了Character以外，都有可以直接使用字符串参数的构造函数，这也就使得我们将String类转换为这些数据类型变得相当之简单，即：
Boolean(String s)、Integer(String s)、Long(String s)、Float(String s)、Double(String s)
而将String类转换为Date类也可以使用这样的构造函数：Date(String s)
现在我们还剩下一个字符型变量，事实上String类可以理解为一个char型数组，因此我们可以在String类中找到这样的方法来实现这种转换： charAt(int index)可以得到String类中某一位置上的字符，toCharArray()更可以将整个String类转换成一个char的数组。
对于所有的包装类都存在一个名为toString()的方法可以将其转换成对应的String类，而对于整型类和长整型类，还可以使用 toBinaryString(int i)、toHexString(int i)、toOctalString(int i)分别以二进制、十六进制和八进制的形式进行到String类的转换。
将字符型直接做为数值转换为其它数据类型
将字符型变量转换为数值型变量实际上有两种对应关系，在我们在第一部分所说的那种转换中，实际上是将其转换成对应的ASCII码，但是我们有时还需要另一种转换关系，例如，‘1’就是指的数值1，而不是其ASCII码，对于这种转换，我们可以使用Character的getNumericValue(char ch)方法
Date类与其它数据类型的相互转换
整型和Date类之间并不存在直接的对应关系，只是你可以使用int型为分别表示年、月、日、时、分、秒，这样就在两者之间建立了一个对应关系，在作这种转换时，你可以使用Date类构造函数的三种形式：
Date(int year, int month, int date)：以int型表示年、月、日
Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、时、分
Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、时、分、秒
在长整型和Date类之间有一个很有趣的对应关系，就是将一个时间表示为距离格林尼治标准时间1970年1月1日0时0分0秒的毫秒数。对于这种对应关系，Date类也有其相应的构造函数：Date(long date)
获取Date类中的年、月、日、时、分、秒以及星期你可以使用Date类的getYear()、getMonth()、getDate()、 getHours()、getMinutes()、getSeconds()、getDay()方法，你也可以将其理解为将Date类转换成int。
而Date类的getTime()方法可以得到我们前面所说的一个时间对应的长整型数，与包装类一样，Date类也有一个toString()方法可以将其转换为String类。
规定格式的 String 转 Date
java.text.SimpleDateFormat sdf=new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date dat = sdf.parse("2007-05-04 12:56:18");
定义这个规范的目的是让项目中所有的文档都看起来像一个人写的，增加可读性，减少项目组中因为换人而带来的损失。
（这些规范并不是一定要绝对遵守，但是一定要让程序有良好的可读性）。Java语言的命名规范，不使用匈牙利命名法。
a) 标识符命名总则
程序中应采用有意义的标识符名字，让标识符含义自明。尽量使用应用领域熟知的名词和术语，避免生造一些普通词汇。避免使用近似的名字。
标识符采用英文单词命名，禁止使用汉语拼音或其缩写形式命名。在一个对象的操作名字中不必重复出现对象的名字。
【例子】
对User 接口或类的操作而言，insert 是好的标识符，insertUser 是不好的标识符。
因为以对象引用调用操作时的形式分别为user.insert(...)和user.insertUser(...)，显然前者更佳。
b) 标识符长度
各类标识符长度应控制在24 个字符之内。如果个别难以表述的标识符确实需要更大的长度，则禁止超过36 个字符。
【备注】
虽然Java 语言本身未约束标识符的长度，但其实现通常都会有一定约束，并且过长的标识符对于程序的输入与阅读都带来麻烦。
c) 单词缩写约定
总体指导原则：一个程序成份的作用域越大，则越应采用完整的单词；仅当该成份作用域局限于程序员自己控制范围时，才宜采用单词的缩写形式。
一个对象公开给其他组件的接口、类、方法、对象实例、属性等标识符均应避免使用缩写，除非该单词本身冗长且有约定俗成的简写。
仅在一个对象实现的内部对过长的单词采用缩写，从而将这些缩写的涉及范围约束在一个较小的名字空间中。
需要缩写单词时，遵循以下原则以提高标识符的可读性：
① 保留单词的首字母（注意ex 前缀的单词常转换为x 开头）；
② 单词的首部比尾部重要；
③ 单词中的辅音字母比元音字母重要；
④ 遵循英文单词的缩写习惯。
【例子】
接口或类的名字UsrAuth 不如UserAuthorization ， 公有方法的名字delChar 不如deleteCharacter；
但类名UserConfig 比UserConfiguration 更好，类名PackingSpec 比PackingSpecification 更好。
禁止使用2代替to，4代替for,U代替you等等。
d) 程序包的命名
Java程序包的名字应该都是由一个小写单词组成。规定的Java程序包层次格式为 com.dareway.项目.具体模块。
命名必须全部用小写字母，可以用"_"作为分割符。
【例子】
com.dareway.util.*;
com.dareway.db.*;
com.dareway.shopping_center.client.*;
e) class/interface 的命名
Class 的名字必须由大写字母开头而其他字母都小写的单词组成，应该有英文的名次组成，不宜采用动词。
接口(interface)的命名采用形容词通常比名词好。
【例子】
class MainThread extends Thread
interface LoadOption
class Integer extends Number
interface Runnable
f) Method(方法, 函数)的命名
第一个单词必须小写，后面的单词均以大写字母开头，采用大小写混合形式，并且应足够长以描述它的作用，
Method名应以一个动词起首。当然构造函数除外。
对于返回值为布尔类型的方法，其标识符通常采用is、has 或can 等前缀；
其他方法名宜选择动词或以动词开头（例如动名词短语），不宜采用名词来命名。
对于代表一组对象的接口或类，通常利用完备的方法封装其内部实现，
这些方法宜命名为：访问集合getAbc()、访问元素getXyz()、设置集合setAbc()；插入一个元素insertXyz()、
修改或更新一个元素updateXyz()、删除一个元素deleteXyz()、创建并插入一个新元素newXyz()。
其中Abc 为集合名词，Xyz 为元素名词。
如果属性的Getter 和Setter 方法可在问题域中找到与对象建模相对应的实体自然映射，
则应采用这种更自然、更易理解的命名。否则，将属性abc 的Setter 方法命名为setAbc()；
如果该属性为布尔类型，则Getter 方法名字采用is开头，否则命名为getAbc()。
【例子】
User.getName()
User.setName()
Iterator.hasNext()
Collection.isEmpty()
getUserRight()
exitProgram()
g) 变量的命名
变量的名字必须用一个小写字母开头。后面的单词用大写字母开头。
对于描述一组对象的集合属性或局部变量（例如类型为Array、HashTable、Vector、Enumeration 等），用英文复数形式命名其标识符。
用于命名布尔型的属性或局部变量的标识符通常采用is、has 或can 等前缀；并且这些标识符应使用肯定形式的判定句式，不要使用其否定形式。
如果变量类形是static final类型，则变量名要全部大写，单词之间用"_"连接。
【例子】
static final int MAX_NUMBER=1024;
String strName ;
h) 方法的参数命名
参数的名字可以和Class变量的命名规范一致。建议是用下面的规范。
i. 如果参数是要对class的变量进行赋值，参数要使用和要赋值的字段一样的名字。
【例子】
public MainThread ( int runTime ){ //构造函数
this.runTime = runTime;
//---------------
}
public void setCounter(int size){ //对实例变量进行赋值
this.size = size;
}
i) 临时变量的命名
建议和Class变量的命名规范一致。返回值命名为re。
在简单循环中的循环计数器可命名为i、j、k、ptr、index 或counter；
复杂的循环或循环计数器在问题域有明确对应术语时不得如此命名，应采用问题域中对应的名字作为标识符。
用于命名布尔型的属性或局部变量的标识符通常采用is、has 或can 等前缀；
并且这些标识符应使用肯定形式的判定句式，不要使用其否定形式。
当一个流作为局部变量时，习惯将输入流命名为in、输出流命名为out、I/O 流命名为inOut。
习惯将异常对象实例命名为ex。
j) 实例变量的引用
在类中引用实力变量的时候，一定要注明，实例变量是本对象的还是父类对象的变量。
如果是本类的实例变量应该用this.xxx来引用，禁止直接用xxx引用；如果是父类的实例变量应该用super.xxx来引用，禁止使用xxx引用。
Java 注释
良好的程序注释可帮助提高程序源代码的清晰度。注释的目的是要使代码更易于被同时参与程序设计的开发人员以及其他后继开发人员理解。
注释即使对程序员自己而言，也是一种帮助而不是拖累。程序中的各类注释应在程序编制过程中不断书写与完善，
这样才可体现程序员的设计思路。不应该在程序开发完毕后再一次性填写注释条目！
程序注释方式很大程度上影响着程序员的工作效率以及所有负责维护、改进程序代码的后继开发者的工作效率。
在软件开发过程中及早注释代码，会促使程序员在编写代码前仔细考虑这些代码，从而提高编码的质量。
程序维护人员重新阅读以前的代码时，可很容易地判断出当时程序员的想法，因为这些思路均有记录可查。
各种注释、文档与手册之间尽量避免重复。
a) 程序注释总则
程序员编写程序时，先编写注释、后编写代码；程序员修改程序时，也是先修改注释、再修改代码。
注释不仅仅是只列出相应代码执行的功能，而且还应给出为什么如此编写代码的原因或理由。
注释以清晰、实用为目的，避免使用广告横幅那样的装饰性注释风格。
b) javadoc
javadoc 是一种文档产生工具，它可以方便的将源文件中的注释转成标准的java文档。
只要在写注释的时候按照一定标准来写就可以了。下表是javadoc支持的一些标签。
我们会在自己的注释中应用javadoc的一些规范。可以被javadoc生成文档的注释方法:，
javadoc可以识别注释中的Html标识，在注释中可以采用。
Tag 标签 Used for使用对象 Purpose目的
@author name Interfaces,Classes, 标识作者一个@author 对应一个作者
@deprecated Interfaces,Classes,Member Functions 表示这个API已经不推荐使用,请使用其他类型代替
@exception name description Member Functions 描述方法会抛出的异常.一个标签对应一个异常name应该是异常类的全名
@param name description Member Functions 用来描述参数, 包括它的类型和使用方法如：@param key电价编号
@return description Member Functions 返回值说明, 包括类型, 和代表的意义，如：@return String 电价名称
@since Interfaces,Classes,Member Functions 显示该项目什么时候开始存在的例如 @since JDK 1.1
@see ClassName Classes,Interfaces,Member Functions, Fields 建立一个超级连接到指定的class作为参考，
如：@see com.dareway.DarewayManager
@see ClassName#memberfunctionName
Classes,Interfaces,Member Functions, Fields
建立一个超级连接到指定的某一个方法中去，如：@see DarewayFactory#getCode()
@version text Classes,Interfaces 版本号
c) Java文件头
版权信息必须在 java 文件的开头。
其他不需要出现在 javadoc 的信息也可以包含在这里。
如果要修改现有的Java类，你需要首先在这里注明修改日期、修改人、修改原因。
【例子】
d) 类的注释
类的注释，一般是用来解释类的。在定义类之前。
其他不需要出现在 javadoc 的信息也可以包含在这里。
【例子】
e) 变量注释
对于作用范围是public的变量，一定要有注释。注释在变量上面。
如果注释的内容很多。在第一个完整的句子（必须以半角的"."结束）中说明类的主要功能。在其他句子中进行详细地说明。
【例子】
public String totleCount;
f) 方法的注释
对于作用范围是public的方法，一定要有注释。注释在方法上面。
如果注释的内容很多。在第一个完整的句子（必须以半角的"."结束）中说明类的主要功能。在其他句子中进行详细地说明。
【例子】
public static void Add ( MyClass eMC ){
}
g) 其他注释
在Java中的 和 // 注释不会被javadoc识别。可以用来注释程序。在方法中的 注释也不会被javadoc识别。
在程序中不主张使用javadoc注释 。
建议在 java 方法实现中采用 和 // 注释。
// 注释不要在一行语句的结束，要在新的一行。
在类的方法体外禁止使用 和 //来进行注释。但是Java文件头的注释除外。
在复杂的算法中必须有足够多的注释。
六.java关键字和保留字
Java 关键字列表 (依字母排序 共51组):
abstract, assert,boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum,extends, final, finally, float, for, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while
Java 保留字列表 (依字母排序 共14组) : Java保留字是指现有Java版本尚未使用 但以后版本可能会作为关键字使用。
byValue, cast, false, future, generic, inner, operator, outer, rest, true, var ， goto ，const,null
呵呵，不管别的，来几条题目先，作对了你牛^_^
1, which of the following are keywords or reserved words in java?
a) if b)then c)goto d)while e)case f)sizeof
2, which of the following are java key words?
a)double b)Switch c)then d)instanceof
3, which of these are key words in java?
a) default b)NULL c)String d)throws e)long f)true
答案来了 1，acde 2，ad 3，adef 作对了吗^_^
解释来了 1，then和sizeof都不是java的关键字，熟悉c或者c＋＋，写惯了asp的高手就要小心喽。
2，所有的关键字都是小写的，所以Switch不是关键字。instanceof看上去像方法名，但其实是关键字；
3，大写的NULL不是java语言的关键字。String是java语言的一个封装类的类名，也不是关键字。
再来点系统的：
正确识别java语言的关键字（keyword）和保留字（reserved word）是十分重要的。Java的关键字对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等。保留字是为java预留的关键字，他们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。
关键字列表
abstract boolean break byte case
catch char class continue default
do double else extends false
final finally float for if
implements import instanceof int interface
long native new null package
private protected public return short
static super switch synchronized this
throw throws transient true try
void volatile while
保留字
const，goto
注意点
识别java语言的关键字，不要和其他语言如c/c++的关键字混淆。
const和goto是java的保留字。
所有的关键字都是小写
friendly，sizeof不是java的关键字
1. 算术运算符与算术表达式
(1) 加减运算符 +,-.例如 2+39,908.98-23等.
加减运算符是双目运算符,即连接两个操作元的运算符.加减运算符的结合方向是从左到右.例如: 2+3-8,先计算2+3,然后再将得到的结果减8.加减运算符的操作元是整型或浮点型数据,加减运算符的优先级是4级.
(2) 乘,除和求余运算符 *,/,%.例如 2*39 908.98/23等.
*,/,%运算符是双目运算符,即连接两个操作元的运算符.*,/,%运算符的结合方向是从左到右,例如 2*3/8,先计算2*3,然后再将得到的结果除以8.乘除运算符的操作元是整型或浮点型数据.*,/,%运算符的优先级是3级.
用算术符号和括号连接起来的符合java语法规则的式子,如x+2*y-30+3*(y+5).
2 自增,自减运算符 ++,--
自增,自减运算符是单目运算符,可以放在操作元之前,也可以放在操作元之后.操作元必
须是一个整型或浮点型变量.作用是使变量的值增1或减1,如
++x,--x表示在使用x之前,先使x的值加 减 1 .
x++,x— 表示在使用x之后,使x的值加 减 1.
粗略的看,++x和x++的作用相当于x=x+1.但++x和x++的不同之处在于,++x 是先执行x=x+1再使用x的值,而x++是先使用x的值再执行x=x+1.如果 x的原值是5,则
对于y=++x y的值为6.
对于y=x++ y的值为5,然后x的值变为6.
3 算术混合运算的精度
精度从”底”到”高”排列的顺序是
byte short int long float double
Java将按运算符两边的操作元的最高精度保留结果的精度,例如
5/2的结果是2,要想得到2.5,必须写成5.0/2或5.0f/2.
char型数据和整型数据运算结果的精度是int.例如
byte x=7;
那么
‘B’+x;
的结果是int型,因此下列写法是不正确的,
char ch=’B’+x;
应当写成
char ch=(char)(’B’+x);
4 关系运算符与关系表达式
关系运算符用来比较两个值的关系.关系运算符的运算结果是boolean 型,当运算符对应的关系成立时,运算结果是true,否则是false.例如,10<9的结果是false,5>1的结果是true,3!=5的结果是true,10>20-17的结果为true,因为算术运算符的级别高于关系运算符,10>20-17 相
当于10> 20-17 ,结果当然是true.
结果为数值型的变量或表达式可以通过关系运算符形成关系表达式.如,4>8,(x+y)>80.
5 逻辑运算符与逻辑表达式
逻辑运算符包括 &&,||,!.其中&&,||为二目运算符,实现逻辑与,逻辑或 为单目运算符,实现逻辑非.逻辑运算符的操作元必须是boolean 型数据 ,逻辑运算符可以用来连接关系表达式.
给出了逻辑运算符的用法和含义
逻辑运算符
结果为boolean型的变量或表达式可以通过逻辑运算符合成为逻辑表达式.
用逻辑运算符进行逻辑运算
例如,2>8&&9>2 的结果为false,2>8||9>2 的结果为true.由于关系运算符的级别高于&&,||的级别,2>8&&8>2相当于 2>8 && 9>2 .
逻辑运算符”&&”和”||”也称做短路逻辑运算符,这是因为当op1 的值是false 时,”&&”运算符在运算时不再去计算op2 的值,直接就得出op1&&op2 的结果是false.当op1 的值是true时,”||”运算符号在运算时不再去计算op2的值,直接就得出op1|op2的结果是true.比如,x
的初值是1,那么经过下列逻辑比较运算后,
((y=1)==0))&&((x=6)==6));
x的值仍然是1.经过下列逻辑比较运算后,
((y=1)==1))&&((x=6)==6));
x的值将变为6.
6 赋值运算符与赋值表达式
赋值运算符 =.
赋值运算符是双目运算符,左面的操作元必须是变量,不能是常量或表达式.设x 是一个整型变量,y 是一个boolean 型变量,x=20 和y = true 都是正确的赋值表达式,赋值运算符的优先级较低,是14 级,结合方向右到左.赋值表达式的值就是”=“左面变量的值.注意不要将赋值运算符”=“与等号运算符”==“混淆.
7 位运算符
我们知道整型数据在内存中以2 进制的形式表示,比如一个int 型的变量在内存中占4个字节共32位,int 型数据7的2进制表示是
00000000 00000000 00000000 00000111
左面最高位是符号位,最高位是0表示正数,1表示负数.负数采用补码表示,比如-8 的进制是
111111111 111111111 1111111 11111000
这样我们就可以对整型数据进行按位的运算,比如,对两个整型数据对应的位进行运算得到一个新的整型数据
1 ”按位与”运算符
“&”是双目运算符,对两个整型数据a,b 按位进行运算,运算结果是一个整型数据c.运算法则是 如果a,b 两个数据对应位都是1,则c 的该位是1,否则是0.如果b 的精度高于a,那么结果c的精度和b相同.
2 ”按位或”运算符
“|”是双目运算符.对两个整型数据a,b 按位进行运算,运算结果是一个整型数据c.运算法则是 如果a,b 两个数据对应位都是0,则c 的该位是0,否则是1.如果b 的精度高于与a,那么结果c的精度和b相同.
3 ”按位非”运算符
“~”是单目运算符.对一个整型数据a 按位进行运算,运算结果是一个整型数据c.运算法则是 如果a对应位都是0,则c的该位是1,否则是1.
“按位异或”运算符
4 ”^”是双目运算符.对两个整型数据a,b按位进行运算,运算结果是一个整型数据c.运算法则是 如果a,b 两个数据对应位相同,则c 的该位是0,否则是1.如果b 的精度高于与a,那么结果c的精度和b相同.
由异或运算法则可知
a^a=0,
a^0=a.
因此,如果c=a^b,那么a=c^b,即用同一个数对数a进行两次”异或”运算的结果又是数a.在下面的例子1 中,利用”异或”运算的性质,对几个字符进行加密并输出密文,然后再解密.
例子1
class Example1
{ public static void main(String args[])
{char a1='十',a2='点',a3='进',a4='攻';
char secret='8';
a1=(char)(a1^secret); a2=(char)(a2^secret);
a3=(char)(a3^secret); a4=(char)(a4^secret);
System.out.println("密文:"+a1+a2+a3+a4);
a1=(char)(a1^secret); a2=(char)(a2^secret);
a3=(char)(a3^secret); a4=(char)(a4^secret);
System.out.println("原文:"+a1+a2+a3+a4);
}
}
位运算符也可以操作逻辑型数据,法则是
当a,b都是true时,a&b是true,否则a&b是false.
当a,b都是false时,a|b是false,否则a|b是true.
当a是true时,~a是false 当a是false时,~a是true.
位运算符在操作逻辑型数据时,与逻辑运算符&&,||,, 不同的是 位运算符要计算完a和b的之后再给出运算的结果.比如,x的初值是1,那么经过下列逻辑比较运算后,
((y=1)==0))&&((x=6)==6));
x的值仍然是1,但是如果经过下列位运算之后,
((y=1)==0))&((x=6)==6));
x的值将是6.
位运算符也可以操作字符数据,但运算结果是int 型数据,例如
char x=’a’,y=’b’;
那么
x^y,x&y,x^y, x
的结果是int型.
通过下面的例子可以比较出短路逻辑运算和位运算的不同.
例子2
class Example2
{ public static void main(String args[])
{ int x,y=10;
if(((x=0)==0)||((y=20)==20))
{ System.out.println("现在y的值是:"+y);
}
int a,b=10;
if(((a=0)==0)|((b=20)==20))
{ System.out.println("现在b的值是:"+b);
}
}
}
8 instanceof 运算符
该运算符是双目运算符,左面的操作元是一个对象 右面是一个类.当左面的对象是右面的类创建的对象时,该运算符运算的结果是true ,否则是false.
9 运算符综述
Java 的表达式就是用运算符连接起来的符合Java 规则的式子.运算符的优先级决定了表达式中运算执行的先后顺序.例如,x<y&&!z相当于(x<y)&&(!z),没有必要去记忆运算符号的优先级别,在编写程序时可尽量的使用括号 运算符号来实现你想要的运算次序,以免产生难以阅读或含糊不清的计算顺序.运算符的结合性决定了并列相同级别的运算符的先后顺序,例如,加减的结合性是从左到右,8-5+3 相当于 8-5 +3.逻辑否运算符 的结合性是右到左, x 相当于!(!x).表3.4是Java所有运算符的优先级和结合性,有些运算符我们没有介绍,可参见相关书籍.
运算符的优先级和结合性
1324
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
