亚洲av无码专区在线电影天堂,亚洲精品国产高清在线观看,亚洲国产专区一区

java中相对�\径，�l�对路径问题�ȝ��

王君 — Tue, 09 Oct 2007 06:10:00 GMT

1.基本概念的理�?br />
　　�l�对路径�Q�绝对�\径就是你的主��上的文件或目录在硬盘上真正的�\径，(URL和物理�\�?例如�Q?br /> C:\xyz\test.txt 代表了test.txt文�g的绝对�\径�?a >http://www.sun.com/index.htm也代表了一�?br /> URL�l�对路径�?br />
　　相对路径�Q�相对与某个基准目录的�\径。包含Web的相对�\径（HTML中的相对目录�Q�，例如�Q�在
Servlet中，"/"代表Web应用的跟目录。和物理路径的相对表�C�。例如："./" 代表当前目录,
"../"代表上��目录。这�U�类似的表示�Q�也是属于相对�\径�?br />
另外关于URI�Q�URL,URN�{�内容，请参考RFC相关文档标准�?br />
RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax,
(http://www.ietf.org/rfc/rfc2396.txt)

2.关于JSP/Servlet中的相对路径和绝对�\径�?br />
2.1服务器端的地址

　　服务器端的相对地址指的是相对于你的web应用的地址�Q�这个地址是在服务器端解析�?br /> �Q�不同于html和javascript中的相对地址�Q�他们是由客��L��览器解析的�Q�也��是说这时�?br /> 在jsp和servlet中的相对地址应该是相对于你的web应用�Q�即相对�?a >http://192.168.0.1/webapp/的�?nbsp;

　　其用到的地方有：
forward�Q�servlet中的request.getRequestDispatcher(address);�q�个address�?br /> 在服务器端解析的�Q�所以，你要forward到a.jsp应该�q�么写：
request.getRequestDispatcher(“/user/a.jsp”)�q�个/相对于当前的web应用webapp�Q?br /> 其绝对地址��是�Q?a >http://192.168.0.1/webapp/user/a.jsp�?nbsp;
sendRedirect�Q�在jsp�?lt;%response.sendRedirect("/rtccp/user/a.jsp");%>

2.22、客��L��的地址

       所有的html��面中的相对地址都是相对于服务器根目�?http://192.168.0.1/)的，
而不�?跟目录下的该Web应用的目�?http://192.168.0.1/webapp/的�?nbsp;
Html中的form表单的action属性的地址应该是相对于服务器根目录(http://192.168.0.1/)的，
所以，如果提交到a.jsp为：action�Q?/webapp/user/a.jsp"或action="<%=request.getContextPath()%>"/user/a.jsp�Q?br /> 　　提交到servlet为actiom�Q?/webapp/handleservlet"
　　Javascript也是在客��L��解析的，所以其相对路径和form表单一栗��?nbsp;

　　因此�Q�一般情况下�Q�在JSP/HTML��面�{�引用的CSS,Javascript.Action�{�属性前面最好都加上
<%=request.getContextPath()%>,以确保所引用的文仉��属于Web应用中的目录�?br /> 另外�Q�应该尽量避免��用类�?.","./","../../"�{�类似的相对该文件位�|�的相对路径�Q�这�?br /> 当文件移动时�Q�很�Ҏ��出问题�?br />

3. JSP/Servlet中获得当前应用的相对路径和绝对�\�?br /> 3.1 JSP中获得当前应用的相对路径和绝对�\�?br /> 根目录所对应的绝对�\�?request.getRequestURI()
文�g的绝对�\�?nbsp;   　:application.getRealPath(request.getRequestURI());
当前web应用的绝对�\�?nbsp;:application.getRealPath("/");
取得��h��文�g的上层目�?new File(application.getRealPath(request.getRequestURI())).getParent()

3.2 Servlet中获得当前应用的相对路径和绝对�\�?br /> 根目录所对应的绝对�\�?request.getServletPath();
文�g的绝对�\�?nbsp;   :request.getSession().getServletContext().getRealPath
(request.getRequestURI())
当前web应用的绝对�\�?nbsp;:servletConfig.getServletContext().getRealPath("/");
     (ServletContext对象获得几种方式�Q?br />        javax.servlet.http.HttpSession.getServletContext()
       javax.servlet.jsp.PageContext.getServletContext()
       javax.servlet.ServletConfig.getServletContext()
     )

4.java 的Class中获得相对�\径，�l�对路径的方�?br /> 4.1单独的Java�c�M��获得�l�对路径
　　�Ҏ��java.io.File的Doc文挡�Q�可�?
默认情况下new File("/")代表的目录�ؓ�Q�System.getProperty("user.dir")�?br /> 一下程序获得执行类的当前�\�?br /> package org.cheng.file;
import java.io.File;

public class FileTest {
    public static void main(String[] args) throws Exception {

  System.out.println(Thread.currentThread().getContextClassLoader().getResource(""));

  System.out.println(FileTest.class.getClassLoader().getResource(""));

　　System.out.println(ClassLoader.getSystemResource(""));
  System.out.println(FileTest.class.getResource(""));
  System.out.println(FileTest.class.getResource("/")); //Class文�g所在�\�?nbsp;
  System.out.println(new File("/").getAbsolutePath());
  System.out.println(System.getProperty("user.dir"));
}
}

4.2服务器中的Java�c�获得当前�\径（来自�|�络�Q?br /> (1).Weblogic

WebApplication的系�l�文件根目录是你的weblogic安装所在根目录�?br /> 例如�Q�如果你的weblogic安装在c:\bea\weblogic700.....
那么�Q�你的文件根路径��是c:\.
所以，有两�U�方式能够让你访问你的服务器端的文�g�Q?br /> a.使用�l�对路径�Q?br /> 比如��你的参数文件放在c:\yourconfig\yourconf.properties�Q?br /> 直接使用 new FileInputStream("yourconfig/yourconf.properties");
b.使用相对路径�Q?br /> 相对路径的根目录��是你的webapplication的根路径�Q�即WEB-INF的上一�U�目录，��你的参数文件放

在yourwebapp\yourconfig\yourconf.properties�Q?br /> �q�样使用�Q?br /> new FileInputStream("./yourconfig/yourconf.properties");
�q�两�U�方式均可，自己选择�?br />
(2).Tomcat

在类中输出System.getProperty("user.dir");昄��的是%Tomcat_Home%/bin

(3).Resin

不是你的JSP攄��相对路径,是JSP引擎执行�q�个JSP�~�译成SERVLET
的�\径�ؓ�?比如用新建文件法��试File f = new File("a.htm");
�q�个a.htm在resin的安装目录下

(4).如何�ȝ��对�\径哪�Q?br />
在Java文�g中getResource或getResourceAsStream均可

例：getClass().getResourceAsStream(filePath);//filePath可以�?/filename",�q�里�?代表web

发布根�\径下WEB-INF/classes

默认使用该方法的路径是：WEB-INF/classes。已�l�在Tomcat中测试�?br />
5.��d��文�g时的相对路径�Q�避免硬�~�码和绝对�\径的使用。（来自�|�络�Q?br /> 5.1 采用Spring的DI机制获得文�g�Q�避免硬�~�码�?br />    参考下面的�q�接内容�Q?br />    http://www.javajia.net/viewtopic.php?p=90213&
5.2 配置文�g的读�?br /> 参考下面的�q�接内容�Q?br /> http://dev.csdn.net/develop/article/39/39681.shtm
5.3 通过虚拟路径或相对�\径读取一个xml文�g�Q�避免硬�~�码
参考下面的�q�接内容�Q?br /> http://club.gamvan.com/club/clubPage.jsp?iPage=1&tID=10708&ccID=8

6.Java中文件的常用操作�Q�复�Ӟ��U�d��Q�删除，创徏�{�）�Q�来自网�l�）
常用 java File 操作�c?nbsp;
http://www.easydone.cn/014/200604022353065155.htm

Java文�g操作大全�Q�JSP中）
http://www.pconline.com.cn/pcedu/empolder/gj/java/0502/559401.html

java文�g操作详解�Q�Java中文�|�）
http://www.51cto.com/html/2005/1108/10947.htm

JAVA 如何创徏\删除\修改\复制目录及文�?br /> http://www.gamvan.com/developer/java/2005/2/264.html

�ȝ��Q?br /> 通过上面内容的��用，可以解决在Web应用服务器端�Q�移动文�Ӟ��查找文�g�Q�复�?br /> 删除文�g�{�操作，同时�Ҏ��务器的相对地址�Q�绝对地址概念更加清晰�?br /> ��参考URI,的RFC标准文挡。同时对Java.io.File. Java.net.URI.�{�内容了解透彻
对其他方面的理解可以更加深入和透彻�?

王君 2007-10-09 14:10 发表评论

王君 — Tue, 09 Oct 2007 05:59:00 GMT

创徏数据库Schema 在本例中�Q�与Customer�c�d��应的数据库表名�ؓCUSTOMERS�Q�它在MySQL数据库中的DDL定义如下�Q?

create table CUSTOMERS (
　　ID bigint not null primary key,
　　NAME varchar(15) not null,
　　EMAIL varchar(128) not null,
　　PASSWORD varchar(8) not null,
　　PHONE int ,
　　ADDRESS varchar(255),
　　SEX char(1) ,
　　IS_MARRIED bit,
　　DESCRIPTION text,
　　IMAGE blob,
　　BIRTHDAY date,
　　REGISTERED_TIME timestamp
　　);

　　
CUSTOMERS表有一个ID字段�Q�它是表的主键，它和Customer�cȝ��id属性对应。CUSTOMERS表中的字�D��用了各种各样的SQL�c�d��

2.4 创徏对象-关系映射文�g

Hibernate采用XML格式的文件来指定对象和关�p�L��据之间的映射。在�q�行�Ӟ��Hibernate��根据这个映��文件来生成各种SQL语句。在本例中，��创��Z��个名为Customer.hbm.xml的文�Ӟ��它用于把Customer�c�L��到CUSTOMERS表，�q�个文�g应该和Customer.class文�g存放在同一个目录下。例�E?-3为Customer.hbm.xml文�g的代码�?

例程2-3 Customer.hbm.xml

　　　　//Hibernate/Hibernate Mapping DTD 2.0
　　//EN"
　　"http://hibernate.sourceforge.net
　　/hibernate-mapping-2.0.dtd">
　　
　　

　　　　table="CUSTOMERS">
　　
　　
　　
　　
　　
　　　　column="NAME"　type="string"
　　not-null="true" />
　　　　column="EMAIL"　　 type="string"
　　not-null="true" />
　　　　column="PASSWORD"　type="string"
　　not-null="true"/>
　　　　column="PHONE"　　 type="int" />
　　　　column="ADDRESS"　 type="string" />
　　　　column="SEX"　　　 type="character"/>
　　　　column="IS_MARRIED"　type="boolean"/>
　　　　column="DESCRIPTION"　type="text"/>
　　　　column="IMAGE"　　　　type="binary"/>
　　　　column="BIRTHDAY"　　 type="date"/>
　　　　column="REGISTERED_TIME"
　　type="timestamp"/>
　　
　　

　　
2.4.1 映射文�g的文档类型定义（DTD�Q?

在例�E?-3的Customer.hbm.xml文�g的开头声明了DTD�Q�Document Type Definition�Q�文档类型定义）�Q�它对XML文�g的语法和格式做了定义。Hibernate的XML解析器将�Ҏ��DTD来核对XML文�g的语法�?

每一�U�XML文�g都有独自的DTD文�g。Hibernate的对�?关系映射文�g使用的DTD文�g的下载网址为：http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd。此外，在Hibernate软�g包的src
etsfhibernate目录下也提供了hibernate-mapping-2.0.dtd文�g。在�q�个文�g中，描述��层元素的代码如下：

　　import*, (class|subclass|joined-subclass)*,
　　query*,sql-query*)>

　　
描述��层元素的子元素的代码如下：

　　meta*,
　　(cache|jcs-cache)?,
　　(id|composite-id),
　　discriminator?,
　　(version|timestamp)?,
　　(property|many-to-one|one-to-one
　　|component|dynamic-component|any
　　|map|set|list|bag|idbag|array
　　|primitive-array)*,
　　((subclass*)|(joined-subclass*))
　　)>

　　
元素是对�?关系映射文�g的根元素�Q�其他元素（即以上DTD代码中括号以内的元素�Q�如子元素）必须嵌入在元素以内。在元素中又嵌套了好多子元素�?

在以上DTD代码中，�q��用了一�p�d��的特�D�符��h��修饰元素�Q�表2-3描述了这些符��L��作用。在创徏自己的对�?关系映射文�g�Ӟ��如果不熟悉某�U�元素的语法�Q�可以参考DTD文�g�?

此外�Q�在映射文�g中，父元素中的各�U�子元素的定义必��ȝ��合特定的��序。例如，�Ҏ��元素的DTD可以看出�Q�必��d��定义子元素，再定义子元素�Q�以下映��代码颠倒了和子元素的位�|�：

table="CUSTOMERS">
column="NAME" type="string"
not-null="true" />
column="EMAIL"
type="string" not-null="true" />

……

Hibernate的XML解析器在�q�行时会抛出MappingException�Q?

[java] 21:27:51,610 ERROR XMLHelper:
48 - Error parsing XML:
XML InputStream (24)
The content of element type "class"
must match "(meta*,(cache|jcs-cache)?,
(
id|composite-id),
discriminator?,(version|timestamp)?,
(property|many-to-one|one-to-one|component|
dynamic-component|any|map|set
|list|bag|idbag|array|primitive-array)*,
(subclass*|joined-subclass*))".

[java] net.sf.hibernate.MappingException:
Error reading resource:
mypack/Customer.hbm.xml
at net.sf.hibernate.cfg.Configuration.addClass
(Configuration.java:357)

2.4.2 把Customer持久化类映射到CUSTOMERS�?

例程2-3的Customer.hbm.xml文�g用于映射Customer�c�R��如果需要映��多个持久化�c�，那么既可以在同一个映��文件中映射所有类�Q�也可以为每个类创徏单独的映��文�Ӟ��映射文�g和类同名�Q�扩展名�?hbm.xml"。后一�U�做法更值得推荐�Q�因为在团队开发中�Q�这有利于管理和�l�护映射文�g�?

元素指定�c�d��表的映射�Q�它的name属性设定类名，table属性设定表名。以下代码表明和Customer�c�d��应的表�ؓCUSTOMERS表：

如果没有讄��元素的table属性，Hibernate��直接以�c�d��作�ؓ表名�Q�也��是��_��在默认情况下�Q�与mypack.Customer�c�d��应的表�ؓCustomer表�?

元素包含一个子元素及多个子元素。子元素讑֮�持久化类的OID和表的主键的映射。以下代码表明Customer�cȝ��id属性和CUSTOMERS表中的ID字段对应�?

元素的子元素指定对象标识�W�生成器�Q�它负责为OID生成惟一标识�W�。本书第5章（映射对象标识�W�）详细介绍了Hibernate提供的各�U�对象标识符生成器的用法�?

子元素设定类的属性和表的字段的映��。子元素主要包括name、type、column和not-null属性�?

1�Q�元素的name属�?

元素的name属性指定持久化�cȝ��属性的名字�?

2�Q�元素的type属�?

元素的type属性指定Hibernate映射�c�d��。Hibernate映射�c�d��是Java�c�d��与SQL�c�d��的桥梁。表2-4列出了Customer�cȝ��属性的Java�c�d��、Hibernate映射�c�d��Q�以及CUSTOMERS表的字段的SQL�c�d��q�三者之间的对应关系�?

�?-4 Java�c�d��、Hibernate映射�c�d��以及SQL�c�d��之间的对应关�p?

Customer�cȝ��属�?Java�c�d�� Hibernate映射�c�d�� CUSTOMERS表的字段 SQL�c�d��
name java.lang.String string NAME VARCHAR(15)
email java.lang.String string EMAIL VARCHAR(128)
password java.lang.String string PASSWORD VARCHAR(8)
phone int int PHONE INT
address java.lang.String string ADDRESS VARCHAR(255)
sex char character SEX CHAR(1)
married boolean boolean IS_MARRIED BIT
description java.lang.String text DESCRIPTION TEXT
image byte[] binary IMAGE BLOB
birthday java.sql.Date date BIRTHDAY DATE
registeredTime java.sql.Timestamp timestamp REGISTERED_TIME TIMESTAMP

从表2-4看出�Q�如果Customer�cȝ��属性�ؓjava.lang.String�c�d��Q��ƈ且与此对应的CUSTOMERS表的字段为VARCHAR�c�d��Q�那么应该把Hibernate映射�c�d��设�ؓstring�Q�例如：

column="NAME" type="string"
not-null="true" />

如果Customer�cȝ��属性�ؓjava.lang.String�c�d��Q��ƈ且与此对应的CUSTOMERS表的字段为TEXT�c�d��Q�那么应该把Hibernate映射�c�d��设�ؓtext�Q�例如：

如果Customer�cȝ��属性�ؓbyte[]�c�d��Q��ƈ且与此对应的CUSTOMERS表的字段为BLOB�c�d��Q�那么应该把Hibernate映射�c�d��设�ؓbinary�Q�例如：

如果没有昑ּ�讑֮�映射�c�d��Q�Hibernate会运用Java反射机制先识别出持久化类的属性的Java�c�d��Q�然后自动��用与之对应的默认的Hibernate映射�c�d��。例如，Customer�cȝ��address属性�ؓjava.lang.String�c�d��Q�与java.lang.String对应的默认的映射�c�d��为string�Q�因此以下两�U�设�|�方式是�{��h的：

或者：

对于Customer�cȝ��description属性，��管它是java.lang.String�c�d��Q�由于CUSTOMERS表的DESCRIPTION字段为text�c�d��Q�因此必��L��式地把映��类型设为text�?

3�Q�元素的not-null属�?

如果元素的not-null属性�ؓtrue�Q�表明不允许为null�Q�默认�ؓfalse。例如以下代码表明不允许Customer�cȝ��name属性�ؓnull�Q?

Hibernate在持久化一个Customer对象�Ӟ��会先��查它的name属性是否�ؓnull�Q�如果�ؓnull�Q�就会抛��Z��下异常：

net.sf.hibernate.PropertyValueException:
not-null property references
a null or transient value:
mypack.Customer.name

如果数据库中CUSTOMERS表的NAME字段不允��ؓnull�Q�但在映��文件中没有讄��not-null属性：

那么Hibernate在持久化一个Customer对象�Ӟ��不会先检查它的name属性是否�ؓnull�Q�而是直接通过JDBC API向CUSTOMERS表插入相应的数据�Q�由于CUSTOMERS表的NAME字段讄��了not null�U�束�Q�因此数据库会抛出错误：

708 ERROR JDBCExceptionReporter:
58 - General error, message from server:
"Column NAME cannot be null"

值得注意的是�Q�对于实际Java应用�Q�当持久化一个Java对象�Ӟ��不应该依赖Hibernate或数据库来负责数据验证。在四层应用�l�构中，应该��p��q�层或者业务逻辑层负责数据验证。例如对于Customer对象的name属性，事实上在表述层就能检查name属性是否�ؓnull�Q�假如表�q�层、业务逻辑层和Hibernate持久化层都没有检查name属性是否�ؓnull�Q�那么数据库层会监测到NAME字段�q�反了数据完整性约束，从而抛出异常，如图2-2所�C�，包含非法数据的Customer对象从表�q�层依次传到数据库层�Q�随后从数据库层抛出的错误信息又依次传到表述层，�q�种做法昄��会降低数据验证的效率�?

既然如此�Q�把元素的not-null属性设为true�Q�有何意义呢�Q�这主要是便于在软�g开发和��试阶段能捕莯��q�层或者业务逻辑层应该处理而未处理的异常，提醒开发�h员在表述层或者业务逻辑层中加入必要的数据验证逻辑�?

4�Q�元素的column属�?

元素的column属性指定与�cȝ��属性映��的表的字段名。以下代码表明和address属性对应的字段为ADDRESS字段�Q?

如果没有讄��< property >元素的column属性，Hibernate��直接以�cȝ��属性名作�ؓ字段名，也就是说�Q�在默认情况下，与Customer�cȝ��address属性对应的字段为address字段�?

元素�q�可以包括子元素�Q�它和元素的column属性一��P��都可以设定与�cȝ��属性映��的表的字段名。以下两�U�设�|�方式是�{��h的：

或者：

元素的子元素比column属性提供更多的功能�Q�它可以更加详细地描�q�表的字�D�c��例如，以下子元素指定CUSTOMERS表中的NAME字段的SQL�c�d��为varchar(15)�Q�不允许为null�Q��ƈ且�ؓ�q�个字段建立了烦引：

not-null="true" index="idx_name" />

子元素主要和hbm2ddl工具联合使用。当使用hbm2ddl工具来自动生成数据库Schema�Ӟ��hbm2ddl工具��依据子元素提供的信息来定义表的字段。关于hbm2ddl工具的用法参见本书第3章（hbm2java和hbm2ddl工具�Q�。如果数据库Schema是通过手工方式创徏的，��׃��必通过子元素设定字�D늚�详细信息�Q�通常只需讑֮�它的name属性和not-null属性就可以了，例如�Q?

或者：

type="string" not-null="true" />

除了not-null属性以外，子元素的多数属性（如sql-type或index属性）都不会媄响Hibernate的运行时行�ؓ�?

Hibernate采用XML文�g来配�|�对�?关系映射�Q�有以下优点�Q?

1、Hibernate既不会渗透到上层域模型中�Q�也不会渗透到下层数据模型中�?

2、��Y件开发�h员可以独立设计域模型�Q�不必强�q�遵守�Q何规范�?

3、数据库设计人员可以独立设计数据模型�Q�不必强�q�遵守�Q何规范�?

4、对�?关系映射不依赖于��M��E�序代码�Q�如果需要修改对�?关系映射�Q�只需修改XML文�g�Q�不需要修改�Q何程序，提高了��Y件的灉|��性，�q�且使维护更加方�?

王君 2007-10-09 13:59 发表评论

Java对象持久化技术Hibernate 一

王君 — Tue, 09 Oct 2007 05:58:00 GMT

Hibernate是Java应用和关�p�L��据库之间的桥梁，它负责Java对象和关�p�L��据之间的映射。Hibernate内部��装了通过JDBC讉K��数据库的操作�Q�向上层应用提供了面向对象的数据讉K��API。在Java应用中��用Hibernate包含以下步骤�?br /> 　　
　　�Q?�Q�创建Hibernate的配�|�文件�?br /> 　　
　　�Q?�Q�创建持久化�c�R�?br /> 　　
　　�Q?�Q�创建对�?关系映射文�g�?br /> 　　
　　�Q?�Q�通过Hibernate API�~�写讉K��数据库的代码�?br /> 　　
　　本文通过一个简单的例子helloapp应用�Q�演�C�如何运用Hibernate来访问关�p�L��据库。helloapp应用的功能非常简单：通过Hibernate保存、更新、删除、加载及查询Customer对象。图1昄��了Hibernate在helloapp应用中所处的位置�?br /> 　　　　　　　
　　helloapp应用既能作�ؓ独立的Java�E�序�q�行�Q�还能作为Java Web应用�q�行�Q�该应用的源代码位于配套光盘的sourcecode/chapter2/helloapp目录下�?br /> 　　
　　2.1 创徏Hibernate的配�|�文�?br /> 　　
　　Hibernate从其配置文�g中读取和数据库连接有关的信息�Q�这个配�|�文件应该位于应用的classpath中。Hibernate的配�|�文件有两种形式�Q�一�U�是XML格式的文�Ӟ��q�有一�U�是Java属性文�Ӟ��采用"�?�?的�Ş式�?br /> 　　
　　下面介绍如何以Java属性文件的格式来创建Hibernate的配�|�文件。这�U�配�|�文件的默认文�g名�ؓhibernate.properties�Q�例�E?-1为示范代码�?br /> 　　
　　例程2-1 hibernate.properties
　　
　　hibernate.dialect=
　　net.sf.hibernate.dialect.mysqlDialect
　　hibernate.connection.driver_class=
　　com.mysql.jdbc.Driver
　　hibernate.connection.url=jdbc:mysql:
　　//localhost:3306/SAMPLEDB
　　hibernate.connection.username=root
　　hibernate.connection.passWord=1234
　　hibernate.show_sql=true
　　
　　以上hibernate.properties文�g包含了一�p�d��属性及其属性��|��Hibernate��根据这些属性来�q�接数据库，本例��接MySQL数据库的配置代码。表2-1对以上hibernate.properties文�g中的所有属性做了描�q?

王君 2007-10-09 13:58 发表评论

垃圾清理势在必行——Java垃圾攉��法

王君 — Sat, 06 Oct 2007 00:18:00 GMT

1.垃圾攉��法的核心思想

Java语言建立了垃圾收集机�Ӟ��用以跟踪正在使用的对象和发现�q�回收不再��?引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽�Q�以及不恰当的内存释放所造成的内存非法引用�?

垃圾攉��法的核心思想是：对虚拟机可用内存�I�间�Q�即堆空间中的对象进行识别，如果对象正在被引用，那么�U�其为存�z�d��象，反之�Q�如果对象不再被引用�Q�则为垃圑֯�象，可以回收其占据的�I�间�Q�用于再分配。垃圾收集算法的选择和垃圾收集系�l�参数的合理调节直接影响着�pȝ��性能�Q�因此需要开发�h员做比较深入的了解�?

2.触发主GC(Garbage Collector)的条�?

JVM�q�行�ơGC的频率很�?但因��U�GC占用旉��极短,所以对�pȝ��产生的媄响不大。更值得��x��的是主GC的触发条�?因�ؓ它对�pȝ��影响很明显。�ȝ��来说,有两个条件会触发主GC:

①当应用�E�序�I�闲�?��x��有应用线�E�在�q�行�?GC会被调用。因为GC在优先��最低的�U�程中进�?所以当应用忙时,GC�U�程��׃��会被调用,但以下条仉��外�?

②Java堆内存不��x��,GC会被调用。当应用�U�程在运�?�q�在�q�行�q�程中创建新对象,若这时内存空间不��?JVM��׃��强制地调用GC�U�程,以便回收内存用于新的分配。若GC一�ơ之后仍不能满��内存分配的要�?JVM会再�q�行两次GC作进一步的��试,若仍无法满��要求,�?JVM��报“out of memory”的错�?Java应用��停止�?

�׃��是否�q�行主GC由JVM�Ҏ��pȝ��环境军_��,而系�l�环境在不断的变化当�?所以主GC的运行具有不��定�?无法预计它何时必然出�?但可以确定的是对一个长期运行的应用来说,其主GC是反复进行的�?

3.减少GC开销的措�?

�Ҏ��上述GC的机�?�E�序的运行会直接影响�pȝ��环境的变�?从而媄响GC的触发。若不针对GC的特点进行设计和�~�码,��׃��出现内存�ȝ��{�一�p�d��负面影响。�ؓ了避免这些媄�?基本的原则就是尽可能地减��垃圑֒�减少GC�q�程中的开销。具体措施包括以下几个方�?

(1)不要昑ּ�调用System.gc()

此函数徏议JVM�q�行主GC,虽然只是��而非一�?但很多情况下它会触发主GC,从而增加主GC的频�?也即增加了间歇性停��的�ơ数�?

(2)��量减少临时对象的��?

临时对象在蟩出函数调用后,会成为垃�?��用临时变量��q��当于减少了垃圄��产生,从而�g长了出现上述�W�二个触发条件出现的旉��,减少了主GC的机会�?

(3)对象不用时最好显式置为Null

一般而言,为Null的对象都会被作�ؓ垃圾处理,所以将不用的对象显式地设�ؓNull,有利于GC攉��器判定垃�?从而提高了GC的效率�?

(4)��量使用StringBuffer,而不用String来篏加字�W�串(详见blog另一��文章JAVA中String与StringBuffer)

�׃��String是固定长的字�W�串对象,累加String对象�?�q��在一个String对象中扩�?而是重新创徏新的String对象,如Str5=Str1+Str2+Str3+Str4,�q�条语句执行�q�程中会产生多个垃圾对象,因�ؓ�Ҏ��?#8220;+”操作旉��必须创徏新的String对象,但这些过渡对象对�pȝ��来说是没有实际意义的,只会增加更多的垃圾。避免这�U�情况可以改用StringBuffer来篏加字�W�串,因StringBuffer是可变长�?它在原有基础上进行扩�?不会产生中间对象�?

(5)能用基本�c�d��如Int,Long,��׃��用Integer,Long对象

基本�c�d��变量占用的内存资源比相应对象占用的少得多,如果没有必要,最好��用基本变量�?

(6)��量��用静态对象变�?

静态变量属于全局变量,不会被GC回收,它们会一直占用内存�?

(7)分散对象创徏或删除的旉��

集中在短旉��内大量创建新对象,特别是大对象,会导致突焉��要大量内�?JVM在面临这�U�情冉|��,只能�q�行主GC,以回收内存或整合内存��片,从而增加主GC的频率。集中删除对�?道理也是一��L��。它使得�H�然出现了大量的垃圾对象,�I�闲�I�间必然减少,从而大大增加了下一�ơ创建新对象时强制主GC的机会�?

4.gc与finalize�Ҏ��

⑴gc�Ҏ��h��垃圾回收

使用System.gc()可以不管JVM使用的是哪一�U�垃圑֛�收的��法�Q�都可以��h��Java的垃圑֛�收。需要注意的是，调用System.gc()也仅仅是一个请求。JVM接受�q�个消息后，�q�不是立卛_��垃圾回收�Q�而只是对几个垃圾回收��法做了加权�Q��垃圾回收操作�Ҏ��发生�Q�或提早发生�Q�或回收较多而已�?

⑵finalize�Ҏ��透视垃圾攉��器的�q�行

在JVM垃圾攉��器收集一个对象之�?�Q�一般要求程序调用适当的方法释放资源，但在没有明确释放资源的情况下�Q�Java提供了缺省机制来�l�止化该对象释放资源�Q�这个方法就是finalize()。它的原型�ؓ�Q?

protected void finalize() throws Throwable

在finalize()�Ҏ��q�回之后�Q�对象消失，垃圾攉��开始执行。原型中的throws Throwable表示它可以抛��Z�Q何类型的异常�?

因此�Q�当对象卛_��被销毁时�Q�有旉��要做一些善后工作。可以把�q�些操作写在finalize()�Ҏ��里�?

以下是引用片�D�：

protected void finalize()
　　{
　　// finalization code here
　　}

⑶代码示�?

以下是引用片�D�：

class Garbage
　　{
　　int index;
　　static int count;
　　Garbage()
　　{
　　count++;
　　System.out.println("object "+count+" construct");
　　setID(count);
　　}
　　void setID(int id)
　　{
　　index=id;
　　}
　　protected void finalize() //重写finalize�Ҏ��
　　{
　　System.out.println("object "+index+" is reclaimed");
　　}
　　public static void main(String[] args)
　　{
　　new Garbage();
　　new Garbage();
　　new Garbage();
　　new Garbage();
　　System.gc(); //��h��q�行垃圾攉��?
　　}
　　}

5.Java 内存泄漏

�׃��采用了垃圑֛�收机�Ӟ��M��不可辑֯��?对象不再被引�?都可以由垃圾攉��U�程回收。因此通常说的Java 内存泄漏其实是指无意识的、非故意的对象引用，或者无意识的对象保持。无意识的对象引用是指代码的开发�h员本来已�l�对对象使用完毕�Q�却因�ؓ�~�码的错误而意外地保存了对该对象的引用(�q�个引用的存在�ƈ不是�~�码人员的主观意�?�Q�从而��得该对象一直无法被垃圾回收器回收掉�Q�这�U�本来以为可以释放掉的却最�l�未能被释放的空间可以认为是�?#8220;泄漏�?#8221;�?

王君 2007-10-06 08:18 发表评论

王君 — Sat, 06 Oct 2007 00:17:00 GMT

import java.io.*;

public class KeyboardInput{

private final BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
public final synchronized int readInteger(){
String input="";
int value=0;
try{
input=in.readLine();
}
catch (IOException e){}
if(input!=null){
try{
value=Integer.parseInt(input);
}
catch(NumberFormatException e){}
}
return value;
}

public final synchronized long readLong(){
String input="";
long value=0L;
try{
input=in.readLine();
}
catch (IOException e){}
if(input!=null){
try{
value=Long.parseLong(input);
}
catch(NumberFormatException e){}
}
return value;
}

public final synchronized double readDouble(){
String input="";
double value=0.0D;
try{
input=in.readLine();
}
catch (IOException e){}
if(input!=null){
try{
value=Double.parseDouble(input);
}
catch(NumberFormatException e){}
}
return value;
}

public final synchronized float readFloat(){
String input="";
float value=0.0F;
try{
input=in.readLine();
}
catch (IOException e){}
if(input!=null){
try{
value=Float.parseFloat(input);
}
catch(NumberFormatException e){}
}
return value;
}

public final synchronized char readCharacter(){
char c=;
try{
c=(char)in.read();
}
catch (IOException e){}
return c;
}

public final synchronized String readString(){
String s="";
try{
s=in.readLine();
}
catch (IOException e){}
if(s==null){
s="";
}
return s;
}
}

王君 2007-10-06 08:17 发表评论

JAVA中的反射机制详解

王君 — Mon, 01 Oct 2007 17:50:00 GMT

JAVA反射机制
JAVA反射机制是在�q�行状态中�Q�对于�Q意一个类�Q�都能够知道�q�个�cȝ��所有属性和�Ҏ��Q�对于�Q意一个对象，都能够调用它的�Q意一个方法；�q�种动态获取的信息以及动态调用对象的�Ҏ��的功能称为java语言的反��机制�?br /> Java反射机制主要提供了以下功能：在运行时判断��L��一个对象所属的�c�；在运行时构造�Q意一个类的对象；在运行时判断��L��一个类所��h��的成员变量和�Ҏ��Q�在�q�行时调用�Q意一个对象的�Ҏ��Q�生成动态代理�?br /> 1. 得到某个对象的属�?br />
1 public Object getProperty(Object owner, String fieldName) throws Exception {
2 Class ownerClass = owner.getClass();
3
4 Field field = ownerClass.getField(fieldName);
5
6 Object property = field.get(owner);
7
8 return property;
9 }
Class ownerClass = owner.getClass()�Q�得到该对象的Class�?br />
Field field = ownerClass.getField(fieldName)�Q�通过Class得到�c�d��明的属性�?br />
Object property = field.get(owner)�Q�通过对象得到该属性的实例�Q�如果这个属性是非公有的�Q�这里会报IllegalAccessException�?br />
2. 得到某个�cȝ��静态属�?br />
1 public Object getStaticProperty(String className, String fieldName)
2 throws Exception {
3 Class ownerClass = Class.forName(className);
4
5 Field field = ownerClass.getField(fieldName);
6
7 Object property = field.get(ownerClass);
8
9 return property;
10 }

Class ownerClass = Class.forName(className) �Q�首先得到这个类的Class�?br />
Field field = ownerClass.getField(fieldName)�Q�和上面一��P��通过Class得到�c�d��明的属性�?br />
Object property = field.get(ownerClass) �Q�这里和上面有些不同�Q�因��属性是静态的�Q�所以直接从�cȝ��Class里取�?br />
3. 执行某对象的�Ҏ��

1 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
2
3 Class ownerClass = owner.getClass();
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Method method = ownerClass.getMethod(methodName, argsClass);
12
13 return method.invoke(owner, args);
14 }
Class owner_class = owner.getClass() �Q�首先还是必��d��到这个对象的Class�?br />
5�?行：配置参数的Class数组�Q�作为寻找Method的条件�?br />
Method method = ownerClass.getMethod(methodName, argsClass)�Q�通过Method名和参数的Class数组得到要执行的Method�?br />
method.invoke(owner, args)�Q�执行该Method�Q�invoke�Ҏ��的参数是执行�q�个�Ҏ��的对象，和参数数�l�。返回值是Object�Q�也既是该方法的�q�回倹{�?br />
4. 执行某个�cȝ��静态方�?br />
1 public Object invokeStaticMethod(String className, String methodName,
2 Object[] args) throws Exception {
3 Class ownerClass = Class.forName(className);
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Method method = ownerClass.getMethod(methodName, argsClass);
12
13 return method.invoke(null, args);
14 }

基本的原理和实例3相同�Q�不同点是最后一行，invoke的一个参数是null�Q�因��是静态方法，不需要借助实例�q�行�?br />
5. 新徏实例
1
2 public Object newInstance(String className, Object[] args) throws Exception {
3 Class newoneClass = Class.forName(className);
4
5 Class[] argsClass = new Class[args.length];
6
7 for (int i = 0, j = args.length; i < j; i++) {
8 argsClass[i] = args[i].getClass();
9 }
10
11 Constructor cons = newoneClass.getConstructor(argsClass);
12
13 return cons.newInstance(args);
14
15 }

�q�里说的�Ҏ��是执行带参数的构造函数来新徏实例的方法。如果不需要参敎ͼ�可以直接使用newoneClass.newInstance()来实现�?br />
Class newoneClass = Class.forName(className)�Q�第一步，得到要构造的实例的Class�?br />
�W?～第9行：得到参数的Class数组�?br />
Constructor cons = newoneClass.getConstructor(argsClass)�Q�得到构造子�?br />
cons.newInstance(args)�Q�新建实例�?br />
6. 判断是否为某个类的实�?br />
1 public boolean isInstance(Object obj, Class cls) {
2 return cls.isInstance(obj);
3 }

7. 得到数组中的某个元素
1 public Object getByArray(Object array, int index) {
2 return Array.get(array,index);
3 }

王君 2007-10-02 01:50 发表评论

如何掌握JDK1.5枚�D�c�d��

王君 — Mon, 01 Oct 2007 17:48:00 GMT

Enum作�ؓSun全新引进的一个关键字�Q�看��h��很象是特�D�的class, 它也可以有自��q��变量�Q�可以定义自��q��Ҏ��Q�可以实��C��个或者多个接口�?当我们在声明一个enum�c�d��Ӟ��我们应该注意到enum�c�d��有如下的一些特征�?

　　1�Q�它不能有public的构造函敎ͼ��q�样做可以保证客户代码没有办法新��Z��个enum的实例�?

　　2�Q�所有枚丑ր�都是public , static , final的。注意这一点只是针对于枚�D��|��我们可以和在普通类里面定义变量一样定义其它�Q何类型的非枚丑֏�量，�q�些变量可以用�Q何你想用的修饰符�?

　　3�Q�Enum默认实现了java.lang.Comparable接口�?

　　4�Q�Enum覆蝲了了toString�Ҏ��Q�因此我们如果调用Color.Blue.toString()默认�q�回字符�?#8221;Blue”.

　　5�Q�Enum提供了一个valueOf�Ҏ��Q�这个方法和toString�Ҏ��是相对应的。调用valueOf(“Blue”)��返回Color.Blue.因此我们在自己重写toString�Ҏ��的时候就要注意到�q�一点，一把来说应该相对应地重写valueOf�Ҏ��?

　　6�Q�Enum�q�提供了values�Ҏ��Q�这个方法��你能够方便的遍历所有的枚�D倹{�?

　　7�Q�Enum�q�有一个oridinal的方法，�q�个�Ҏ��q�回枚�D值在枚�D�cȝ��的顺序，�q�个��序�Ҏ��枚�D值声明的��序而定�Q�这里Color.Red.ordinal()�q�回0�?

　　了解了这些基本特性，我们来看看如何��用它们�?

　　1�Q�遍历所有有枚�D�? 知道了有values�Ҏ��Q�我们可以轻车熟路地用ForEach循环来遍历了枚�D��g��?

　　for (Color c: Color.values())
　　System.out.println(“find value:” + c);

　　2�Q�在enum中定义方法和变量�Q�比如我们可以�ؓColor增加一个方法随��回一个颜艌Ӏ?

　　public enum Color {
　　Red,
　　Green,
　　Blue;

　　/*
　　*定义一个变量表�C�枚丑ր�的数目�?
　　*(我有点奇怪�ؓ什么sun没有�l�enum直接提供一个size�Ҏ��).
　　*/
　　private static int number = Color.values().length ;

　　/**
　　* 随机�q�回一个枚丑ր?
　　@return a random enum value.
　　*/
　　public static Color getRandomColor(){
　　long random = System.currentTimeMillis() % number;
　　switch ((int) random){
　　　case 0:
　　　　return Color.Red;
　　　case 1:
　　　　return Color.Green;
　　　case 2:
　　　　return Color.Blue;
　　　default : return Color.Red;
　　}
　　}
　　}

　　可以看出�q�在枚�D�c�d��里定义变量和�Ҏ��和在普通类里面定义�Ҏ��和变量没有什么区别。唯一要注意的只是变量和方法定义必��L��在所有枚丑ր�定义的后面�Q�否则编译器会给��Z��个错误�?

　　3�Q�覆�?Override)toString, valueOf�Ҏ��

　　前面我们已经知道enum提供了toString,valueOf�{�方法，很多时候我们都需要覆载默认的toString�Ҏ��Q�那么对于enum我们怎么做呢。其实这和覆载一个普通class的toString�Ҏ��没有什么区别�?

　　….
　　public String toString(){
　　switch (this){
　　case Red:
　　　return "Color.Red";
　　case Green:
　　　return "Color.Green";
　　case Blue:
　　　return "Color.Blue";
　　default:
　　　return "Unknow Color";
　　}
　　}
　　….
　　�q�时我们可以看到�Q�此时再用前面的遍历代码打印出来的是

　　Color.Red
　　Color.Green
　　Color.Blue

　　而不�?

　　Red
　　Green
　　Blue.

　　可以看到toString��实是被覆蝲了。一般来说在覆蝲toString的时候我们同时也应该覆蝲valueOf�Ҏ��Q�以保持它们�怺�的一致性�?

　　4�Q��用构造函�?

　　虽然enum不可以有public的构造函敎ͼ�但是我们�q�是可以定义private的构造函敎ͼ�在enum内部使用。还是用Color�q�个例子�?

　　public enum Color {
　　Red("This is Red"),
　　Green("This is Green"),
　　Blue("This is Blue");

　　private String desc;

　　Color(String desc){
　　this.desc = desc;
　　}

　　public String getDesc(){
　　return this.desc;
　　}

　　}

　　�q�里我们为每一个颜色提供了一个说明信�? 然后定义了一个构造函数接受这个说明信息�?

　　要注意这里构造函��C��能�ؓpublic或者protected, 从而保证构造函数只能在内部使用�Q�客户代码不能new一个枚丑ր�的实例出来。这也是完全�W�合情理的，因�ؓ我们知道枚�D值是public static final的常量而已�?

　　5�Q�实现特定的接口

　　我们已经知道enum可以定义变量和方法，它要实现一个接口也和普通class实现一个接口一��P��q�里��׃��作示例了�?

　　6�Q�定义枚丑ր�D��q��Ҏ��?

　　前面我们看到可以为enum定义一些方法，其实我们甚至可以为每一个枚丑ր�定义方法。这��P��我们前面覆蝲 toString的例子可以被改写成这栗��?

　　public enum Color {
　　Red {
　　public String toString(){
　　　return "Color.Red";
　　}
　　},
　　Green {
　　public String toString(){
　　　return "Color.Green";
　　}
　　},
　　Blue{
　　public String toString(){
　　　return "Color.Blue";
　　}
　　};
　　}

　　从逻辑上来说这��h��原先提供一�?#8220;全局“的toString�Ҏ��要清��C��些�?

　　�ȝ��来说�Q�enum作�ؓ一个全新定义的�c�d��Q�是希望能够帮助�E�序员写出的代码更加��单易懂，个�h觉得一般也不需要过多的使用enum的一些高�U�特性，否则��和��单易懂的初衷惌��背了

王君 2007-10-02 01:48 发表评论

新手入门:写Java�E�序的三十个基本规则

王君 — Wed, 26 Sep 2007 11:05:00 GMT

(1) �c�d��首字母应该大写。字�D�c��方法以及对�?句柄)的首字母应小写。对于所有标识符�Q�其中包含的所有单词都应紧靠在一��P��而且大写中间单词的首字母。例如：

　　ThisIsAClassName

　　thisIsMethodOrFieldName

　　若在定义中出��C��常数初始化字�W�，则大写static final基本�c�d��标识�W�中的所有字母。这样便可标志出它们属于�~�译期的常数�?br />
　　Java�?Package)属于一�U�特�D�情况：它们全都是小写字母，即便中间的单词亦是如此。对于域名扩展名�U�ͼ�如com�Q�org�Q�net或者edu�{�，全部都应��写(�q�也是Java 1.1和Java 1.2的区别之一)�?br />
　　(2) ��Z��常规用途而创��Z��个类�Ӟ��请采�?#8220;�l�典形式”�Q��ƈ包含对下�q�元素的定义�Q?br />
　　equals()

　　hashCode()

　　toString()

　　clone()(implement Cloneable)

　　implement Serializable

　　(3) 对于自己创徏的每一个类�Q�都考虑�|�入一个main()�Q�其中包含了用于��试那个�cȝ��代码。�ؓ使用一个项目中的类�Q�我们没必要删除��试代码。若�q�行了�Q何�Ş式的改动�Q�可方便地返回测试。这些代码也可作为如何��用类的一个示例��用�?br />
　　(4) 应将�Ҏ��设计成简要的、功能性单元，用它描述和实��C��个不�q�箋的类接口部分。理��x��况下�Q�方法应��明扼要。若长度很大�Q�可考虑通过某种方式��其分割成较短的几个�Ҏ��。这样做也便于类内代码的重复使用(有些时候，�Ҏ��必须非常大，但它们仍应只做同��L��一件事�?�?(5) 设计一个类�Ӟ��误��w�处��Cؓ客户�E�序员考虑一�?�cȝ��使用�Ҏ��应该是非常明��的)。然后，再设�w�处��Cؓ��理代码的�h考虑一�?预计有可能进行哪些�Ş式的修改�Q�想想用什么方法可把它们变得更��?�?br />
　　(6) 使类��可能短��精悍，而且只解决一个特定的问题。下面是对类设计的一些徏议：

　　■一个复杂的开兌��句：考虑采用“多�Ş”机制

　　■数量众多的�Ҏ��涉及到类型差别极大的操作�Q�考虑用几个类来分别实�?br />
　　■许多成员变量在特征上有很大的差别：考虑使用几个�c?�?br />
　　(7) 让一切东襉K��可能地“�U�有”——private。可使库的某一部分“公共�?#8221;(一个方法、类或者一个字�D늭��{?�Q�就永远不能把它拿出。若��拿出�Q�就可能破坏其他人现有的代码�Q��他们不得不重新编写和设计。若只公布自己必��d��布的�Q�就可放心大胆地改变其他��M��东西。在多线�E�环境中�Q�隐�U�是特别重要的一个因素——只有private字段才能在非同步使用的情况下受到保护�?br />
　　(8) 谨惕“巨大对象�l�合�?#8221;。对一些习惯于��序�~�程思维、且初涉OOP领域的新手，往往喜欢先写一个顺序执行的�E�序�Q�再把它嵌入一个或两个巨大的对象里。根据编�E�原理，对象表达的应该是应用�E�序的概念，而非应用�E�序本��n�?br />
　　(9) 若不得已�q�行一些不太雅观的�~�程�Q�至��应该把那些代码�|�于一个类的内部�?br />
　　(10) ��M��时候只要发现类与类之间�l�合得非常紧密，��需要考虑是否采用内部�c�，从而改善编码及�l�护工作(参见�W?4�?4.1.2��节�?#8220;用内部类改进代码”)�?br />
　　(11) ��可能细致地加上注释�Q��ƈ用javadoc注释文档语法生成自己的程序文档�?br />
　　(12) 避免使用“��术数字”�Q�这些数字很难与代码很好地配合。如以后需要修改它�Q�无疑会成�ؓ一场噩梦，因�ؓ�Ҏ��不知�?#8220;100”到底是指“数组大小”�q�是“其他全然不同的东�?#8221;。所以，我们应创��Z��个常敎ͼ��q��ؓ其��用具有说服力的描�q�性名�U�ͼ��q�在整个�E�序中都采用常数标识�W�。这样可使程序更易理解以及更易维护�?br />
　　(13) 涉及构徏器和异常的时候，通常希望重新丢弃在构建器中捕��L��M��异常——如果它造成了那个对象的创徏��p�|。这样一来，调用者就不会以�ؓ那个对象已正��地创徏�Q�从而盲目地�l�箋�?br />
　　(14) 当客��L��序员用完对象以后�Q�若你的�c�要求进行�Q何清除工作，可考虑��清除代码置于一个良好定义的�Ҏ��里，采用�c�M��于cleanup()�q�样的名字，明确表明自己的用途。除此以外，可在�c�d��攄��一个boolean(布尔)标记�Q�指出对象是否已被清除。在�cȝ��finalize()�Ҏ��里，��L��定对象已被清除，�q�已丢弃了从RuntimeException�l�承的一个类(如果�q�没有的�?�Q�从而指��Z��个编�E�错误。在采取象这��L��Ҏ��之前�Q�请��定finalize ()能够在自��q��pȝ��中工�?可能需要调用System.runFinalizersonExit(true)�Q�从而确保这一行�ؓ)�?br />
　　(15) 在一个特定的作用域内�Q�若一个对象必��L��?非由垃圾攉��机制处理)�Q�请采用下述�Ҏ��Q�初始化对象;若成功，则立卌��入一个含有finally从句的try块，开始清除工作�?br />
　　(16) 若在初始化过�E�中需要覆�?取消)finalize()�Q�请��C��调用super.finalize()(若Object属于我们的直接超�c�，则无此必�?。在对finalize()�q�行覆盖的过�E�中�Q�对super.finalize()的调用应属于最后一个行动，而不应是�W�一个行动，�q�样可确保在需要基��cȝ��件的时候它们依然有效�?br />
　　(17) 创徏大小固定的对象集合时�Q�请��它们传输至一个数�l?若准备从一个方法里�q�回�q�个集合�Q�更应如此操�?。这样一来，我们��可享受到数�l�在�~�译期进行类型检查的好处。此外，��Z��用它们，数组的接收者也许�ƈ不需要将对象“造型”到数�l�里�?br />
　　(18) ��量使用interfaces�Q�不要��用abstract�c�R��若已知某样东西准备成�ؓ一个基��c�，那么�W�一个选择应是��其变成一个interface(接口)。只有在不得不��用方法定义或者成员变量的时候，才需要将其变成一个abstract(抽象)�c�R��接口主要描�q�C��客户希望做什么事情，而一个类则致力于(或允�?具体的实施细节�?br />
　　(19) 在构建器内部�Q�只�q�行那些��对象设为正��状态所需的工作。尽可能地避免调用其他方法，因�ؓ那些�Ҏ��可能被其他�h覆盖或取消，从而在构徏�q�程中��生不可预知的�l�果(参见�W?章的详细说明)�?br />
　　(20) 对象不应只是��单地容纳一些数�?它们的行��Z��应得到良好的定义�?br />
　　(21) 在现成类的基��上创建新�c�L��Q�请首先选择“新徏”�?#8220;创作”。只有自��q��设计要求必须�l�承�Ӟ��才应考虑�q�方面的问题。若在本来允许新建的场合使用了��承，则整个设计会变得没有必要地复杂�?br />
　　(22) 用��承及�Ҏ��覆盖来表�C��为间的差异，而用字段表示状态间的区别。一个非常极端的例子是通过对不同类的��承来表示颜色�Q�这是绝对应该避免的�Q�应直接使用一�?#8220;颜色”字段�?br />
　　(23) 为避免编�E�时遇到�ȝ��Q�请保证在自��q��路径指到的�Q何地方，每个名字都仅对应一个类。否则，�~�译器可能先扑ֈ�同名的另一个类�Q��ƈ报告出错消息。若怀疑自��q��C��c��\径问题，误��试在�c��\径的每一个�v点，搜烦一下同名的.class文�g�?br />
　　(24) 在Java 1.1 AWT中��用事�?#8220;适配�?#8221;�Ӟ��特别�Ҏ��到一个陷阱。若覆盖了某个适配器方法，同时拼写�Ҏ��没有特别讲究�Q�最后的�l�果��是新添加一个方法，而不是覆盖现成方法。然而，�׃��q�样做是完全合法的，所以不会从�~�译器或�q�行期系�l�获得�Q何出错提�C�——只不过代码的工作就变得不正�怺��?br />
　　(25) 用合理的设计�Ҏ��消除“伪功�?#8221;。也��是��_��假若只需要创建类的一个对象，��׃��要提前限制自�׃��用应用程序，�q�加上一�?#8220;只生成其中一�?#8221;注释。请考虑��其��装成一�?#8220;独生�?#8221;的�Ş式。若在主�E�序里有大量散�ؕ的代码，用于创徏自己的对象，误��虑采纳一�U�创造性的�Ҏ��Q�将些代码封装�v来�?br />
　　(26) 警惕“分析瘫痪”。请��C��Q�无论如何都要提前了解整个项目的状况�Q�再去考察其中的细节。由于把握了全局�Q�可快速认识自己未知的一些因素，防止在考察�l�节的时候陷�?#8220;死逻辑”中�?br />
　　(27) 警惕“�q�早优化”。首先让它运行�v来，再考虑变得更快——但只有在自己必��这样做、而且�l�证实在某部分代码中的确存在一个性能瓉��的时候，才应�q�行优化。除非用专门的工具分析瓶颈，否则很有可能是在��费自己的时间。性能提升的隐含代��h��自己的代码变得难于理解，而且难于�l�护�?br />
　　(28) 误��住，阅读代码的时间比写代码的旉��多得多。思�\清晰的设计可获得易于理解的程序，但注释、细致的解释以及一些示例往往��h��不可估量的�h倹{��无论对你自己，�q�是对后来的人，它们都是相当重要的。如�Ҏ��仍有怀疑，那么误��惌��p��图从联机Java文档里找出有用信息时��到的挫折，�q�样或许能将你说服�?br />
　　(29) 如认��己已�q�行了良好的分析、设计或者实施，那么��L��微更换一下思维角度。试试邀请一些外来�h士——�ƈ不一定是专家�Q�但可以是来自本公司其他部门的�h。请他们用完全新鲜的眼光考察你的工作�Q�看看是否能扑և�你一度熟视无睹的问题。采取这�U�方式，往往能在最适合修改的阶�D�|��Z��些关键性的问题�Q�避免��品发行后再解决问题而造成的金钱及�_�֊�斚w��的损失�?br />
　　(30) 良好的设计能带来最大的回报。简�a�之，对于一个特定的问题�Q�通常会花较长的时间才能找��C��U�最恰当的解��x��案。但一旦找��C��正确的方法，以后的工作就��L��多了�Q�再也不用经历数��时、数天或者数月的痛苦挣扎。我们的努力工作会带来最大的回报(甚至无可估量)。而且�׃��自己倾注了大量心血�Q�最�l�获得一个出色的设计�Ҏ��Q�成功的快感也是令�h心动的。坚持抵制草草完工的诱惑——那样做往往得不偿失�?

王君 2007-09-26 19:05 发表评论

王君 — Wed, 26 Sep 2007 11:04:00 GMT

通过用static来定义方法或成员�Q��ؓ我们�~�程提供了某�U�便利，从某�U�程度上可以说它�c�M��于C语言中的全局函数和全局变量。但是，�q�不是说有了�q�种便利�Q�你便可以随处��用，如果那样的话�Q�你侉K��要认真考虑一下自己是否在用面向对象的思想�~�程�Q�自��q��E�序是否是面向对象的。好了，现在开始讨论this&super�q�两个关键字的意义和用法�?br /> 　　在Java中，this通常指当前对象，super则指父类的。当你想要引用当前对象的某种东西�Q�比如当前对象的某个�Ҏ��Q�或当前对象的某个成员，你便可以利用this来实现这个目的，当然�Q�this的另一个用途是调用当前对象的另一个构造函敎ͼ��q�些马上��p��讨论。如果你惛_��用父�cȝ��某种东西�Q�则非super莫属。由于this与super有如此相似的一些特性和与生俱来的某�U�关�p�，所以我们在�q�一块儿来讨论，希望能帮助你区分和掌握它们两个�?br /> 　　在一般方法中
　　最普遍的情况就是，在你的方法中的某个�Ş参名与当前对象的某个成员有相同的名字�Q�这时�ؓ了不至于��h��Q�你侉K��要明��用this关键字来指明你要使用某个成员�Q��用方法是“this.成员�?#8221;�Q�而不带this的那个便是�Ş参。另外，�q�可以用“this.�Ҏ��?#8221;来引用当前对象的某个�Ҏ��Q�但�q�时this��׃��是必��ȝ��了，你可以直接用�Ҏ��名来讉K��那个�Ҏ��Q�编译器会知道你要调用的是那一个。下面的代码演示了上面的用法�Q?br /> 　　public class DemoThis{　
private String name;　
private int age;　
DemoThis(String name,int age){　　
setName(name);
//你可以加上this来调用方法，像这��P��this.setName(name);但这�q�不是必��ȝ��　　
setAge(age);　　
this.print(); br> }　　
public void setName(String name){　　
this.name=name;//此处必须指明你要引用成员变量　
}
public void etAge(int age){　
this.age=age;　
}　
public void print(){　　
System.out.println("Name="+name+" ge="+age);
//在此行中�q�不需要用this�Q�因为没有会��D��h��的东�ѝ��
}　
public static void main(String[] args){　　
DemoThis dt=new DemoThis("Kevin","22");
　　�q�段代码很简单，不用解释你也应该能看明白。在构造函��C��你看到用this.print(),你完全可以用print()来代替它�Q�两者效果一栗��下面我们修改这个程序，来演�C�super的用法�?br /> 　　class Person{　
public int c;　
private String name;　
private int age;
protected void setName(String name){　　
this.name=name;　
}　
protected void setAge(int age){　
this.age=age;
　}
protected void print(){　　
System.out.println("Name="+name+" Age="+age);
}
}
public class DemoSuper extends Person{　
public void print(){　　
System.out.println("DemoSuper:");　
super.print();
}　
public static void main(String[] args){　
DemoSuper ds=new DemoSuper();　
ds.setName("kevin");　
ds.setAge(22);　
ds.print();
}
}
　　在DemoSuper中，重新定义的print�Ҏ��覆写了父�cȝ��print�Ҏ��Q�它首先做一些自��q��事情�Q�然后调用父�cȝ��那个被覆写了的方法。输出结果说明了�q�一点：
　　DemoSuper:
Name=kevin Age=22

　　�q�样的��用方法是比较常用的。另外如果父�cȝ��成员可以被子�c�访问，那你可以像��用this一样��用它�Q�用“super.父类中的成员�?#8221;的方式，但常�怽��q�不是这��h��讉K��父类中的成员名的�?br /> 　　在构造函��C��构造函数是一�U�特�D�的�Ҏ��Q�在对象初始化的时候自动调用。在构造函��C��Q�this和super也有上面说的�U�种使用方式�Q��ƈ且它�q�有�Ҏ��的地方，��L��下面的例子：

　　
class Person{　

public static void prt(String s){　　
System.out.println(s);　
}　
Person(){　
prt("A Person.");　
}
Person(String name){　
　prt("A person name is:"+name);　

}
}
public class Chinese extends Person{
　Chinese(){　　
super();　//调用父类构造函敎ͼ�1�Q�　
prt("A chinese.");//(4)
}　
Chinese(String name){　　
super(name);//调用父类��h��相同形参的构造函敎ͼ�2�Q�　　
prt("his name is:"+name);
}
Chinese(String name,int age){　　
this(name);//调用当前��h��相同形参的构造函敎ͼ�3�Q�　
prt("his age is:"+age);
}
public static void main(String[] args){　
Chinese cn=new Chinese();　　
cn=new Chinese("kevin");　
cn=new Chinese("kevin",22);
}
}
　　在这�D늨�序中�Q�this和super不再是像以前那样�?#8220;.”�q�接一个方法或成员�Q�而是直接在其后跟
　　上适当的参敎ͼ�因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同�Ş式的
　　构造函敎ͼ��?�?处。this后加参数则调用的是当前具有相同参数的构造函敎ͼ��?处。当�Ӟ��?br /> 　　Chinese的各个重载构造函��C��Q�this和super在一般方法中的各�U�用法也仍可使用�Q�比�?处，�?br /> 　　可以��它替换�?#8220;this.prt”(因�ؓ它��承了父类中的那个�Ҏ��Q�或者是“super.prt”�Q�因为它
　　是父�c�M��的方法且可被子类讉K��Q�，它照样可以正��运行。但�q�样��g��有点画蛇添��的味道
　　了�?br /> 　　最后，写了�q�么多，如果你能�?#8220;this通常指代当前对象�Q�super通常指代父类”�q�句话牢记在
　　心，那么本篇便达��C��目的�Q�其它的你自会在以后的编�E�实践当中慢慢体会、掌握�?

王君 2007-09-26 19:04 发表评论

�~�程需要注意的陷阱�Q�Java�l�承是有害的

王君 — Wed, 26 Sep 2007 11:03:00 GMT

大多数好的设计者象�w�避瘟疫一��h��避免使用实现�l�承(extends 关系)。实际上80%的代码应该完全用interfaces写，而不是通过extends�?#8220;JAVA设计模式”一书详�l�阐�q�C��怎样用接口��承代替实现��ѝ��这��文章描�q�设计者�ؓ什么会�q�么作�?

Extends是有害的�Q�也许对于Charles Manson�q�个�U�别的不是，但是��_��p�糕的它应该在�Q何可能的时候被避开�?#8220;JAVA设计模式”一书花了很大的部分讨论用interface�l�承代替实现�l�承�?

好的设计者在他的代码中，大部分用interface�Q�而不是具体的基类。本文讨��Zؓ什么设计者会�q�样选择�Q��ƈ且也介绍一些基于interface的编�E�基��?

接口�Q�Interface�Q�和�c�（Class�Q?

Jams Gosling�Q�Java之父�Q�做发�v��话。有人问他：“如果你重新构造Java�Q�你��x��变什么？”�?#8220;我想抛弃classes”他回�{�。在�W�声�q�x��后，它解释说�Q�真正的问题不是�׃��class本��n�Q�而是实现�l�承(extends 关系)。接口��承（implements关系�Q�是更好的。你应该��可能的避免实现�l�承�?

失去了灵�z�L�?

��Z��么你应该避免实现�l�承呢？�W�一个问题是明确的��用具体类名将你固定到特定的实玎ͼ��l�底层的改变增加了不必要的困难�?

在当前的敏捷�~�程�Ҏ��中，核心是�ƈ行的设计和开发的概念。在你详�l�设计程序前�Q�你开始编�E�。这个技术不同于传统�Ҏ��的�Ş�?---传统的方式是设计应该在编码开始前完成----但是许多成功的项目已�l�证明你能够更快速的开发高质量代码�Q�相对于传统的按部就班的�Ҏ��。但是在�q�行开发的核心是主张灵�z�L��。你不得不以某一�U�方式写你的代码以至于最新发现的需求能够尽可能没有痛苦的合�q�到已有的代码中�?

胜于实现你也讔R��要的特征�Q�你只需实现你明��需要的特征�Q�而且适度的对变化的包宏V��如果你没有�q�种灉|��Q��ƈ行的开发，那简直不可能�?

对于Inteface的编�E�是灉|��l�构的核心。�ؓ了说明�ؓ什么，让我们看一下当使用它们的时候，会发生什么。考虑下面的代码：

f()
{ LinkedList list = new LinkedList();
//...
g( list );
}

g( LinkedList list )
{
list.add( ... );
g2( list )
}

现在�Q�假设一个对于快速查询的需求被提出�Q�以至于�q�个LinkedList不能够解冟뀂你需要用HashSet来代替它。在已有代码中，变化不能够局部化�Q�因��Z��不仅仅需要修改f()也需要修改g()�Q�它带有LinkedList参数�Q�，�q�且�q�有g()把列表传递给的�Q何代码。象下面�q�样重写代码:

f()
{ Collection list = new LinkedList();
//...
g( list );
}

g( Collection list )
{
list.add( ... );
g2( list )
}

�q�样修改Linked list成hash�Q�可能只是简单的用new HashSet()代替new LinkedList()。就�q�样。没有其他的需要修改的地方�?

作�ؓ另一个例子，比较下面两段代码�Q?

f()
{ Collection c = new HashSet();
//...
g( c );
}

g( Collection c )
{
for( Iterator i = c.iterator(); i.hasNext() )
do_something_with( i.next() );
}

�?

f2()
{ Collection c = new HashSet();
//...
g2( c.iterator() );
}

g2( Iterator i )
{ while( i.hasNext() )
do_something_with( i.next() );
}

g2()�Ҏ��现在能够遍历Collection的派生，��像你能够从Map中得到的键值对。事实上�Q�你能够写iterator�Q�它产生数据�Q�代曉K��历一个Collection。你能够写iterator�Q�它从测试的框架或者文件中得到信息。这会有巨大的灵�z�L��?

耦合

对于实现�l�承�Q�一个更加关键的问题是耦合---令�h烦躁的依赖，��是那种�E�序的一部分对于另一部分的依赖。全局变量提供�l�典的例子，证明��Z��么强耦合会引起麻烦。例如，如果你改变全局变量的类型，那么所有用到这个变量的函数也许都被影响�Q�所以所有这些代码都要被��查，变更和重新测试。而且�Q�所有用到这个变量的函数通过�q�个变量�怺�耦合。也��是�Q�如果一个变量值在难以使用的时候被改变�Q�一个函��C��许就不正��的影响了另一个函数的行�ؓ。这个问题显著的隐藏于多�U�程的程序�?

作�ؓ一个设计者，你应该努力最��化耦合关系。你不能一�q�消除耦合�Q�因��Z��一个类的对象到另一个类的对象的�Ҏ��调用是一个松耦合的�Ş式。你不可能有一个程序，它没有�Q何的耦合。然而，你能够通过遵守OO规则�Q�最��化一定的耦合�Q�最重要的是�Q�一个对象的实现应该完全隐藏于��用他的对象）。例如，一个对象的实例变量�Q�不是常量的成员域）�Q�应该��L��private。我意思是某段时期的，无例外的�Q�不断的。（你能够偶��有效地使用protected�Ҏ��Q�但是protected实例变量是可憎的事）同样的原因你应该不用get/set函数---他们对于是一个域公用只是使�h感到�q�于复杂的方式（��管�q�回修饰的对象而不是基本类型值的讉K��函数是在某些情况下是由原因的�Q�那�U�情况下�Q�返回的对象�c�L��一个在设计时的关键抽象�Q��?

�q�里�Q�我不是书生气。在我自��q��工作中，我发��C��个直接的�怺�关系在我OO�Ҏ��的严��g��_��快速代码开发和�Ҏ��的代码实现。无��Z��么时候我�q�反中心的OO原则�Q�如实现隐藏�Q�我�l�果重写那个代码�Q�一般因��Z��码是不可调试的）。我没有旉��重写代码�Q�所以我遵��@那些规则。我兛_��的完全实�?我对�q�净的原因没有兴��?

脆弱的基�c�问�?

现在�Q�让我们应用耦合的概念到�l�承。在一个用extends的��承实现系�l�中�Q�派生类是非常紧密的和基�c�耦合�Q�当且这�U�紧密的�q�接是不期望的。设计者已�l�应用了�l�号“脆弱的基�c�问�?#8221;��L��q�这个行为。基��c�被认�ؓ是脆��q��是，因�ؓ你在看�v来安全的情况下修改基�c�，但是当从�z��cȝ��承时�Q�新的行��Z��许引��h��生类出现功能紊�ؕ。你不能通过��单的在隔��M��查基�cȝ��Ҏ��来分辨基�cȝ��变化是安全的�Q�而是你也必须看（和测试）所有派生类。而且�Q�你必须��查所有的代码�Q�它们也用在基类和派生类对象中，因�ؓ�q�个代码也许被新的行为所打破。一个对于基��cȝ��单变化可能导致整个程序不可操作�?

让我们一��h��查脆��q��基类和基�c�耦合的问题。下面的�c�extends了Java的ArrayList�c�d��使它像一个stack来运转：

class Stack extends ArrayList
{ private int stack_pointer = 0;

public void push( Object article )
{ add( stack_pointer++, article );
}

public Object pop()
{ return remove( --stack_pointer );
}

public void push_many( Object[] articles )
{ for( int i = 0; i < articles.length; ++i )
push( articles[i] );
}
}

甚至一个象�q�样��单的�c�M��有问题。思考当一个用户��^衡��承和用ArrayList的clear()�Ҏ��d��出堆栈时�Q?

Stack a_stack = new Stack();
a_stack.push("1");
a_stack.push("2");
a_stack.clear();

�q�个代码成功�~�译�Q�但是因为基�c�M��知道关于stack指针堆栈的情�?�q�个stack对象当前在一个未定义的状态。下一个对于push�Q�）调用把新的项攑օ�索引2的位�|�。（stack_pointer的当前��|��Q�所以stack有效地有三个元素-下边两个是垃圾。（Java的stack�c�L��是有�q�个问题�Q�不要用它）.

对这个��o��厌的�l�承的方法问题的解决办法是�ؓStack覆盖所有的ArrayList�Ҏ��Q�那能够修改数组的状态，所以覆盖正��的操作Stack指针或者抛��Z��个例外�?removeRange()�Ҏ��对于抛出一个例外一个好的候选方�?�?

�q�个�Ҏ��有两个缺炏V��第一�Q�如果你覆盖了所有的东西�Q�这个基�c�d��该真正的是一个interface�Q�而不是一个class。如果你不用��M��l�承�Ҏ��Q�在实现�l�承中就没有�q�一炏V��第二，更重要的是，你不能够让一个stack支持所有的ArrayList�Ҏ��。例如，令�h烦恼的removeRange()没有什么作用。唯一实现无用�Ҏ��的合理的途径是��它抛��Z��个例外，因�ؓ它应该永�q�不被调用。这个方法有效的把编译错误成��行错误。不好的�Ҏ��是，如果�Ҏ��只是不被定义�Q�编译器会输��Z��个方法未扑ֈ�的错误。如果方法存在，但是抛出一个例外，你只有在�E�序真正的运行时�Q�你才能够发现调用错误�?

对于�q�个基类问题的一个更好的解决办法是封装数据结构代替用�l�承。这是新的和改进的Stack的版本：

class Stack
{
private int stack_pointer = 0;
private ArrayList the_data = new ArrayList();

public void push( Object article )
{
the_data.add( stack_poniter++, article );
}

public Object pop()
{
return the_data.remove( --stack_pointer );
}

public void push_many( Object[] articles )
{
for�Q?int i = 0; i < o.length; ++i �Q?br /> push( articles[i] );
}
}

到现在�ؓ止，一直都不错�Q�但是考虑脆弱的基�c�问题，我们说你惌��在stack创徏一个变量，用它在一�D�周期内跟踪最大的堆栈��寸。一个可能的实现也许象下面这�?

class Monitorable_stack extends Stack
{
private int high_water_mark = 0;
private int current_size;

public void push( Object article )
{
if( ++current_size > high_water_mark )
high_water_mark = current_size;
super.push( article );
}

publish Object pop()
{
--current_size;
return super.pop();
}

public int maximum_size_so_far()
{
return high_water_mark;
}
}

�q�个新类�q�行的很好，臛_��是一�D�|��间。不�q�的是，�q�个代码发掘了一个事实，push_many()通过调用push()来运行。首先，�q�个�l�节看�v来不是一个坏的选择。它��化了代码�Q��ƈ且你能够得到push()的派生类版本�Q�甚臛_��Monitorable_stack通过Stack的参考来讉K��的时候，以至于high_water_mark能够正确的更�?br />

王君 2007-09-26 19:03 发表评论

Java�c�d��Q�java.lang�Q�包概述

王君 — Mon, 24 Sep 2007 00:21:00 GMT

1. 接口java.lang.Appendable可追加（append�Q�接口。实��C��该接口的�cȝ��对象实例��h��可向其追加字�W�或字符序列的能力。希望能够接收Formatter输出的类必须实现该接口。java.lang.CharSequenceCharSequence是指可阅�ȝ��字符序列。该接口为只读访问各�U�类型的字符序列提供了统一的方法。java.lang.Cloneable可克隆接口。实��C��该接口的�c�d��有克隆的能力。可以通过Object.clone()�Ҏ��类的实例对象的域（field�Q�逐个复制到同一个类的另外一个实例中。如果��用Object.clone()�Ҏ��克隆没有实现该接口的�cȝ��实例对象�Q�将会触发CloneNotSupportedException异常。java.lang.Comparable可比较接口。实��C��该接口的�cȝ��两个实例对象之间可以�q�行比较。比较结果负敎ͼ�-1�Q��?、正敎ͼ�1�Q�分别代表比较对象与被比较对象之间的关系分别是小于、等于、大于。可对实��C��该接口的�cȝ��多个实例对象�q�行排序。java.lang.Iterable可�P代接口。实��C��该接口的�c�M��般作为容器，且具有提供依�ơ访问被包容对象功能的能力。java.lang.Readable可读取接口。客户对象可以从实现了该接口的类的实例对象中��d��字符。java.lang.Runable可运行接口。实��C��该接口的�cȝ��实例对象��在一个单独的�U�程�Q�thread�Q�中被运行。没有扩展Thread的类可以通过实现该接口，开发出多线�E�服务的能力。java.lang.Thread.UncaughtExceptionHandler�U�程未捕获异常控制器接口。在�U�程执行�q�程中引发了异常而没有捕��h��Q?实现了该接口的类可以作�ؓ控制器处理该状况�?

2. �c�java.lang.Boolean��原始数据类型boolean对象化的�c�R��该�cȝ��实例对象除了包含一个boolean��g��外，�q�提供boolean String之间转化�{�处理boolean的方法。java.lang.Byte��原始数据类型byte对象化的�c�R��该�cȝ��实例对象除了包含一个byte��g��外，�q�提供byte与其他类型之间�{化等处理byte的方法。java.lang.Character��原始数据类型char对象化的�c�R��该�cȝ��实例对象除了包含一个char��g��外，�q�提供了处理字符的方法。Java 2�q�_��在字�W�数�l�、字�W�串或StringBuffer中��用UTF-16表达字符。UTF-16使用16�?1位二�q�制位表达，即从/u0000�?u10FFFF�?u0000�?uFFFF表示基本�?6位字�W�，/u10000�?u10FFFF表示辅助字符�Q�supplymentary characters�Q��?辅助字符�׃��个高位替代符�Q�high-surrogate �Q�和一个低位替代符�Q�low-surrogate �Q�共同组成。高位替代符使用一�?uD800�?uDBFF之间的字�W�表�C�；低位替代�W��用一�?uDC00�?uDFFF之间的字�W�表�C�。假设：A代表辅助字符�Q�SC�Q�的码点��|�� B代表SC的高位替代符的码点（Unicode code point�Q��|�� C代表SC的低位替代符的码点倹{��那么下面的�{�式成立�Q�A = (B - 0xD800) << 10 + (C - 0xDC00) + 0x10000在将Unicode�q�原为可阅读字符的时候，当且仅当当前字符旉��位替代符�Q�下一字符是低位替代符�Ӟ��此连�l�的两个字符被解释�ؓ辅助字符。java.lang.Character.Subset该类的实例对表达某个Unicode字符集的特定子集。java.lang.Character.UnicodeBlock该类的实例对象表达一族相关的子Unicode字符集。这些子字符集通常服务于相同的目的。java.lang.Class该类的实例对象表达Java应用中正在运行的�c�L��者接口。该�c�L��有公��q��构造方法，所以不能由Java虚拟��动实例化�Q�而是由ClassLoader实例化。java.lang.ClassLoader该类是Java�c�d��载器�Q�负责根据制定的二进制名�U�加载相应的�c�R��在Java语言规范中规定，�c�R��接口或原始数据�c�d��有三�U�命名，他们分别是许可名�Q�fully qualified name�Q�、规范名�Q�canonical name�Q�、二�q�制名（binary name�Q�。不同的�c�d��载器�Ҏ��cȝ��二进制名从不同的源中��d��二进制的�c?#8220;*.class”信息�Q��ƈ生成Class对象。每个类中都有对其加载器的引用�?

package org.javaplus.jdkoverview;
public class OuterClass {
public class InnerClass {
public InnerClass() {}
}
public OutterClass() {}
}
public class SubClass extends OuterClass {
public SubClass() {}
}

org.javaplus.jdkoverview.SubClass的内部类�Q�InnerClass�Q�的名称许可�?

org.javaplus.jdkoverview.SubClass.InnerClass规范�?

org.javaplus.jdkoverview.OuterClass.InnerClass二进制名:

org.javaplus.jdkoverview.OuterClass$InnerClassjava.lang.Compiler该类提供Java到本��Z��码的支持�Q�及相关服务。该�c�d��是JIT�~�译器（Java Just-in-Time Compiler�Q�的一个占位符而已。如果JVM�Q�Java Virtual Machine �Q�第一�ơ启动时未成功加载JIT�~�译器，则本�c�M��做�Q何工作。java.lang.Double��原始数据类型double对象化的�c�R��该�cȝ��实例对象除了包含一个double��g��外，�q�提供double与其他类型之间�{化等处理double的方�?br />

王君 2007-09-24 08:21 发表评论

用java实现的经兔R��归��法

王君 — Mon, 24 Sep 2007 00:19:00 GMT

一、写作此文的原因�Q?br /> 学过�E�序设计的朋友都知道�Q�存在自调用的算法称作递归��法�?br /> 递归往往能给我们带来非常��z�非常直观的代码形势�Q�从而��我们的编码大大简化，然而递归的思维��实很我们的常规思维盔R��的�Q�我们通常都是从上而下的思维问题�Q?而递归��势从下往上的�q�行思维�Q�正�׃��此，很多人对于递归有着深深的恐惧，我曾�l�也是如此，如今为把我的�l�验通过几个�l�典的例子与初学者共享，故作此文�Q�希望能寚w��要者有所助益�Q�如若如此，便是�q�甚。。�?br />

二、递归��法设计的基本思想是：对于一个复杂的问题�Q�把员问题分解�ؓ若干个相对简单前�c�d��的子问题�Q��l�下�ȝ��到子问题��单到能够直接求解�Q�也��是说到了递推的出口，�q�样原问题就有递推得解�?br /> 关键要抓住的是：�Q?�Q�递归出口
�Q?�Q�地推逐步向出口��D��

三、具体实�?
1。汉诺塔
�q�是递归的超�l�典的例子，几乎每本�E�序设计书上谈到递归都会介绍。具体情景不再赘�q�。以我上�q�的�Ҏ��观之�Q�（1�Q�递归的出口在于disk��Cؓ一的时�?br /> �Q?�Q�向出口��D��Q�如果不是一�Q�是n �Q�则我们先挪动上面n-1块disk�Q�等上面挪完�Q�即递归�q�回的时候，我们挪动最底下的disk�?br />
仅仅如此�Q�一个貌似十分复杂的问题��p��决了�Q�因为挪动那n-1块disk的时候，会��l�向上减��，直到disk的数量�ؓ一为止。下面给出ｊａｖａ程序编码（已测试过�Q�运行正常）�Q?br />
import javax.swing.JOptionPane;

public class Hanoi {
private static final String DISK_B = "diskB";
private static final String DISK_C = "diskC";
private static final String DISK_A = "diskA";
static String from=DISK_A;
static String to=DISK_C;
static String mid=DISK_B;
public static void main(String[] args) {
String input=JOptionPane.showInputDialog("please input the number of the disks you want me move.");
int num=Integer.parseInt(input);
move(num,from,mid,to);
}
private static void move(int num, String from2, String mid2, String to2) {
if(num==1){
System.out.println("move disk 1 from "+from2+" to "+to2);
}
else {
move(num-1,from2,to2,mid2);
System.out.println("move disk "+num+" from "+from2+" to "+to2);
move(num-1,mid2,from2,to2);
}

}
}

2。这是一个排列的例子�Q�它所做的工作是将输入的一个字�W�串中的所有元素进行排序�ƈ输出�Q�例如：你给出的参数�?abc" 则程序会输出�Q?br /> abc
acb
bac
bca
cab
cba

　　�Q�１�Q�算法的出口在于�Q�ｌｏｗ�Q�ｈｉｇｈ也��是现在�l�出的排列元素只有一个时�?br /> 　　�Q�２�Q�算法的��D��q�程�Q�先��定排列的第一位元素，也就是��@环中ｉ所代表的元素，
然后ｌｏｗ＋�Q�开始减��排列元素，如此下去�Q�直刎ͽ�ｏｗ�Q�ｈｉｇ�?br /> public static void permute(String str) {
char[] strArray = str.toCharArray();
permute(strArray, 0, strArray.length - 1);
}

public static void permute(char[] list, int low, int high) {
int i;
if (low == high) {
String cout = "";
for (i = 0; i <= high; i++)
cout += list[i];
System.out.println(cout);
} else {

for (i = low; i <= high; i++) {
char temp = list[low];
list[low] = list[i];
list[i] = temp;
permute(list, low + 1, high);
temp = list[low];
list[low] = list[i];
list[i] = temp;
}
}
}

�Q�．�q�是一个组合的例子�Q�与上述的例子相��|��只是它所做的工作是，输出所�l�字�W�串中制定数目的元素的组合种�c?br /> 　　　　　�Q�１�Q�程序出口在于ｎ�Q�１�Q�此时只要输出目标数�l�的所有元素即�?br /> 　　　　　�Q�２�Q��D��q�程�Q�当ｎ＞�Q�　的时候，我们先取�W�一个元素放入目标数�l�中�Q�然后ｎ�Q�１�Q�如此下去，最后出来�?br /> 　　　　　import javax.swing.JOptionPane;

public class Combination {

/**
* @param args
*/
public static void main(String[] args) {

String input = JOptionPane
.showInputDialog("please input your String: ");
String numString = JOptionPane
.showInputDialog("please input the number of your Combination: ");
int num = Integer.parseInt(numString);
Combine(input, num);
}

private static void Combine(String input, int num) {
char[] a = input.toCharArray();
String b = "";
Combine(a, num, b, 0, a.length);

}

private static void Combine(char[] a, int num, String b, int low, int high) {
if (num == 0) {
System.out.println(b);
} else {
for (int i = low; i < a.length; i++) {
b += a[i];
Combine(a, num - 1, b, i+1, a.length);
b=b.substring(0, b.length()-1);
}
}

}
}

�׃��递归的表�q�确实不易加上本人的水��^有限�Q�颇有以�׃��昏昏�Ʋ�h之昭昭的意味�Q�还望大家多多谅解�?

王君 2007-09-24 08:19 发表评论

王君 — Mon, 24 Sep 2007 00:18:00 GMT

我是一个java初学者碰��C��些小问题�Q�希望前辈们�l�我解答一下，谢谢�Q?br /> 原题目：
�~�写应用�E�序�Q�利用缓冲输入流BufferedInputStream 从键盘输入字�W�串�Q�当输入的字�W�串�?#8220;exit”时结束输入，��输入的所有字�W�串存放�?my file.txt中�?br /> �~�写应用�E�序�Q�读�?#8220;my file.txt”的内容，�q�将��d��的内容输出到屏幕上，��L��件结束后�Q�显�C?#8220;Finished reading,programe ended.”.
代码�Q?br /> import java.io.*;
public class Ex3
{
public static void main(String[]args)throws Exception
{
BufferedInputStream bis=new BufferedInputStream(System.in);
FileWriter fw=new FileWriter("my file.txt");
while(true)
{
byte[]b=new byte[200];
int len=bis.read(b);
String str=new String(b,0,len-2);
if(str.equals("exit"))
{
System.exit(0);
}
fw.write(str);
fw.flush();
}
}
}
上面的代码中��Z��么String str=new String(b,0,len-2);�q�个�Ҏ��的参数最后一个要�?br /> len-2�Q�尝试过len或者len-1�Q�结果会��exit也写入文�Ӟ��len-1�q�有回�R操作�W�，不明白�?br /> 试写的代码：
import java.io.*;
public class Ex4
{
public static void main(String[]args)throws Exception
{
FileReader fr=new FileReader("my file.txt");
FileOutputStream fos=new FileOutputStream("my file.txt");
int c;
byte b[]=new byte[200];
int len=fr.read();
while((c=fr.read())!=-1)
{

fos.write(b);
}
System.out.print("Finished reading,programe ended.");
fr.close();
fos.close();

}
}
思�\是否正确�Q�这道题应该怎么写？

王君 2007-09-24 08:18 发表评论

JAVA 实现各种排序��法和复杂度分析2

王君 — Thu, 20 Sep 2007 07:58:00 GMT

接上�?br />
�W�三�U�：插入排序

public static int[] insertionSort(int[] a) {
int n = a.length;
for (int i = 1; i < n; i++) {
int temp = a[i];
int j;
for (j = i - 1; j >= 0 && temp < a[j]; j--) {
a[j + 1] = a[j];
}
a[j + 1] = temp;
}
return a;
}
}

��法分析�Q?插入排序的思想是这��L��Q�第一层for循环表示要��@环n�ơ，且每�ơ��@环要操作的主体是a[i]�Q�第二层循环是对a[i]的具体操作，是从原数��第i个位�|��v�Q�向前比较，若a[i]比前面的数小�Q�前面的数后�U�d��去a[i]的位�|�，同时也�ؓa[i]�I�出了插入地点，然后向前�l�箋比较�Q�直到a[i]比前面的数来的大�Q�插入。下一�ơ��@环开始，�q�样��完成一个完整的升序插入排序�?br />
很明显，�q�种排序也是不稳定的�Q?br /> 最好的情况是：��序已经排好那么我们只要�q�行n-1�ơ比较即可�?br /> 最坏的情况是：��序恰好是逆序�Q�惨了，我们要比�?+2+...+n-1��?br />
�q�_��的复杂度��v来还是比较困隄��Q�也是很有参考�h值的�Q?br />
1。首先，我们来看对于�W�i个元�?a[i] 的操�?br />
从等概率角度思考：a[i]只比�?1 �ơ的概率�?1/i;
a[i]只比�?2 �ơ的概率�?1/i;
a[i]只比�?3 �ơ的概率�?1/i;
�?br /> �?
�?br />
a[i]只比�?i-1 �ơ的概率�?1/i;
a[i]只比�?i �ơ的概率�?1/i;
于是又编号�ؓi的元素��^均比较次��Cؓ�Q?1/i)*(1+2+3+...+i)=(i+1)/2

2。然后我们来�?br />
�q�_��比较�ơ数�?T=(2+3+4+...+n)/2
所以插入排序的�q�_��旉��复杂度也是O(n^2).

�W�四�U�：Rank排序
public static int[] rankSort(int[] a){
int n=a.length;
int[] r1=new int[n];
int[] r2=new int[n];
for (int i = 0; i for(int j=i+1;j if(a[i] r1[j]++;
else
r1[i]++;
}
}
for(int i=0;i r2[r1[i]]=a[i];
}
return r2;
}

��法分析�Q�Rank排序是基于这��L��思想�Q�徏立一个和待排序数�l�相同大��的数组�Q�初识化为全0�Q�然后扫描原数组��每个数的大��排名，然后更具排名安排各自元素的位�ơ，思�\非常��?br /> 复杂度分析：�q�个��法是稳定的一��p��比较的次��Cؓn*(n-1)/2
旉��复杂度是O(n^2);

王君 2007-09-20 15:58 发表评论

JAVA 实现各种排序��法和复杂度分析1

王君 — Thu, 20 Sep 2007 07:57:00 GMT

�W�一�U�：冒��排序

public static int[] bubbleSort(int[] a) {
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < (a.length - i) - 1; j++) {
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
return a;
}

复杂度分析：冒��排序是不�E�_��的排序算法，一��p��比较((n-1)+(n-2)+...+3+2+1)=n*(n-1)/2�ơ，所以时间复杂度是O(n^2)�?br />

�W�二�U�：选择排序

public static int[] selecitonSort(int[] a) {
for (int i = 0; i < a.length; i++) {
int max = a[0];
int count = 0;
int k = a.length - i - 1;
for (int j = 0; j < a.length - i; j++) {
if (max < a[j]) {
max = a[j];
count = j;
}
}
a[count] = a[k];
a[k] = max;
}
return a;
}

复杂度分析：选择排序是不�E�_��法�Q�最好的情况是最好情冉|��已经排好��序�Q�只要比�?br /> n*(n-1)/2�ơ即可，最坏情冉|��逆序排好的，那么�q�要�U�d�� O(n)��?�׃��是低阶故而不考虑
不难得出选择排序的时间复杂度�?O(n^2)

�W�三�U�：插入排序
待箋。。�?br />

王君 2007-09-20 15:57 发表评论

王君 — Thu, 20 Sep 2007 07:56:00 GMT

1�Q�关于数�l�的特点

1�Q�在Java中，无论使用数组或容器，都有边界��查。如果越界操作就会得��C��个RuntimeException异常�?

2�Q�数�l�只能保存特定类型。数�l�可以保存基本类型，容器则不能。容器不以具体的�c�d��来处理对象，它们��所有对象都按Object�c�d��处理�?

3�Q�容器类只能保存对象的引用。而数�l�既可以创徏为直接保存基本类型，也可以保存对象的引用。在容器中可以��用包装类�Q�如Integer、Double�{�来实现保存基本数据�c�d��倹{�?

4�Q�对象数�l�和基本�c�d��数组在��用上几乎是相同的�Q�唯一的区别是对象数组保存的是引用�Q�基本类型数�l�保存基本类型的倹{�?

2�Q�关于数�l�定�?

1�Q�数�l�在定义�Ӟ��不能分配�I�间。只有定义完后，可以�l�数�l�分配空间�?

int num[];

num=new int[3];

�?

int num[]=new int[3];

注意

int [] num=new int[]{1,2,3}; //ok

int [] num=new int[3]{1,2,3}; //error;

2�Q�可以这样定义二�l�数�l��?

int [][] num;

//or

num=new int[3][];

num[0]=new int[5];

num[1]=new int[3];

num[2]=new int[2];

3�Q�二�l�数�l�赋初倹{�?

int [][] num=new int[][]{1,2,3,4,5,5}; //error
int [][] num=new int[][]{{1,2,3},{4,5,5}}; //ok
int [][] num=new int[2][]{{1,2,3},{4,5,5}}; //error
int [][] num={{1,2,3},{4,5,6}}; //ok

3�Q�关于数�l�初始化

对象数组在创��Z��初会自动初始化成null�Q�由原始数据�c�d��构成的数�l�会自动初始化成�Ӟ��针对数值类型）�Q?Char)0 �Q�针对字�W�类型）或者false �Q�针对布��类型）�?

4�Q�数�l�有兛_��用的问题

int[] a1 = { 1, 2, 3, 4, 5 };

int[] a2;

a2 = a1;//�q�里只是复制了一个引�?

看以下代码：

public class Arrays {
public static void main(String[] args) {
int[] a1 = { 1, 2, 3, 4, 5 };
for (int i = 0; i < a1.length; i++)
System.out.println("a1[" + i + "] = " + a1[i]);
int[] a2;
a2 = a1;
for (int i = 0; i < a2.length; i++)
a2[i]++;
System.out.println("-----after change a2------");
for (int i = 0; i < a1.length; i++)
System.out.println("a1[" + i + "] = " + a1[i]);
System.out.println("-----after change a2[0]------");
a2[0] = 333;
System.out.println("a2[0]=" + a2[0]);
System.out.println("a1[0]=" + a1[0]);
System.out.println("----- a2------");
for (int i = 0; i < a2.length; i++)
System.out.println("a2[" + i + "] = " + a2[i]);
}
}

�l�果�Q?

a1[0] = 1

a1[1] = 2

a1[2] = 3

a1[3] = 4

a1[4] = 5

-----after change a2------

a1[0] = 2

a1[1] = 3

a1[2] = 4

a1[3] = 5

a1[4] = 6

-----after change a2[0]------

a2[0]=333

a1[0]=333

----- a2------

a2[0] = 333

a2[1] = 3

a2[2] = 4

a2[3] = 5

a2[4] = 6

数组a1和a2始终在操作同一个对象�?

5�Q�关于数�l�的相关操作

1�Q�在Java中，所有的数组都有一个缺省的属性length�Q�用于获取数�l�中元素的个数�?

2�Q�数�l�的复制�Q�System.arraycopy()�?

3�Q�数�l�的排序�Q�Arrays.sort()�?

4�Q�在已排序的数组中查找某个元素：Arrays.binarySearch()�?

6�Q�关于数�l�的排序操作

1�Q�对象数�l�排序，必须实现Comparable接口�?

import java.util.Arrays;
class Student implements Comparable {
int num;
String name;

Student(int num, String name) {
this.num = num;
this.name = name;
}

public String toString()// 重写toString()�Ҏ��Q�以便main:System.out.println(ss[i]);
{
return "number=" + num + "," + "name=" + name;
}

public int compareTo(Object o) {
Student s = (Student) o;
return num > s.num ? 1 : (num == s.num ? 0 : -1);
}
}

class ArrayTest {
public static void main(String[] args) {
Student[] ss = new Student[] { new Student(1, "zhangsan"),
new Student(2, "lisi"), new Student(3, "wangwu") };
Arrays.sort(ss);
for (int i = 0; i < ss.length; i++) {
System.out.println(ss[i]);
}
}
}

�l�果�Q?

number=1,name=zhangsan

number=2,name=lisi

number=3,name=wangwu

2�Q�以num为第一关键字，name为第二关键字排序

import java.util.Arrays;

class Student implements Comparable {
int num;
String name;

Student(int num, String name) {
this.num = num;
this.name = name;
}

public String toString() {
return "number=" + num + "," + "name=" + name;
}

public int compareTo(Object o) {
Student s = (Student) o;
int result = num > s.num ? 1 : (num == s.num ? 0 : -1);
if (0 == result) {
result = name.compareTo(s.name);
}
return result;
}
}

class ArrayTest {
public static void main(String[] args) {
Student[] ss = new Student[] { new Student(1, "zhangsan"),
new Student(2, "lisi"), new Student(3, "wangwu"),
new Student(3, "mybole") };
Arrays.sort(ss);
for (int i = 0; i < ss.length; i++) {
System.out.println(ss[i]);
}
}
}

�l�果�Q?

number=1,name=zhangsan

number=2,name=lisi

number=3,name=mybole

number=3,name=wangwu

7�Q�关于java.util.Arrays

1�Q�java.util.Class Arrays’s architecture

java.lang.Object

|

+--java.util.Arrays

2�Q�说�?

�q�个�c�L��供的基本上都是静态方法，用户�q�行数组操作�Q�binarySearch()�Q�数�l�中特定元素的寻找，equals()�Q�比较两个数�l�是否相�{�（在相同位�|�上的元素是否相�{�）,fill()�Q�数�l�填充，sort()�Q�数�l�排�?br />

王君 2007-09-20 15:56 发表评论

王君 — Thu, 20 Sep 2007 07:55:00 GMT

1. 异常机制

1.1

异常机制是指当程序出现错误后�Q�程序如何处理。具体来��_��异常机制提供了程序退出的安全通道。当出现错误后，�E�序执行的流�E�发生改变，�E�序的控制权转移到异常处理器�?

1.2

传统的处理异常的办法是，函数�q�回一个特�D�的�l�果来表�C�出现异常（通常�q�个�Ҏ��l�果是大家约定俗�U�的�Q�，调用该函数的�E�序负责��查�ƈ分析函数�q�回的结果。这样做有如下的弊端�Q�例如函数返�?1代表出现异常�Q�但是如果函数确实要�q�回-1�q�个正确的值时��׃��出现��h��Q�可��L��降低，��程序代码与处理异常的代码�؜爹在一��P��p��用函数的�E�序来分析错误，�q�就要求客户�E�序员对库函数有很深的了解�?

1.3 异常处理的流�E?

1.3.1 遇到错误�Q�方法立即结束，�q�不�q�回一个��|��同时�Q�抛��Z��个异常对�?

1.3.2 调用该方法的�E�序也不会��l�执行下去，而是搜烦一个可以处理该异常的异常处理器�Q��ƈ执行其中的代�?

2 异常的分�c?

2.1 异常的分�c?

2.1.1

异常的��承结构：基类为Throwable�Q�Error和Exception�l�承Throwable�Q�RuntimeException和IOException�{��承Exception�Q�具体的RuntimeException�l�承RuntimeException�?

2.1.2

Error和RuntimeException及其子类成�ؓ未检查异常（unchecked�Q�，其它异常成�ؓ已检查异常（checked�Q��?

2.2 每个�c�d��的异常的特点

2.2.1 Error体系

Error�c�M��p�L��q�C��Java�q�行�pȝ��中的内部错误以及资源耗尽的情形。应用程序不应该抛出�q�种�c�d��的对象（一般是��p��拟机抛出�Q�。如果出现这�U�错误，除了��力使程序安全退出外�Q�在其他斚w��是无能�ؓ力的。所以，在进行程序设计时�Q�应该更��x��Exception体系�?

2.2.2 Exception体系

Exception体系包括RuntimeException体系和其他非RuntimeException的体�p?

2.2.2.1 RuntimeException

RuntimeException体系包括错误的类型�{换、数�l�越界访问和试图讉K��I�指针等�{�。处理RuntimeException的原则是�Q�如果出现RuntimeException�Q�那么一定是�E�序员的错误。例如，可以通过��查数�l�下标和数组边界来避免数�l�越界访问异常�?

2.2.2.2 其他�Q�IOException�{�等�Q?

�q�类异常一般是外部错误�Q�例如试图从文�g��֐��d��数据�{�，�q��ƈ不是�E�序本��n的错误，而是在应用环境中出现的外部错误�?

2.3 与C++异常分类的不�?

2.3.1

其实�Q�Java中RuntimeException�q�个�c�d��L��q�不恰当�Q�因��Z�Q何异帔R��是运行时出现的。（在编译时出现的错误�ƈ不是异常�Q�换句话��_��异常��是��Z��解决�E�序�q�行时出现的的错误）�?

2.3.2

C++中logic_error与Java中的RuntimeException是等��L��Q�而runtime_error与Java中非RuntimeException�c�d��的异常是�{��h的�?

3 异常的��用方�?

3.1 声明�Ҏ��抛出异常

3.1.1 语法�Q�throws�Q�略�Q?

3.1.2 ��Z��么要声明�Ҏ��抛出异常�Q?

�Ҏ��是否抛出异常与方法返回值的�c�d��一样重要。假设方法抛出异常确没有声明该方法将抛出异常�Q�那么客��L��序员可以调用�q�个�Ҏ��而且不用�~�写处理异常的代码。那么，一旦出现异常，那么�q�个异常��没有合适的异常控制器来解决�?

3.1.3 ��Z��么抛出的异常一定是已检查异常？

RuntimeException与Error可以在�Q何代码中产生�Q�它们不需要由�E�序员显�C�的抛出�Q�一旦出现错误，那么相应的异�怼�被自动抛出。而已��查异常是��q��序员抛出的，�q�分��Z��U�情况：客户�E�序员调用会抛出异常的库函数�Q�库函数的异常由库程序员抛出�Q�；客户�E�序员自�׃��用throw语句抛出异常。遇到Error�Q�程序员一般是无能为力的；遇到RuntimeException�Q�那么一定是�E�序存在逻辑错误�Q�要对程序进行修改（相当于调试的一�U�方法）�Q�只有已��查异常才是程序员所兛_��的，�E�序应该且仅应该抛出或处理已��查异常�?

3.1.4

注意�Q�覆盖父�c�L��Ҏ��的子�c�L��法不能抛出比父类�Ҏ��更多的异常，所以，有时设计父类的方法时会声明抛出异常，但实际的实现�Ҏ��的代码却�q�不抛出异常�Q�这样做的目的就是�ؓ了方便子�c�L��法覆盖父�c�L��法时可以抛出异常�?

3.2 如何抛出异常

3.2.1 语法�Q�throw�Q�略�Q?

3.2.2 抛出什么异常？

对于一个异常对象，真正有用的信息时异常的对象类型，而异常对象本�w�毫无意义。比如一个异常对象的�c�d��是ClassCastException�Q�那么这个类名就是唯一有用的信息。所以，在选择抛出什么异常时�Q�最关键的就是选择异常的类名能够明��说明异常情�늚��c�R�?

3.2.3

异常对象通常有两�U�构造函敎ͼ�一�U�是无参数的构造函敎ͼ�另一�U�是带一个字�W�串的构造函敎ͼ��q�个字符串将作�ؓ�q�个异常对象除了�c�d��名以外的额外说明�?

3.2.4

创徏自己的异常：当Java内置的异帔R��不能明确的说明异常情�늚�时候，需要创��q��异常。需要注意的是，唯一有用的就是类型名�q�个信息�Q�所以不要在异常�cȝ��设计上花费精力�?

3.3 捕获异常

如果一个异常没有被处理�Q�那么，对于一个非囑�Ş界面的程序而言�Q�该�E�序会被中止�q�输出异�怿�息；对于一个图形界面程序，也会输出异常的信息，但是�E�序�q�不中止�Q�而是�q�回用Ы缑娲��分小?BR> 3.3.1 语法�Q�try、catch和finally�Q�略�Q?

控制器模块必��ȝ��接在try块后面。若掷出一个异常，异常控制机制会搜��d��C��异常�c�d��相符的第一个控制器随后它会�q�入那个catch

从句�Q��ƈ认�ؓ异常已得到控制。一旦catch 从句�l�束�Ҏ��制器的搜索也会停止�?

3.3.1.1 捕获多个异常�Q�注意语法与捕获的顺序）�Q�略�Q?

3.3.1.2 finally的用法与异常处理��程�Q�略�Q?

3.3.2 异常处理做什么？

对于Java来说�Q�由于有了垃圾收集，所以异常处理�ƈ不需要回收内存。但是依然有一些资源需要程序员来收集，比如文�g、网�l�连接和囄��{�资源�?

3.3.3 应该声明�Ҏ��抛出异常�q�是在方法中捕获异常�Q?

原则�Q�捕捉�ƈ处理哪些知道如何处理的异常，而传递哪些不知道如何处理的异�?

3.3.4 再次抛出异常

3.3.4.1 ��Z��么要再次抛出异常�Q?

在本�U�中�Q�只能处理一部分内容�Q�有些处理需要在更高一�U�的环境中完成，所以应该再�ơ抛出异常。这样可以��每��的异常处理器处理它能够处理的异常�?

3.3.4.2 异常处理��程

对应与同一try块的catch块将被忽略，抛出的异常将�q�入更高的一�U��?

4 关于异常的其他问�?

4.1 �q�度使用异常

首先�Q��用异常很方便�Q�所以程序员一般不再愿意编写处理错误的代码�Q�而仅仅是��单单的抛��Z��个异常。这样做是不对的�Q�对于完全已知的错误�Q�应该编写处理这�U�错误的代码�Q�增加程序的鲁棒性。另外，异常机制的效率很差�?

4.2 ��异�怸�普通错误区分开

对于普通的完全一致的错误�Q�应该编写处理这�U�错误的代码�Q�增加程序的鲁棒性。只有外部的不能��定和预知的�q�行旉��误才需要��用异常�?

4.3 异常对象中包含的信息

一般情况下�Q�异常对象唯一有用的信息就是类型信息。但使用异常带字�W�串的构造函数时�Q�这个字�W�串�q�可以作为额外的信息。调用异常对象的getMessage()、toString()或者printStackTrace()�Ҏ��可以分别得到异常对象的额外信息、类名和调用堆栈的信息。�ƈ且后一�U�包含的信息是前一�U�的��集

王君 2007-09-20 15:55 发表评论

王君 — Thu, 20 Sep 2007 07:54:00 GMT

一、引�a�

20世纪末是万维�|�开始膨胀的时期，它的发展速度是十分惊人的。据�l�计�Q�万�l�网已经�q�通了世界上几乎所有的国家�Q��ƈ且万�l�网正在急速发展。目前，万维�|�已�l�成��Z��界上最大的信息源，成�ؓ全球范围内科研、教肌Ӏ�商业和�C�会、新闅R��学校和专业机构介绍、图书及�׃��{�信息的集大成者。近�q�来对万�l�网的研�I�的两大热点是网�l�搜索引擎的研究和网�l�拓扑结构的研究。对于网�l�信息挖掘的首先要面对的问题��是如何提取出网站内部的URL�Q�只有获得了�|�站的所有URL才可以网站的全部内容。基于此本文�l�出了一�U�实用有效的提取�|�站内部URL的方法�?

二、JAVA基础

Java语言方便灉|��Q�是现在开发网�l�程序的主要语言。本文采用了Java语言来开发。在Java的提供的java.util.*�?java.net.* 工具包中提供了大量简单易用的API。此外，在网�l�上�q�有大量的开放源码�?

HTMLParser v 1.3是一套优�U�的开放源代码的提供HTML文�g分析的工具包。它可以提供快速的、实事的文本分析的功能。HTMLParser最大的成功之处是它设计��单、速度快、应用方�ѝ��可以从http://htmlparser.sourceforge.net下蝲此工具包和了解其用法�?

对于HTMLParser 工具包我们需要修改其中的htmlparser.java文�g使其适用中文的html文�g分析。htmlparser.java文�g中具体实现细节就不再介绍。这里主要是把protected static final String DEFAULT_CHARSET = "ISO-8859-1"�Q�修�Ҏ��protected static final String DEFAULT_CHARSET = "gb2312"�Q�因为采用默认的字符�?ISO-8859-1"对含有中文的html文�g�q�行分析的时候就会出��Cؕ码。必��进行new String(str.getBytes("ISO-8859-1")�Q?GB2312")的�{换工作�?

对于修改好的htmlparser工具包，需要重新压�~�成.jar文�g�Q�放到jdk的工作环境中�?

三、具体设�?

首先新徏一个静态全局Vector变量L�Q�在��法的递归调用中往L中不断添加新发现的URL。公�?1)是一个遍历网站内部URL的数学表辑ּ��?

S=T(ui) �Q?�Q?

s.t. ui O(ui)

ui Ui-1 i=1�Q?…m

其中T(u)是遍历一个站点的所有URL的函敎ͼ��Z��保证该遍历方法收敛这里我�l�出了两个限制条�Ӟ��ui��Z��|�站中的URL�Q�O(ui)是判断ui是否��|�站内部的URL�?

��法是：

1�Q?定义全局静态变量public static Vector svecLink�Q?

2�Q?开始搜索网站W的主URL�Q?

3�Q?解析出第一��面的所有URL�Q?

4�Q?剔除无效的URL和非本站点的URL同时记录所��L��URL的个��Cؓa�Q?

5�Q?把URL��d��到svecLink中；

6�Q?从svecLink中取出最后a个URL分别递归调用此函�?

��Z��能保证遍历的收敛�Q�程序必��d��URL�q�行严格限制。下面是一些具体实玎ͼ�

1�Q?定义的全局变量

public final int DEEP=3; //遍历的深�?

public static Vector svecLink, svecOutlink; //存放内部URL和外部URL

public static String hostName; //��L��名称

public static boolean bl; //判断标志

private String location;

private Parser parser; //对超文本�q�行分析

2�Q?获取��L��名称GetHostName�Q�）函数

通过该函数来判断所得URL是否是本�|�站的URL�Q�如果不是就不需要添加svecLink中如果是�q�且以前没有提取�q�就��d��到svecLink中�?

public String GetHostName(String hostname)
{
URL aurl;
String ss=" ";
try
{
aurl=new URL(hostname);
ss=aurl.getHost();
}
catch(MalformedURLException e)
{
e.printStackTrace();
}
return ss;
}

3�Q?递归遍历�Ҏ��

�׃��|�站中URL之间的连接构成了图，所以对囄��遍历�q�里采用深度优先的方法�?

public void extractLinks(String loc) throws ParserException {
System.out.println("Parsing "+loc+" for links...");

Vector vecTemp=new Vector();
try {
this.parser = new Parser(loc); //原理见HTMLParser
parser.registerScanners();
bl=true;
}
catch (ParserException e) {
bl=false;
e.printStackTrace();
}

String ss,str1;
URL wwwurl;
boolean byes;

int a=0;
b++;
Node [] links = parser.extractAllNodesThatAre(LinkTag.class);
//获取一个页面中//所有的URL
for (int i = 0;i < links.length;i++) {
if(bl)
{
byes=true;
System.out.println("Total url is "+links.length+"This page has url "+i);
LinkTag linkTag = (LinkTag)links[i];
str1=linkTag.getLink();
if(str1.equals("")) continue;
if(str1.charAt(str1.length()-1)==/
||str1.charAt(str1.length()-1)==\)
str1=str1.substring(0,str1.length()-1);
if(!svecLink.contains(str1))
{
try
{
wwwurl=new URL(str1);
wwwurl.getContent();
}
catch(MalformedURLException e)
{
byes=false;
}
catch(IOException e)
{
byes=false;
}
if(GetHostName(str1).equals(hostName) && byes)
{
a++;
tID++;
svecLink.add(str1);
vecTemp.add(str1);
System.out.println("the url is "+str1);
}
else
{

svecOutlink.add(str1);
}
}
}
}

String strNew;
if(a>0&&b<=DEEP)
{

for(int i=0;i {
strNew=(String)vecTemp.get(i);
System.out.println("this is "+strNew);
extractLinks(strNew); //递归调用
}
}

}

四、结�?

本文介绍�l�出了一�U�提取网站内部URL的实现方法，本文的方法对�|�络机器人的研究和WEB文本挖掘提供了方便的工具。在�E�序的实��C��q�有许多实际的困难，需要在实验中不断完善和改进

王君 2007-09-20 15:54 发表评论

Java初学者容易�؜淆的几个问题详细解析

王君 — Tue, 18 Sep 2007 06:52:00 GMT

�Q?String�c�d��StringBuffer�c?

它们都是处理字符串的�c?但是它们有一个最大的区别,那就�?String对象是存储你不能改动的文本字�W�串,相反,如果你希望改�?则应使用StringBuffer�c�M��为替�?

eg1:

　　 ......

　　 //omit some code

　　 String s1="You are hired!";

　　 System.out.println(s1.replace(h,f));//用f把字串中的h替换�?

　　 System.out.println(s1);

　　 ......

　　 //omit some code

　　 �q�行�l�果:

　　 You are fired!

　　 You are hired!
　　 �l�果分析:

　　从结�?明显可知,s1的值�ƈ没有被改�?而第一行结果只是屏�q�内容的替换.

　　 eg2:

　　 ......

　　 //omit some code

　　 StringBuffer s2=new StringBuffer("Hello from Java!");

　　 s2.replace(6,10,"to");

　　 System.out.println(s2);

　　 ......

　　 //omit some code

　　

�q�行�l�果:

Hello to Java!

�l�果分析:

昄��,s2的值已改变.

�Q?位逻辑与条仉��辑

首先声明, ��Z��与位逻辑更好区分开�?我把通常所说的逻辑取了个别名叫做条仉��辑.

它们都有各自的操作符,位逻辑操作�W�有:&(与运��?,^(异或�q�算),|(或运��?;条�g逻辑操作�W�有:&&(�q�且),||(或�?.

位逻辑�q�算通常是针对两个数而言,实行位操�?而条仉��辑�q�算是针对两个条件表辑ּ�而言,实行条�g操作.其实,位逻辑操作�W�一样可以实现条件操�?但是此时有一个重要的区别:用位操作�W�时,不管操作�W�两边的

条�g表达式成不成�?它都要通通进行运��判�?而条仉��辑操作�W�不一样了,如果通过左侧的操作数��可以进行它们需要的判断,那么它就不会再计��右侧的操作��C��,�q�种情况叫短�?废话��说!且看下例.

eg1:

　　 ......

　　 //omit some code

　　 double value=0;

　　 if(value!=0 && 1/value<1000){

　　 System.out.println("The value is not too small.");

　　 }

　　 else{

　　 System.out.println("The value is too small.");

　　 }

　　 ......

　　 //omit some code

　　

�q�行�l�果:

The value is too small.

�l�果分析:

照理说应会出现除��Cؓ0的错�?但是我刚才说�?�׃��条�g逻辑操作�W�是短�\操作�W?昄��,value!=0不成�?立即��可作出判断应执行else后的语句,所以它��׃��再会�q�算判断1/value<1000�?如果不懂请再看一�?

eg2:

　　 ......

　　 //omit some code

　　 double int1=0,int2=1,int3=1;

　　 if(int1!=0 & (int2=2)==1){}

　　 System.out.println("int2="+int2);

　　 if(int1!=0 && (int3=2)==1){}

　　 System.out.println("int3="+int3);

　　 ......

　　 //omit some code

�q�行�l�果:

int2=2.0

int3=1.0

�l�果分析:

我想不用我分析了,你应该懂了吧.

�Q?实例变量与类变量

可以通过两种�Ҏ��在类中存储数据───作�ؓ实例变量和类变量.实例变量是特定于对象�?如果你有两个对象(即一个类的两个实�?,每一个对象中的实例变量独立于另一个对象中的实例变量的;另一斚w��,两个对象的类变量均指向相同的数据,�q�因此面保存相同的�?换句话说,�c�d��量被�c�M��的所有对象共�?差点忘了,它们在�Ş式上的区�?�c�d��量在声明时比实例变量多一个static.

eg:

　　 class data

　　 public int intdata=0;//昄��,intdata在这儿是实例变量

　　 }

　　 public class exam

　　 {

　　 public static void main(String[] args)

　　 {

　　 data a,b;

　　 a=new data();

　　 b=new data();

　　 a.intdata=1;

　　 System.out.println("b.indata="+b.intdata);

　　 }

　　 }

�q�行�l�果:

b.intdata=0

�l�果分析:

可以看出,a.intdata的��D��然变�?但�ƈ没有影响b.intdata.但是如果在data�c�M��声明intdata�?在其前面加上static��变成类变量�?�?public static int intdata=0;),则此时运行结果会变�ؓ:

b.intdata=1

�q�次a.intdata值的改变可把b.intdata影响�?事实�?对象a和b的类变量均指向相同的数据,所有��g��?�q�就是类变量的作�?

�Q?实例�Ҏ��,�c�L��?构造器�Ҏ��

我们通常所说的�Ҏ��p�L��实例�Ҏ��,��像c语言中的函数一�?其具体方法我��׃��用说�?在这里我主要是用它来区分�c�L��法和构造器�Ҏ��.�c�L��法与实例�Ҏ��最大的区别�?在�Ş式上�c�L��法多一个static,在用法上,不必创徏对象��可直接调用�c�L��?而实例方法却一定要先创建对�?再通过对象调用).

eg:

　　 class add

　　 {

　　 static int addem(int op1,int op2)

　　 {
　　 return op1+op2;

　　 }

　　 }

　　 public class xxf

　　 {

　　 public static void main(String[] args)

　　 {

　　 System.out.println("addem(2,2)="+add.addem(2,2));

　　 } //直接用类名作为对象调用类�Ҏ��

　　 }

　　

�? 也可按通常的方�?卛_��创徏对象,再调用方�?不过,�q�时static��无��M��意义�?

再说说构造器�Ҏ��,它是用来初始化对象中的数据的一�U�方�?创徏很容�?只需在类中加上一个与�q�个�c�d��名的�Ҏ��,不需要在前面加�Q何访问说明符或者返回类�?另外,构造器也一样可以向�Ҏ��一样传递参�?

eg:

　 class data

　　 {

　　 private String data1;//事先声明
　　 data(String s)

　　 {

　　 data1=s; /*通过接收数据来初始化变量.(�?不能在构造器�?

　　声明变量,事先在外��p��声明.)*/

　　 }

　　 public String getdata()

　　 {

　　 return data1;

　　 }

　　 }

　　 public class xxf

　　 {

　　 public static void main(String[] args)

　　 {

　　 System.out.println((new data("I love you")).getdata());
/*通过传递参数调用构造器新徏一个对�?再通过对象调用�Ҏ��得到数据*/

　　 }

　　 }

�Q?接口与类

�c�L��对一�cȝ��定对象的规格说明,我们可以�c�d��义创建对�?通过创徏对象来组合所有属于该�cȝ��l��g,而接口不能这样做.而接口实质上��是一个常量和抽象�Ҏ��的集�?要��用一个接�?��需要在�c�M��实现�q�个接口,然后作�ؓ�c�d��义的一部分,�~�写接口中声明的每一个方�?接口中的�Ҏ��永远是public,abstract,接口中的帔R��永远是public static和final,因此不需要�ؓ它们说明属�?因�ؓ在Java中不支持多重�l�承,但是,可以用接口来实现�c�M��的功�?�q�是接口的重要作用之一.

eg:

　　 interface anyone //定义一个接�?

　　 {

　　 final double PI=3.1416;

　　 void setNumber(int number);

　　 int getNumber();

　　 }

　　 interface anyother //定义另一个接�?

　　 {

　　 void setString(String str);

　　 String getString();

　　 }

　　 class xxf implement anyone,anyother //定义一个类,�q��用两个接�?

　　 {

　　 int number;

　　 String str;

　　 public xxf(){}

　　 void setNumber(int number)

　　 {

　　 this.number=number;

　　 }

　　 void setString(String str)

　　 {

　　 this.str=str;

　　 }

　　 void int getNumber(){}//可以��Z��个空实现.

　　 void String getString(){}

　　 }

//在类中必��d��现接口中声明的所有方�?(当然也可不必,但是要用到适配器类或用抽象�c?

王君 2007-09-18 14:52 发表评论

Java中��用接口实现多�l�承和多态的�Ҏ��

王君 — Tue, 18 Sep 2007 06:50:00 GMT

1.JAVA里没有多�l�承�Q�一个类之能有一个父�c�R�?

而��承的表现��是多态。一个父�c�d��以有多个子类�Q�而在子类里可以重写父�cȝ��Ҏ��Q�例如方法print()�Q�，�q�样每个子类里重写的代码不一��P��自然表现形式��׃��一栗��这��L��父类的变量去引用不同的子�c�，在调用这个相同的�Ҏ��print()的时候得到的�l�果和表现�Ş式就不一样了�Q�这��是多态，相同的消息（也就是调用相同的�Ҏ��Q�会有不同的�l�果。�D例说明：

//父类
public class Father{
//父类有一个打孩子�Ҏ��
public void hitChild(){}
}
//子类1
public class Son1 extends Father{
//重写父类打孩子方�?
public void hitChild(){
System.out.println("��Z��么打我？我做错什么了�Q?); }
}
//子类2
public class Son2 extends Father{
//重写父类打孩子方�?public void hitChild(){
System.out.println("我知道错了，别打了！"); }
}
//子类3
public class Son3 extends Father{
//重写父类打孩子方�?public void hitChild(){
System.out.println("我跑�Q�你打不着�Q?); }
}
//��试�c?br /> public class Test{
public static void main(String args[]){
Father father;
father = new Son1();
father.hitChild();
father = new Son2();
father.hitChild();
father = new Son3();
father.hitChild();
}
}

都调用了相同的方法，出现了不同的�l�果�Q�这��是多态的表现�Q?

2.JAVA中没有多�l�承�Q�而用接口实现了多�l�承�Q�一个类或是可以同时实现多个接口�Q�（��q��当于C++里一个类同时�l�承了多个类�Q�）例如�Q?

public class Son implements Father1,Father2,Father3{

}

接口有利于代码功能的扩展�Q�增加新的功能）�Q�而��承则有利于代码功能的修改�Q�把旧的功能�Ҏ��新的功能�Q�！�q�里旧功能的修改和新功能的增加前提是不修�Ҏ��的功能，旧的功能仍然可以使用�Q�旧�cȝ��代码也不做修改！

接着上面的��承�D例：上面例子中的子类我们�l�称��Z��代子�c?

1.用��承修�Ҏ��的功能�?

现在如果一代Son1的功能打孩子�Q�也��是�Ҏ��hitChild()里边的功能实现有问题�Q�我们要把具体实��C��Ҏ��Q�那么我们可以重新写一个新的二代子�c�Son11�l�承自一代子�c�Son1�Q��ƈ重写其hitChild()�Ҏ��?

//二代子类
public class Son11 extends Son1{
//重写父类打孩子方�?
public void hitChild(){ System.out.println("我是二代子类�Ҏ��Ҏ��的新实现");
}
}

2.用接口实现增加新的功能�?

现在�c�Son1已经有了‘打孩�?#8217;功能�Q�也��是�Ҏ��Q�，而我们有了新的需求，我们需要它�q�要有一个新的功�?#8216;宠孩�?#8217;�Q�新�Ҏ��pet();�Q�。而旧的代码不能动�Q�那么我们可以定义一个新的接口（PetInterFace�Q�，接口里定义这个方法pet()的声明。再重新写一个二代子�c�Son11�Q�让它先�l�承�c�Son1�Q�同时实现接�?PetInterFace�Q��ƈ实现接口里的 pet()�Ҏ��Q?

//新接�?br /> public interface PetInterFace{
//新功能方�?public void pet();
}
//二代子类
public class Son11 extends Son1 implements PetInterFace{
//实现接口�Ҏ��
public void pet(){
System.out.println("父亲很爱我！");
}
}

�q�样�q�个二代子类��x��了老的�Ҏ��Q�又有新的功能！

王君 2007-09-18 14:50 发表评论

��d��学习Java语言中的覆盖和重载的使用

王君 — Tue, 18 Sep 2007 06:49:00 GMT

override可以��译��盖，从字面就可以知道�Q�它是覆盖了一个方法�ƈ且对光��写，以求辑ֈ�不同的作用。对我们来说最熟悉的覆盖就是对接口�Ҏ��的实玎ͼ�在接口中一般只是对�Ҏ��q�行了声明，而我们在实现�Ӟ��需要实现接口声明的所有方法。除了这个典型的用法以外�Q�我们在�l�承中也可能会在子类覆盖父类中的�Ҏ��。在覆盖要注意以下的几点�Q?

1、覆盖的�Ҏ��的标志必��要和被覆盖的方法的标志完全匚w��Q�才能达到覆盖的效果�Q?

2、覆盖的�Ҏ��的返回值必��d��被覆盖的�Ҏ��的返回一��_��

3、覆盖的�Ҏ��所抛出的异常必��d��被覆盖方法的所抛出的异�怸��_��或者是其子�c�；

4、被覆盖的方法不能�ؓprivate�Q�否则在其子�c�M��只是新定义了一个方法，�q�没有对其进行覆盖�?

overload�Ҏ��们来说可能比较熟悉，可以��译为重载，它是指我们可以定义一些名�U�相同的�Ҏ��Q�通过定义不同的输入参数来区分�q�些�Ҏ��Q�然后再调用�Ӟ��VM��׃��Ҏ��不同的参数样式，来选择合适的�Ҏ��执行。在使用重蝲要注意以下的几点�Q?

1、在使用重蝲时只能通过不同的参数样式。例如，不同的参数类型，不同的参��C��敎ͼ�不同的参数顺序（当然�Q�同一�Ҏ��内的几个参数�c�d��必须不一��P��例如可以是fun(int, float)�Q?但是不能为fun(int, int)�Q�；

2、不能通过讉K��权限、返回类型、抛出的异常�q�行重蝲�Q?

3、方法的异常�c�d��和数目不会对重蝲造成影响�Q?

4、对于��承来��_��如果某一�Ҏ��在父�c�M��是访问权限是priavte�Q�那么就不能在子�c�d��其进行重载，如果定义的话�Q�也只是定义了一个新�Ҏ��Q�而不会达到重载的效果�?

下面是对override和overload的测试程序，其中注释中的内容都是会��生编译错误的代码�Q�我们将注释��L��Q�看看在�~�译时会产生什么效果�?

// 对overload��试的文�Ӟ��OverloadTest.java
public class OverloadTest {
// 下面几个�Ҏ��用来验证可以通过定义不同的参数类型和参数的数目进行方法重载�?br /> public void fun(){
System.out.println("method fun in OverloadTest, no parameter");
}

public void fun(float f) {
System.out.println("method fun in OverloadTest, parameter type: float");
}

public void fun(int i){
System.out.println("method fun in OverloadTest, parameter type: int");
}

public void fun(int i1, int i2) {
System.out.println("method fun in OverloadTest, parameter type: int, int");
}

// 下面的两个方法用来验证可以通过定义不同的参数顺序进行方法重载�?br /> // 需要注意：�q�里的参数肯定不是相同的�c�d��Q�否则的��序的先后就毫无意义�?br /> public void fun1(int i, float f) {
System.out.println("method fun1 in OverloadTest,
sequence of parameters is: int, float");
}

public void fun1(float f, int i) {
System.out.println("method fun1 in OverloadTest,
sequence of parameters is: float, int");
}

// 下面的两个方法用来验证方法抛出的异常对于重蝲的媄�?
// 无论是异常的�c�d��q�是异常的个数都不会寚w��载造成��M��的媄响�?br /> public void fun2() throws TestException {
System.out.println("fun2 in OverloadTest, exception: TestException");
}

public void fun2(int i) throws TestException, TestException1 {
System.out.println("fun2 in OverloadTest,
exception: TestException, TestException1");
}

public void fun2(float f) throws Exception {
System.out.println("fun2 in OverloadTest, exception: Exception");
}

// 不能通过抛出的异常类型来重蝲fun�Ҏ��?br /> //public void fun(int i) throws Exception {
// System.out.println("method fun in OverloadTest,
parameter type: int, exception: Exception");
//}

// 不能通过�q�回值重载fun�Ҏ��?br /> //public boolean fun(int i) throws Exception {
// System.out.println("method fun in OverloadTest,
parameter type: int, exception: Exception, return: boolean");
// return true;
//}

private void fun3() { }

// 不能通过不同的访问权限进行重�?br /> public void fun3() { }

public static void main(String[] args) {
// �q�里只是定义了OverloadTest的实例，所以test不会调用
// OverloadTest1中的�Ҏ��?br /> OverloadTest test = new OverloadTest1();
// �q�里定义了OverloadTest1的实例，因�ؓOverloadTest1是OverloadTest
// 的子�c�，所以test1会调用OverloadTest中的�Ҏ��?br /> OverloadTest1 test1 = new OverloadTest1();

try {
int i = 1, j = 2, m = 3;

// �q�里不会调用OverloadTest1的fun�Ҏ��
// test.fun(i, m, j);
test1.fun(i, j, m);
test1.fun();
// �q�个调用不会执行�Q�因为fun3()在OverloadTest中访问权限是priavte
//test1.fun3();
test1.fun3(i);
} catch(Exception e) { }
}
}

王君 2007-09-18 14:49 发表评论

王君 — Tue, 18 Sep 2007 06:48:00 GMT

一、��Y件下�?�Q?br />
　　1、java

　　�q�里使用的是jdk1.4.2�?

　　下蝲地址:http://dlc.sun.com/jdk/j2sdk-1_4_2_07-windows-i586-p.exe;

　　2、tomcat

　　�q�里的tomcat的版本是5.0的，安装版或是解压版都是可以的�?

　　下蝲地址:http://apache.linuxforum.net/dis ... a-tomcat-5.0.28.exe

　　3、数据库

　　推荐使用mysql�Q�but暂时找不��C��载地址�Q�由于此�ơ偶们班有课�E�设计要用sqlserver的，所以下面实践会使用sqlserver(扑ּ�安装盘安�?

　　�?�q�接sqlserver需要三个jar文�g(文�g名ms开�?�Q�可从这里下�?

　　http://www.softhouse.com.cn/html ... 11250300001646.html

　　上面包括完整的配�|�方�?

　　二、��Y件安�?�Q?br />
　　1.双击安装jdk。装完后在我的电�?>属�?>高��->环境变量->�pȝ��变量中添加以下环境变�?

　　(假设你的JDK安装在c:/jdk)

　　JDK_HOME=C:jdk

　　classpath=.;%JDK_HOME%libdt.jar;%JDK_HOME%libtools.jar

　　在PATH(原来��已存在)中添�?%JDK_HOME%bin

　　�q�样jdk环境配置成功�?

　　2.双击安装你的Tomcat�?��安装在D:/tomcat)

　　�?tomcat5.0.x版本不需配置环境变量��可以��用，但如果需要编译Servlet则必��d��tomcat的两个jar文�g也放到环境变量中�Q�具体方法如�?

　　在我的电�?>属�?>高��->环境变量->�pȝ��变量中添�?

　　TOMCAT_HOME=D:tomcat

　　修改classpath变成:.;%JDK_HOME%libdt.jar;%JDK_HOME%libtools.jar;%TOMCAT_HOME%commonlibservlet-api.jar;%TOMCAT_HOME%commonlibjsp-api.jar;

　　�q�样已经完整安装完Tomcat了�?

　　��:在PATH中再��d��:%JDK_HOME%bin;%TOMCAT_HOME%bin

　　�q�样做的目的是在虚拟dos中可以��用tomcat的工�?

　　最后顺便把�W�一步下载回来的三个jar文�g攑ֈ�tomcat目录下的common/lib目录�?

　　3.��试:

　　打开开始菜单中的tomcat(��猫图案)的monitor工具�Q�点击start server�Q�显�C�绿色三角�Ş即�ؓ启动�Q�打开��览器在地址栏输�?http://localhost:8080/可以看到��猫图案说明已经配置成功�?

　　4.安装数据�?sqlserver)

　　windows xp下必��d��装个人版或开发版(个�h推荐个�h�?�?

　　一直next��可�?微��Y的东西就是方�?�Q�这里注意到域帐户那里选择本机帐户�Q�到验证那里选择混合验证(�q�点很重要，若选择�pȝ��认证以后在程序中��p��接不上数据库)�Q��ؓ你的sa用户输入一个密�?如果�l�习用就不用考虑安全性啦�Q�选择“�I�密�?#8221;��可�?

　　三、正式编�E�：

　　1.建立数据�?

　　打开开始菜单找到sqlserver的快��h��式组里面的企业管理器�Q�点开左边的树一般有个localhost�q�接�Q�如果有个绿色三角�Ş�W�号证明数据库连接成功。点击邮件新建数据库�Q�在你新建的数据库中再新��Z��数据�?例如叫test)�Q�数据表建立若干字段�?

　　补充:提供另一�U�徏表方法是使用sql脚本��。首先创建如下文�?

　　test.sql

　　create database test

　　USE test

　　create table test

　　(

　　id int not null identity(1,1),

　　mark varchar(255),

　　name varchar(255),

　　sex varchar(255)

　　)

　　然后打开开始菜单中sqlserver快捷方式�l�中的查询分析器�Q�点�?#8220;文�g”-�?#8220;打开”�Q�选择test.sql�Q�点击运行即可�?

　　2.建立tomcat虚拟目录

　　在�Q意你喜欢的地方徏立一个文件夹(例如e:/wool)�Q�在文�g夹中建立WEB-INF文�g�?注意必须大写)�Q�WEB-INF文�g夹中再徏立classes和lib两个文�g夹，��第一步下载的三个jar文�g(�q�接数据库用)攑օ�lib文�g夹中�?有�h可能�?�q�里��Z��没有web.xml�q�个文�g�Q�不急，后面会说�?

　　3.配置文�g与连接池

　　�q�次班里做课�E�设计这步难倒不��同学，我这里有最��单方�?��师��去http://localhost:8080/admin中去配置�Q�我个�h觉得那样�ȝ��而且�Ҏ��出错)�Q�好�Q�下面介�l�步骤：

　　首先�Q�按下面内容建立好两个文�Ӟ��

wool.xml

　　

　　

　　

　　

　　

　　

　　driverClassName

　　com.microsoft.jdbc.sqlserver.SQLServerDriver

　　

　　

　　url

　　jdbc:microsoft:sqlserver://localhost;DatabaseName=test