咫尺天涯

eclipse debug (调试) 学习心得 (转)

Absolutely — Sun, 06 Jul 2008 20:35:14 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/212101 发表时间: 2008年07月06日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1.Step Into (also F5) 跳入
2.Step Over (also F6) 跳过
3.Step Return (also F7) 执行完当前method，然后return跳出此method
4.step Filter 逐步过滤一直执行直到遇到未经过滤的位置或断点(设置Filter:window-preferences-java-Debug-step Filtering)
5.resume 重新开始执行debug,一直运行直到遇到breakpoint。
例如：A和B两个断点，debug过程中发现A断点已经无用,去除A断点，运行resume就会跳过A直接到达B断点。
6.hit count 设置执行次数适合程序中的for循环(设置 breakpoint view-右键hit count)
7.inspect 检查运算。执行一个表达式显示执行值
8.watch 实时地监视对象、方法或变量的变化

9.我们常说的断点(breakpoints)是指line breakpoints,除了line breakpoints,还有其他的断点类型：field(watchpoint)breakpoint,method breakpoint ,exception breakpoint.
10.field breakpoint 也叫watchpoint(监视点) 当成员变量被读取或修改时暂挂
11.添加method breakpoint 进入/离开此方法时暂挂(Run-method breakpoint)
12.添加Exception breakpoint 捕抓到Execption时暂挂(待续...)
断点属性：
1.hit count 执行多少次数后暂挂用于循环
2.enable condition 遇到符合你输入条件(为ture\改变时)就暂挂
3.suspend thread 多线程时暂挂此线程
4.suspend VM 暂挂虚拟机

13.variables 视图里的变量可以改变变量值，在variables 视图选择变量点击右键--change value.一次来进行快速调试。
14.debug 过程中修改了某些code后--〉save&build-->resume-->重新暂挂于断点

15.resume 当debug调试跑出异常时,运行resume,重新从断点开始调试
16.如果一行有很多方法,
当第一次按F5键就跳入这一行第一个方法,F6一步一步调试,F7跳出这方法.
当第二次按F5键就跳入这一行第二个方法,F6一步一步调试,F7跳出这方法.
以此类推.想进入这一行第几个方法,就按几次F5和F7.
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

错误：selection does not contain a main type

Absolutely — Sun, 08 Jun 2008 11:25:19 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/201282 发表时间: 2008年06月08日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

今天在Eclipse上新建了一个项目，编写并运行程序的时候弹出一个“Launch Error”错误对话框，曰：selection does not contain a main type。再编写一个简单的HelloWorld程序测试，发现结果一样。
上网查找原因，找到一个解决办法：
出现这个问题，是因为java文件不在项目的src路径内，也就是说源代码未被eclipse编译，字节码不存在无法运行了。在项目名上右键 -> Builder Path -> Configure Build Path -> 选择Source面板,再点Add Folder, 把源代码所在的包路径的上层目录加进来.
操作起来挺麻烦的，弄了好一会也没弄好，干脆自己找解决办法好了。
我再次新建一个项目，编写程序并运行，发现没有该错误，奇怪了。
仔细想想两个项目的不同之处，不同的地方就是在新建项目的时候第一个项目勾选了Java Settings下的Allow output folders for source folders，而第二个项目则没有勾选，莫非问题就出现在这里？
重新再新建已项目，勾选Allow output folders for source folders选项，编写程序运行，果然再次发现selection does not contain a main type错误。
问题解决。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

JDK6.0和Tomcat6.0的兼容问题

Absolutely — Fri, 30 May 2008 14:24:14 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/198668 发表时间: 2008年05月30日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

前天重装了系统，再次安装JDK6.0和Tomcat6.0之后发现Tomcat无法顺利启动。
上一个系统也是用相同的JDK和Tomcat，但却没这样的问题。
最后百度了一下，终于找到了解决办法：
（1）将JDK1.6目录下bin文件夹中的msvcr71.dll复制到tomcat中bin文件夹中，这样可以成功tomcat；
（2）直接启动tomcat--bin--tomcat6.exe，出现DOS框后稍等一会就可以启动tomcat的服务。
据说是JDK6.0和Tomcat6.0之间的兼容问题，具体原因还不清楚，先记下了。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

大师的经典

Absolutely — Tue, 22 Apr 2008 00:05:01 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/185217 发表时间: 2008年04月22日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

惭愧，好些天没写blog，食言了。。。。。
倒不是不想写，而是觉得，这样直接抄书，实在是没意思，浪费JE的资源，污染大家的视觉，还不如不写更好。
当然，这么些天虽然没写blog，可Java的学习却没放下，书本，还是在看的。
前两天终于把《Thinking in Java》给买回来了，非常非常厚的一本书，将近九百页，看起来很是吓人。书虽厚，可是并不晦涩，很容易看得懂，而且讲得很透彻，不愧为大师之作。当然，这书并不适合初学者看，不过如果把Java基本知识体系熟悉之后，回来再看这书，收获颇大，知其然也知其所以然。
这两天也翻阅了夏昕的《深入浅出hibernate》，读起来直让人捧腹大笑。“是的，也许并非完全无法控制，如果我们愿意，大可发E-mail给埃里森，说由于我们的系统原本是针对SQL Server设计，现在需要从SQL Server迁移到Oracle，产生了这样那样的问题，所以Oracle必须提供这样的功能支持，还有那样的函数接口，然后坐在电脑目前痴心等待......，直到牙齿掉光，头发发白”。类似的句子还有很多，让人忍俊不禁，很容易就理解了作者所要表达的意思。
所以说，看书得看好书，呵呵。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Java笔记之九：基本数据类型转换

Absolutely — Fri, 11 Apr 2008 02:44:56 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/181529 发表时间: 2008年04月11日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

学完数据类型，接着就要学不同类型之间的转换了。

1、基本数据类型的转换是指由系统根据转换规则自动完成，不需要程序员明确地声明不同数据类型之间的转换。转换在编译器执行，而不是等到运行期再执行。
2、基本数据类型的转换在赋值、方法调用和算术运算三种情况下都会发生。在进行方法调用时，数据类型指调用方法向被调用方法传递参数，即实参和型参类型不一致，从而发生了类型转换。
3、赋值和方法调用的基本数据类型转换规则一样。合法的基本类型转换原则是指从取值范围窄的类型向取值范围宽的类型转换，如果是从取值范围宽的类型向取值范围窄的类型转换，则会产生编译错误。
4、具体规则：
（1）布尔型和其它基本数据类型之间不能相互转换；
（2）byte型可以转换为short、int、、long、float和double；
（3）short可转换为int、long、float和double；
（4）char可转换为int、long、float和double；
（5）int可转换为long、float和double；
（6）long可转换为float和double；
（7）float可转换为double；
也就是说，只能有取值窄的范围向宽范围转换，反之则不行。
5、Java中无后缀数字型，文字型共有两种默认类型，无小数点的整数型文字值、默认类型为整型int，带有小数点的浮点数型文字值，默认类型为双精度double。
6、在赋值语句中，默认类型为整型的无小数点整数型文字值作为右操作数时，可以赋值给取值范围比整型小的变量，前提是文字值对于的实际数值在变量类型的取值范围内。而默认类型为双精度的带有小数点的浮点数型文字值只能赋值给双精度型变量，不能赋值给单精度型变量。
7、基本数据类型的转换在算术运算情况下，正对单操作数运算符和双操作数运算符的转换规则是不一样的。
但操作数运算符算术运算时基本转换规则如下：
（1）当运算符为取正运算符（+）。取负运算符（-）或按位取反运算符（~）时，如果操作数为byte、char或short，则先被转换为int，再参与运算。
（2）当运算符为自动递增运算符（++）或自动递减运算符（--）时，如果操作数为byte，short或char，则不用先被转换为int，而是直接参与算术运算，且运算结果类型也不变。
（3）如果操作数为int或long，则无论运算符为何种单操作数运算符，均不发生类型转换，且运算结果类型也不变。
双操作数运算符算术运算时基本转换规则如下：
（1）如操作数之一为double，则另一个操作数先被转化为double，再参与算术运算。
（2）如两操作数均不为double，当操作数之一为float，则另一操作数先被转换为float，再参与运算。
（3）如两操作数均不为double或float，当操作数之一为long，、则另一操作数先被转换为long，再参与算术运算。
（4）如两操作数均不为double、float或long，则两操作数先被转换为int，再参与运算。
（5）如采用+=、*=等缩略形式的运算符，系统会自动强制将运算结果转换为目标变量的类型。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Java笔记之八：对象数据类型（3）

Absolutely — Thu, 10 Apr 2008 02:48:06 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/181069 发表时间: 2008年04月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

5、Data类和Calendar类
Java没有提供时间日期的简单数据类型，而是采用类对象来处理时间和日期，主要有Date类和Calendar类。
Date类的构造方法：
（1）Date（）：获取当前系统的日期和时间
（2）Date（long date）：以长整数形式来生成指定的日期和时间
Date主要成员方法：
（1）把日期转换为字符串
public String toString()
（2）测定日期对象是否在指定日期和时间之后
public boolean after(Date when)
（3）测定日期对象是否在指定日期和时间之前
public boolean beforn(Date when)
（4）比较两个日期和时间是否相等
public boolean equals(Object obj)
Calendar类提供了特定时间日期如YEAR、MONTH、DAY_OF_YEAR等日历域之间进行转换的抽象类。
Calendar的常用成员属性：
（1）使用整数表示的年份
public static final int YEAR
（2）使用整数表示的月份
public static final int MONTH
（3）使用整数表示的月内第几天
public static final int DAY_OF_MONTH
（4）使用整数表示的年内第几天
public static final int DAY_OF_YEAR
（5）使用整数表示的周内第几天
public static final int DAY_OF_WEEK
（6）使用整数表示的小时数
public static final int HOUR_OF_DAY
（7）使用整数表示的分钟数
public static final int MINUTE
（8）使用整数表示的秒数
public static final int SECOND
（9）使用整数表示的毫秒数
public static final int MILLISECOND
Calendar类的常用成员方法：
（1）获得当前系统时间日期
public static Calendar getInstance()
（2）根据年月日的整数值生成日历类型
public final voud set(int year,int month,int date)
（3）根据年月日时分秒的整数值生成日历类型
public final voud set(int year,int montu,int date,
int hourOfDay,int minute,int second)
（4）使用指定的Date类实例设置Calendar类实例
public final voud setTime(Date date)
（5）使用Calendar类实例转换为Date类型
public final Date getTime()
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Java笔记之七：对象数据类型（3）

Absolutely — Wed, 09 Apr 2008 01:27:15 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/180669 发表时间: 2008年04月09日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

3、Character类
Java采用ASCII字符集的基础之上扩充的Unicode字符集来定义字符类型，即采用两个字节的无符号整数来表示。Java把char封装为Character类，把字符串封装为String类。
字符类型以两个字节表示一个字符，它可以转化为整数。字符常量使用单引号来标志一个字母。使用转义字符'\'来标记特殊字符。
Character类成员属性很多，这里介绍两个常用的。
（1）MAX_VALUE:字符类型的最大值，值为'\uFFFF';
（2）MIN_VALUE:字符类型的最小值，值为'\u0000'。
Character类的构造方法：
public character(char value)
Character常见的成员方法：
（1）判断字符是否为字母
public static boolean isLetter(char ch)
（2）判断字符是否为数字
public static boolean isDigit(char ch)
（3）把字符转化为小写
public static char toLowerCase(char ch)
（4）判断字符是否为空格
public static boolean isWhitespace(char ch)
（5）将字符转换为大写
public static char toUpperCase(char ch)

4、Boolean类
在控制程序运行时需要对变量进行逻辑判断，也就需要定义逻辑类型的变量。Java把boolean封装为Boolean类。
Boolean成员属性：
（1）TRUE:对应于boolean的true；
（2）FALSE:对应于boolean的false。
Boolean的构造方法；
（1）根据布尔值建立类实例
public Boolean(boolean value)
（2）根据字符串值建立类实例
public Boolean(String s)
Boolean类的常用成员方法：
（1）判断一个表达式是否成立
public static boolean parseBoolean(String s)
（2）把逻辑值转化为字符串形式
public static String toString(boolean b)

接下来还有个Date类和Calendar类，这两个是大头，留到下次吧。。。。。
有点像罗列，不过，算了。。。。。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Java笔记之六：对象数据类型（2）

Absolutely — Mon, 07 Apr 2008 00:17:49 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/179947 发表时间: 2008年04月07日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

2、Java按照数据位数不同，把实数分为浮点数和双精度两种。
float被封装成为Float类。
Float 成员属性有：
（1）MAX_VALUE:表示最大浮点数，值为（2-2^(-23))*2^127。
（2）MIN_VALUE:表示最小非负的浮点数，值为2^(-149)。
（3）POSITIVE_INFINITY:表示正无穷浮点数常量。
（4）NEGATIVE_INFINITY:表示负无穷浮点数常量。
（5）SIZE:表示浮点数的二进制位数。
Float类的构造方法：
（1）public Float(float value)。
（2）public Float(double value)。
（3）public Float(String s)
Float常见成员方法：
（1）把字符串转换为浮点数：
public static float parseFloat(String s) throws NumberFormatException
（2）把浮点数类型转换为字符串表示形式：
public String toString( )
public static String toString(float f)
（3）比较两个浮点数类型;
public int compareTo(Float anotherFloat)
（4）把浮点数转换为短整数：
public short shortValue( )
（5）把浮点数转换为int整数：
public int intValue( )
（6）使用字符串新建一个Float类实例：
public static float parseFloat(String s) throws NumberFormatException

Java把双精度数double封装成Double类，其成员属性、构造方法和成员方法与Float类似。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Java笔记之五：对象数据类型（1）

Absolutely — Sat, 05 Apr 2008 13:02:19 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/179645 发表时间: 2008年04月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1、Integer类
Java对于基本数据类型int进行了封装，形成了Integer类。Integer是一个对象，所以应该从认识类的次序，即成员属性、构造方法和成员属性三方面来学习Integer类。
Integer常用成员属性有：
（1）MAX_VALUE表示最大整数值，其值为2的31次方-1；
（2）MIN_VALUE表示最小整数值，其值为2的负31次方。
Integer类构造方法有：
（1）public Integer（int value）
（2）public Integer（Strings）
因此建立的Integer类实例哟两种形式：
Integer A = new Integer(1);
Integer B = new Integer("1").
Integer的成员方法有20多个，常用方法有：
（1）比较两个Integer类实例大小的方法
public int compareTo(Integer anotherInteger)
如有Integer实例A和B，两种相比较：
int result = A.compareTo(B);
如A和B相等，返回result为0；
如A>B,返回result>0;
如A（2）把字符串转换为Integer类实例
public static int parseInt(String s) throws NumberFormatException；
public static int parseInt(String s,int radix) throws NumberFormatException
这方法会抛出异常，如果S有数字外的字符就会出现转换错误。第二个方法的参数radix表示进制，用它可进行进制的转换。注意方法是static的，不需使用new来建立实例。
（3）把一个Integer类实例转换为二进制形式字符串
public static String toBinaryString(int i)
（4）把一个Integer类实例转换为十进制字符串
public static String toString(int i)
（5）比较两Integer类实例是否相等。和compareTo()不同，只比较是否相等，不是大小，要着重注意两个的区别。还有就是别和==混淆了。
public boolean equals(Object obj)
（6）把简单类型int转换为对象类型Integer
public static Integer valueOf(int i)
（7）把对象类型Integer转换为简单类型int
public int intValue()

以上只是常见的Integer类成员方法，更多的要去参阅API.
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Java笔记之四：Java语言基本元素（3）

Absolutely — Wed, 02 Apr 2008 23:21:22 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/179019 发表时间: 2008年04月02日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

6、运算符的优先级
运算符含义优先级
（）圆括号 1
++，-- 单目加、减1 2
~，！，- 按位取反、逻辑非、取负 3
*，/，% 乘、除、取余 4
+，- 加、减 5
<<,>>,>>> 循环左、右移，无符号右移 6
<,>,<=,>= 小于,大,小于等于,大于等于 7
==,!= 等于、不等于 8
& 位与 9
^ 位异或 10
| 位或 11
&& 逻辑与 12
|| 逻辑或 13
?: 三目条件运算符 14
=.+=,-=,*=,/=,%=,^=,&=,|=,<<=,>>==,>>>= 赋值，赋值组合符 15
（1）同级运算符中，自左向右；
（2）Java中还有表示属于关系的点操作符（.），表示对象的实例运算（instanceof），
表示数组下标运算符（[]），表示建立对象的初始运算符（new）；
（3）.和[]的优先级为1；
（4）instanceof的优先级为7
（5）new的优先级在2和3之间。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Java笔记之三：Java语言基本元素（2）

Absolutely — Tue, 01 Apr 2008 23:51:10 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/178609 发表时间: 2008年04月01日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

今天接下来学Java基本元素的常量与变量，运算符。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

5、运算符
运算符当然少不了，Java中运算符主要包括算术运算符、关系运算符、逻辑运算符、条件运算符、位运算符和组合运算符。
（1）算术运算符
赋值（=）：把一常量或变量值赋予另一变量。
加法（+）：与数学加法含义相同。
减法（-）：与数学减法含义相同。
乘法（*）：与数学乘法含义相同。
除法（/）：与数学除法含义相同。
取余（%）：取除法余数
加一（++）：一目运算符，计算结果实在当前变量值的基础上加一。
减一（--）：一目运算符，计算结果是在当前变量值的基础上减一。
取负（-）：相当于乘以（-1）。
（2）关系运算符
大于：>
大于等于：>=
小于：<
小于等于：<=
等于：==，这个可不要和赋值运算符弄混淆了，^^
不等于：！=
Java还有一个特殊的比较运算符，就是用于测试对象类型的instanceof比较运算符。instanceof用于在运行期检查一个对象所属类型，左操作数是一个对象引用表达式，通常为一个引用变量或数组元素，可取值null，则比较结果仅返回false，不抛出异常。右操作数必须是一个类、接口或数组，但不能是java.lang.Class或一个代表类名称的字符串对象。
（3）逻辑运算符
AND（&&）：逻辑与运算，当两者都为真时为真，否则为假。
NOT（！）：逻辑非运算，取法的意思。
OR （||）：逻辑或运算，当两者都为假时为假，否则为真。
（4）条件运算符
<条件>？<条件为真的处理动作>：<条件为假的处理动作>
（5）位运算符
位运算符与逻辑运算符基本相似，不过后者的对象只是表示真和假的二值运算，位运算符的对象则是二进制数。Java语言中字节、字符和整数等都可以转换为二进制，所以位运算符的对象也可以是它们。常见位运算符有：
按位进行与运算： &
按位进行或运算： |
按位进行位异运算： ^
按位进行取反运算： ~
按位进行循环左移：<<，运算符左侧对象左移由右侧指定的位数，低位补0，最高位抛弃。带符号的左移位运算相当于对左操作数进行乘2运算。
按位进行循环右移：>>，运算符左侧对象右移由右侧指定的位数，若值为正，在最高位插入0，若值为负，在最高位插入1，即移入的最高位和原最高符号位相同。带符号的右移位运算相当于对左边的运算对象进行除2运算。
按位进行无符号右移：>>>，无论运算符左边的运算对象取值正负，都在高位插入0，即移入位始终补0.
要注意是没有按位进行无符号左移的。位运算符的操作数只能是整数，char,byte,short,
int和long,进行位运算时，总是先将字符型值、字节型值和短整型值转换为整型再进行位运算。位运算符游标的操作数用于指定移动的位数，按规定其不应超过左侧数的进制表示位数。
（6）组合运算符
以上基本运算符可组合使用，成为组合运算符。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
很多细节没补全，先挖个坑，慢慢填吧，睡觉去。。。。。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

JAVA编程规范

Absolutely — Mon, 31 Mar 2008 01:14:03 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/177889 发表时间: 2008年03月31日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

今天周日，休息，就摘录些东西好了。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
命名规范

　　定义这个规范的目的是让项目中所有的文档都看起来像一个人写的，增加可读性，减少项目组中因为换人而带来的损失。(这些规范并不是一定要绝对遵守，但是一定要让程序有良好的可读性)

　　Package 的命名

　　Package 的名字应该都是由一个小写单词组成。

　　Class 的命名

　　Class 的名字必须由大写字母开头而其他字母都小写的单词组成

　　Class 变量的命名

　　变量的名字必须用一个小写字母开头。后面的单词用大写字母开头。

　　Static Final 变量的命名

　　Static Final 变量的名字应该都大写，并且指出完整含义。

　　参数的命名

　　参数的名字必须和变量的命名规范一致。

　　数组的命名

　　数组应该总是用下面的方式来命名:

　　byte[] buffer;

　　而不是:

　　byte buffer[];

　　方法的参数

　　使用有意义的参数命名，如果可能的话，使用和要赋值的字段一样的名字:

　　SetCounter(int size){

　　this.size = size;

　　}

　　Java 文件样式

　　所有的 Java(*.java) 文件都必须遵守如下的样式规则

　　版权信息

　　版权信息必须在 java 文件的开头，比如:

　　/**

　　* Copyright ® 2000 Shanghai XXX Co. Ltd.

　　* All right reserved.

　　*/

　　其他不需要出现在 javadoc 的信息也可以包含在这里。

　　Package/Imports

　　package 行要在 import 行之前，import 中标准的包名要在本地的包名之前，而且按照字母顺序排列。如果 import 行中包含了同一个包中的不同子目录，则应该用 * 来处理。

　　package hotlava.net.stats;

　　import java.io.*;

　　import java.util.Observable;

　　import hotlava.util.Application;

　　这里 java.io.* 使用来代替InputStream and OutputStream 的。

　　Class

　　接下来的是类的注释，一般是用来解释类的。

　　/**

　　* A class representing a set of packet and byte counters

　　* It is observable to allow it to be watched, but only

　　* reports changes when the current set is complete

　　*/

　　接下来是类定义，包含了在不同的行的 extends 和 implements

　　public class CounterSet

　　extends Observable

　　implements Cloneable

　　Class Fields

　　接下来是类的成员变量:

　　/**

　　* Packet counters

　　*/

　　protected int[] packets;

　　public 的成员变量必须生成文档(JavaDoc)。proceted、private和 package 定义的成员变量如果名字含义明确的话，可以没有注释。

　　存取方法

　　接下来是类变量的存取的方法。它只是简单的用来将类的变量赋值获取值的话，可以简单的写在一行上。

　　/**

　　* Get the counters

　　* @return an array containing the statistical data. This array has been

　　* freshly allocated and can be modified by the caller.

　　*/

　　public int[] getPackets() { return copyArray(packets, offset); }

　　public int[] getBytes() { return copyArray(bytes, offset); }

　　public int[] getPackets() { return packets; }

　　public void setPackets(int[] packets) { this.packets = packets; }

　　其它的方法不要写在一行上

　　构造函数

　　接下来是构造函数，它应该用递增的方式写(比如:参数多的写在后面)。

　　访问类型 ("public", "private" 等.) 和任何 "static", "final" 或 "synchronized" 应该在一行中，并且方法和参数另写一行，这样可以使方法和参数更易读。

　　public

　　CounterSet(int size){

　　this.size = size;

　　}

　　克隆方法

　　如果这个类是可以被克隆的，那么下一步就是 clone 方法:

　　public

　　Object clone() {

　　try {

　　CounterSet obj = (CounterSet)super.clone();

　　obj.packets = (int[])packets.clone();

　　obj.size = size;

　　return obj;

　　}catch(CloneNotSupportedException e) {

　　throw new InternalError("Unexpected CloneNotSUpportedException: " + e.getMessage());

　　}

　　}

　　类方法

　　下面开始写类的方法:

　　/**

　　* Set the packet counters

　　* (such as when restoring from a database)

　　*/

　　protected final

　　void setArray(int[] r1, int[] r2, int[] r3, int[] r4)

　　throws IllegalArgumentException

　　{

　　//

　　// Ensure the arrays are of equal size

　　//

　　if (r1.length != r2.length || r1.length != r3.length || r1.length != r4.length)

　　throw new IllegalArgumentException("Arrays must be of the same size");

　　System.arraycopy(r1, 0, r3, 0, r1.length);

　　System.arraycopy(r2, 0, r4, 0, r1.length);

　　}

　　toString 方法

　　无论如何，每一个类都应该定义 toString 方法:

　　public

　　String toString() {

　　String retval = "CounterSet: ";

　　for (int i = 0; i < data.length(); i++) {

　　retval += data.bytes.toString();

　　retval += data.packets.toString();

　　}

　　return retval;

　　}

　　}

　　main 方法

　　如果main(String[]) 方法已经定义了, 那么它应该写在类的底部.

　　代码编写格式

　　代码样式

　　代码应该用 unix 的格式，而不是 windows 的(比如:回车变成回车+换行)

　　文档化

　　必须用 javadoc 来为类生成文档。不仅因为它是标准，这也是被各种 java 编译器都认可的方法。使用 @author 标记是不被推荐的，因为代码不应该是被个人拥有的。

　　缩进

　　缩进应该是每行2个空格. 不要在源文件中保存Tab字符. 在使用不同的源代码管理工具时Tab字符将因为用户设置的不同而扩展为不同的宽度.

　　如果你使用 UltrEdit 作为你的 Java 源代码编辑器的话，你可以通过如下操作来禁止保存Tab字符, 方法是通过 UltrEdit中先设定 Tab 使用的长度室2个空格，然后用 Format|Tabs to Spaces 菜单将 Tab 转换为空格。

　　页宽

　　页宽应该设置为80字符. 源代码一般不会超过这个宽度, 并导致无法完整显示, 但这一设置也可以灵活调整. 在任何情况下, 超长的语句应该在一个逗号或者一个操作符后折行. 一条语句折行后, 应该比原来的语句再缩进2个字符.

　　{} 对

　　{} 中的语句应该单独作为一行. 例如, 下面的第1行是错误的, 第2行是正确的:

　　if (i>0) { i ++ }; // 错误, { 和 } 在同一行

　　if (i>0) {

　　i ++

　　}; // 正确, { 单独作为一行

　　} 语句永远单独作为一行.

　　如果 } 语句应该缩进到与其相对应的 { 那一行相对齐的位置。

　　括号

　　左括号和后一个字符之间不应该出现空格, 同样, 右括号和前一个字符之间也不应该出现空格. 下面的例子说明括号和空格的错误及正确使用:

　　CallProc( AParameter ); // 错误

　　CallProc(AParameter); // 正确

　　不要在语句中使用无意义的括号. 括号只应该为达到某种目的而出现在源代码中。下面的例子说明错误和正确的用法:

　　if ((I) = 42) { // 错误 - 括号毫无意义

　　if (I == 42) or (J == 42) then // 正确 - 的确需要括号
程序编写规范

　　exit()

　　exit 除了在 main 中可以被调用外，其他的地方不应该调用。因为这样做不给任何代码代码机会来截获退出。一个类似后台服务地程序不应该因为某一个库模块决定了要退出就退出。

　　异常

　　申明的错误应该抛出一个RuntimeException或者派生的异常。

　　顶层的main()函数应该截获所有的异常，并且打印(或者记录在日志中)在屏幕上。

　　垃圾收集

　　JAVA使用成熟的后台垃圾收集技术来代替引用计数。但是这样会导致一个问题:你必须在使用完对象的实例以后进行清场工作。比如一个prel的程序员可能这么写:

　　..{

　　FileOutputStream fos = new FileOutputStream(projectFile);

　　project.save(fos, "IDE Project File");

　　}

　　...

　　除非输出流一出作用域就关闭，非引用计数的程序语言，比如JAVA，是不能自动完成变量的清场工作的。必须象下面一样写:

　　FileOutputStream fos = new FileOutputStream(projectFile);

　　project.save(fos, "IDE Project File");

　　fos.close();

　　Clone

　　下面是一种有用的方法:

　　implements Cloneable

　　public

　　Object clone()

　　{

　　try {

　　ThisClass obj = (ThisClass)super.clone();

　　obj.field1 = (int[])field1.clone();

　　obj.field2 = field2;

　　return obj;

　　} catch(CloneNotSupportedException e) {

　　throw new InternalError("Unexpected CloneNotSUpportedException: " + e.getMessage());

　　}

　　}

　　final 类

　　绝对不要因为性能的原因将类定义为 final 的(除非程序的框架要求)

　　如果一个类还没有准备好被继承，最好在类文档中注明，而不要将她定义为 final 的。这是因为没有人可以保证会不会由于什么原因需要继承她。

　　访问类的成员变量

　　大部分的类成员变量应该定义为 protected 的来防止继承类使用他们。

　　注意，要用"int[] packets"，而不是"int packets[]"，后一种永远也不要用。

　　public void setPackets(int[] packets) { this.packets = packets; }

　　CounterSet(int size)

　　{

　　this.size = size;

　　}

　　编程技巧

　　byte 数组转换到 characters

　　为了将 byte 数组转换到 characters，你可以这么做:

　　"Hello world!".getBytes();

　　Utility 类

　　Utility 类(仅仅提供方法的类)应该被申明为抽象的来防止被继承或被初始化。

　　初始化

　　下面的代码是一种很好的初始化数组的方法:

　　objectArguments = new Object[] { arguments };

　　枚举类型

　　JAVA 对枚举的支持不好，但是下面的代码是一种很有用的模板:

　　class Colour {

　　public static final Colour BLACK = new Colour(0, 0, 0);

　　public static final Colour RED = new Colour(0xFF, 0, 0);

　　public static final Colour GREEN = new Colour(0, 0xFF, 0);

　　public static final Colour BLUE = new Colour(0, 0, 0xFF);

　　public static final Colour WHITE = new Colour(0xFF, 0xFF, 0xFF);

　　}

　　这种技术实现了RED, GREEN, BLUE 等可以象其他语言的枚举类型一样使用的常量。他们可以用 == 操作符来比较。

　　但是这样使用有一个缺陷:如果一个用户用这样的方法来创建颜色 BLACK

　　new Colour(0,0,0)

　　那么这就是另外一个对象，==操作符就会产生错误。她的 equal() 方法仍然有效。由于这个原因，这个技术的缺陷最好注明在文档中，或者只在自己的包中使用。

　　Swing

　　避免使用 AWT 组件

　　混合使用 AWT 和 Swing 组件

　　如果要将 AWT 组件和 Swing 组件混合起来使用的话，请小心使用。实际上，尽量不要将他们混合起来使用。

　　滚动的 AWT 组件

　　AWT 组件绝对不要用 JscrollPane 类来实现滚动。滚动 AWT 组件的时候一定要用 AWT ScrollPane 组件来实现。

　　避免在 InternalFrame 组件中使用 AWT 组件

　　尽量不要这么做，要不然会出现不可预料的后果。

　　Z-Order 问题

　　AWT 组件总是显示在 Swing 组件之上。当使用包含 AWT 组件的 POP-UP 菜单的时候要小心，尽量不要这样使用。

　　调试

　　调试在软件开发中是一个很重要的部分，存在软件生命周期的各个部分中。调试能够用配置开、关是最基本的。

　　很常用的一种调试方法就是用一个 PrintStream 类成员，在没有定义调试流的时候就为 null，类要定义一个 debug 方法来设置调试用的流。

　　性能

　　在写代码的时候，从头至尾都应该考虑性能问题。这不是说时间都应该浪费在优化代码上，而是我们时刻应该提醒自己要注意代码的效率。比如:如果没有时间来实现一个高效的算法，那么我们应该在文档中记录下来，以便在以后有空的时候再来实现她。

　　不是所有的人都同意在写代码的时候应该优化性能这个观点的，他们认为性能优化的问题应该在项目的后期再去考虑，也就是在程序的轮廓已经实现了以后。

　　不必要的对象构造

　　不要在循环中构造和释放对象

　　使用 StringBuffer 对象

　　在处理 String 的时候要尽量使用 StringBuffer 类，StringBuffer 类是构成 String 类的基础。String 类将 StringBuffer 类封装了起来，(以花费更多时间为代价)为开发人员提供了一个安全的接口。当我们在构造字符串的时候，我们应该用 StringBuffer 来实现大部分的工作，当工作完成后将 StringBuffer 对象再转换为需要的 String 对象。比如:如果有一个字符串必须不断地在其后添加许多字符来完成构造，那么我们应该使用 StringBuffer 对象和她的 append() 方法。如果我们用 String 对象代替 StringBuffer 对象的话，会花费许多不必要的创建和释放对象的 CPU 时间。

　　避免太多的使用 synchronized 关键字

　　避免不必要的使用关键字 synchronized，应该在必要的时候再使用她，这是一个避免死锁的好方法。

　　可移植性

　　Borland Jbulider 不喜欢 synchronized 这个关键字，如果你的断点设在这些关键字的作用域内的话，调试的时候你会发现的断点会到处乱跳，让你不知所措。除非必须，尽量不要使用。

　　换行

　　如果需要换行的话，尽量用 println 来代替在字符串中使用"

　　"。

　　你不要这样:

　　System.out.print("Hello,world!

　　");

　　要这样:

　　System.out.println("Hello,world!");

　　或者你构造一个带换行符的字符串，至少要象这样:

　　String newline = System.getProperty("line.separator");

　　System.out.println("Hello world" + newline);

　　PrintStream

　　PrintStream 已经被不赞成(deprecated)使用，用 PrintWrite 来代替她。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
出处虽已不可考究，版权为原作者所有。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Java笔记之二：Java语言基本元素（1）

Absolutely — Sun, 30 Mar 2008 01:55:27 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/177714 发表时间: 2008年03月30日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

听着I need some sleep，直叫人昏昏欲睡。。。。。
废话少说，继续开工。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1、注释。通过对程序注释会增加代码的清晰度，便以日后维护使用。注释内容要简洁，除了注释做什么之外，还要说明为什么要这么做，一名优秀的程序员必须具备对程序充分主席的能力和习惯。
Java支持三种注释形式：
（1）单行：使用“//”作为注释内容的开始符号，不能跨行；
（2）多行：使用“/*...*/”，中间为注释内容；
（3）文档：使用“/**...**/,用javadoc时写入文档，多应包括程序、变量和方法的目的和主要特点。
2、标识符与保留字。从语义上讲，标识符用于表示变量、方法、类和对象的名称；从语法上讲，标识符是以字符、_或$开头的有效字母和数字的组合，注意标识符区分大小写，没有长度限制。而保留字则是合法的标识符，并且是程序设计语言专用的，不允许编程人员使用，Java共有48个保留字。
3、基本数据类型。Java的数据类型分为基本数据类型、对象数据类型和复杂数据类型三类，这里就说下基本类型好了。
基本类型包括字节（byte）、短整型（short）、整型（int）、长整型（long）、浮点数（float）、双精度浮点数（double）、字符（char）和布尔（boolean）.
（1）字节。使用一个字节表示整数值，范围是-128至127，在其前加0表示为八进制数，加0x表示为十六进制，否则为十进制，直接表示数值。
（2）短整数。short类型以两个字节表示整数值，范围是-32768至32767。不同进制表示和字节型相同。
（3）整数。以四个字节来表示整数值，范围是-2147483648至2147483647不同进制表示如字节型。
（4）长整型。以八个字节来表示整数值，范围是-9223372036854775808至9223372036854775807，进行long类型变量赋值时，应在数值后门加上“L”或“l”。
（5）字符。以两字节表示一字符，可转换成整数，表示值非负，表示一个字符的整数值从0到65535。对char类型变量赋值时，必须用单引号作为分隔符。
（6）浮点数。以四个字节组合表示一个实数，范围是1.40239846e至3.4028234e+38。赋值时，其后应加“F”或“f”字符。
（7）双精度数。以八个字节组合表示一个实数，赋值时，其后应该“D”或“d”。
（8）布尔值。表示两种状态，true和false。
4、在程序设计语言中使用常量和变量来表示所存储的数据，在程序运行期间，常量值不能改变，变量值可以改变。
先说常量，Java中常量有两种存在方式：引用Java平台所定义的，编程者自己定义的。常量定义形式为：final <数据类型> <常量名> = <常量值>
final保留字用于标志所定义<常量名>的值在程序编译和运行期间都不能被继承。
数据类型说明该常量的类型，可以是简单数据类型或者用户自定义的数据类型。
至于变量，主要特点是在程序执行过程中所存储的值会发生变化。
定义形式为：<数据类型> <变量名> [=<变量初始值>][,<变量名>[==<变量初始值>]...]
方括号表示内容可选可不选。程序员须清楚地为每变量提供一个名字、数据类型和作用范围。
就先弄这么些吧，困了，睡觉去。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Java笔记之一：开发环境配置

Absolutely — Sat, 29 Mar 2008 01:15:01 +0800

作者: Absolutely 链接：http://absolutely.javaeye.com/blog/177499 发表时间: 2008年03月29日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

汗一个，上网来才发现已经过了十二点了，啥都还没写，得赶紧。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1、下载开发工具JDK，http://java.sun.com/javase/downloads/index.jsp，
这个地址可以下载到最新的JDK开发工具；
2、然后是安装，这个过程也没什么好说的，直接点下一步到结束就完了，默认安装文件夹是C:\Program Files\Java；
3、接下来就是配置PATH了，我的电脑/属性/高级/环境变量，在用户变量或者系统变量都行，选择新建，变量名：PATH，变量值：C:\Program Files\Java\jdk1.6.0_03\bin（我装的是1.6.0_03），确定退出。其实还有个CLASSPATH应该在这里配置，但是我很少做，直接忽略了，不知道会不会有啥后遗症。
4、如果没有设置package的话，现在敲打好程序，就可以编译运行了。在D盘下建立HelloWorld.java文件，然后DOS到D盘下，输入javac HelloWorld.java,编译成功，然后输入java HelloWorld,运行成功；
5、如果设置了package，则要设置CLASSPATH，这话题等明天再添加上来吧，汗；
6、要强调的一点是，java是区分大小写的，这地方很容易出错，要注意。

PS:匆匆忙忙的胡乱敲了些东西，自己也不满意，不过总算写了点东西，赞一个，明天再接再厉。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
补充一下，如果有package时的编译。假如package blue.test，则编译时应该这样：javac -d d:\ HelloWorld.java
java blue.test.HelloWorld
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐