亚洲av无码潮喷在线观看,国产亚洲老熟女视频,亚洲精品美女久久777777

刘璐 — Thu, 08 Mar 2007 05:27:00 GMT

abstract class和interface是Java语言中对于抽象类定义�q�行支持的两�U�机�Ӟ��正是�׃��q�两�U�机制的存在�Q�才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的�怼�性，甚至可以�怺�替换�Q�因此很多开发者在�q�行抽象�c�d��义时对于abstract class和interface的选择昑־�比较随意。其实，两者之间还是有很大的区别的�Q�对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意囄��理解是否正确、合理。本文将对它们之间的区别�q�行一番剖析，试图�l�开发者提供一个在二者之间进行选择的依据。 �?br />
理解抽象�c� �?br />
abstract class和interface在Java语言中都是用来进行抽象类�Q�本文中的抽象类�q��从abstract class��译而来�Q�它表示的是一个抽象体�Q�而abstract class为Java语言中用于定义抽象类的一�U�方法，误��者注意区分）定义的，那么什么是抽象�c�，使用抽象�c�能为我们带来什么好处呢�Q� �?br />
在面向对象的概念中，我们知道所有的对象都是通过�c�L��描绘的，但是反过来却不是�q�样。�ƈ不是所有的�c�都是用来描�l�对象的�Q�如果一个类中没有包含��够的信息来描�l�一个具体的对象�Q�这��L��c�d��是抽象类。抽象类往往用来表征我们在对问题领域�q�行分析、设计中得出的抽象概念，是对一�p�d��看上��M��同，但是本质上相同的具体概念的抽象。比如：如果我们�q�行一个图形编辑��Y件的开发，��׃��发现问题领域存在着圆、三角�Ş�q�样一些具体概念，它们是不同的�Q�但是它们又都属于�Ş状这样一个概念，形状�q�个概念在问题领域是不存在的�Q�它��是一个抽象概��c��正是因为抽象的概念在问题领域没有对应的具体概念�Q�所以用以表征抽象概�늚�抽象�c�L��不能够实例化的。 �?br />
在面向对象领域，抽象�c�M��要用来进行类型隐藏。我们可以构造出一个固定的一�l�行为的抽象描述�Q�但是这�l�行为却能够有�Q意个可能的具体实现方式。这个抽象描�q�就是抽象类�Q�而这一�l��Q意个可能的具体实现则表现为所有可能的�z��c�R��模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允�怿�改的�Q�同�Ӟ��通过从这个抽象体�z��Q�也可扩展此模块的行为功能。熟悉OCP的读者一定知道，��Z��能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)�Q�抽象类是其中的关键所在。 �?br />

从语法定义层面看abstract class和interface

在语法层面，Java语言对于abstract class和interface�l�出了不同的定义方式�Q�下面以定义一个名为Demo的抽象类��Z��来说明这�U�不同。 �?br />
使用abstract class的方式定义Demo抽象�cȝ��方式如下�Q� �?br />
abstract class Demo ｛ �?br /> abstract void method1();
abstract void method2();
… �?br />｝ �?br />
使用interface的方式定义Demo抽象�cȝ��方式如下�Q� �?br />
interface Demo {
void method1();
void method2();
… �?br />}

在abstract class方式中，Demo可以有自��q��数据成员�Q�也可以有非abstarct的成员方法，而在interface方式的实��C��Q�Demo只能够有静态的不能被修改的数据成员�Q�也��是必须是static final的，不过在interface中一般不定义数据成员�Q�，所有的成员�Ҏ��都是abstract的。从某种意义上说�Q�interface是一�U�特�D��Ş式的abstract class。 �?br />
      从编�E�的角度来看�Q�abstract class和interface都可以用来实�?design by contract"的思想。但是在具体的��用上面还是有一些区别的。 �?br />
首先�Q�abstract class在Java语言中表�C�的是一�U��承关�p�，一个类只能使用一�ơ��承关�p�R��但是，一个类却可以实现多个interface。也许，�q�是Java语言的设计者在考虑Java对于多重�l�承的支持方面的一�U�折中考虑吧。 �?br />
其次�Q�在abstract class的定义中�Q�我们可以赋予方法的默认行�ؓ。但是在interface的定义中�Q�方法却不能拥有默认行�ؓ�Q��ؓ了绕�q�这个限�Ӟ��必须使用委托�Q�但是这会增加一些复杂性，有时会造成很大的麻烦。 �?br />
在抽象类中不能定义默认行��存在另一个比较严重的问题�Q�那��是可能会造成�l�护上的�ȝ��。因为如果后来想修改�cȝ��界面�Q�一般通过abstract class或者interface来表�C�）以适应新的情况�Q�比如，��d��新的�Ҏ��或者给已用的方法中��d��新的参数�Q�时�Q�就会非常的�ȝ��Q�可能要��p��很多的时��_��对于�z��c�d��多的情况�Q�尤为如此）。但是如果界面是通过abstract class来实现的�Q�那么可能就只需要修改定义在abstract class中的默认行�ؓ��可以了。 �?br />
同样�Q�如果不能在抽象�c�M��定义默认行�ؓ�Q�就会导致同��L��Ҏ��实现出现在该抽象�cȝ��每一个派生类中，�q�反�?one rule�Q�one place"原则�Q�造成代码重复�Q�同样不利于以后的维护。因此，在abstract class和interface间进行选择时要非常的小心。 �?br />

从设计理念层面看abstract class和interface

上面主要从语法定义和�~�程的角度论�q�C��abstract class和interface的区别，�q�些层面的区别是比较低层�ơ的、非本质的。本��节��从另一个层面：abstract class和interface所反映出的设计理念�Q�来分析一下二者的区别。作者认为，从这个层面进行分析才能理解二者概�늚�本质所在。 �?br />
前面已经提到�q�，abstarct class在Java语言中体��C��一�U��承关�p�，要想使得�l�承关系合理�Q�父�c�d��z��c�M��间必��d��?is a"关系�Q�即父类和派生类在概忉|��质上应该是相同的�Q�参考文献�?〕中有关�?is a"关系的大��幅深入的论�q�ͼ�有兴��的读者可以参考）。对于interface 来说则不�Ӟ��q�不要求interface的实现者和interface定义在概忉|��质上是一致的�Q�仅仅是实现了interface定义的契�U�而已。�ؓ了��便于理解�Q�下面将通过一个简单的实例�q�行说明。 �?br />
考虑�q�样一个例子，假设在我们的问题领域中有一个关于Door的抽象概念，该Door��h��执行两个动作open和close�Q�此时我们可以通过abstract class或者interface来定义一个表�C��抽象概念的类型，定义方式分别如下所�C�：

使用abstract class方式定义Door�Q� �?br />
abstract class Door {
abstract void open();
abstract void close()�Q� �?br />}


使用interface方式定义Door�Q� �?br />

interface Door {
void open();
void close();
}


其他具体的Door�c�d��可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看��h��好像使用abstract class和interface没有大的区别。 �?br />
如果现在要求Door�q�要��h��报警的功能。我们该如何设计针对该例子的�cȝ��构呢�Q�在本例中，主要是�ؓ了展�C�abstract class和interface反映在设计理念上的区别，其他斚w��无关的问题都做了��化或者忽略）�Q�下面将�|�列出可能的解决�Ҏ��Q��ƈ从设计理念层面对�q�些不同的方案进行分析。 �?br />
解决�Ҏ��一�Q� �?br />
��单的在Door的定义中增加一个alarm�Ҏ��Q�如下：

abstract class Door {
abstract void open();
abstract void close()�Q� �?br /> abstract void alarm();
}


或者 �?br />
interface Door {
void open();
void close();
void alarm();
}


那么��h��报警功能的AlarmDoor的定义方式如下：

class AlarmDoor extends Door {
void open() { … }
void close() { … }
void alarm() { … }
}


或者 �?br />
class AlarmDoor implements Door ｛ �?br /> void open() { … }
void close() { … }
void alarm() { … }
｝ �?br />
�q�种�Ҏ��q�反了面向对象设计中的一个核心原则ISP�Q�Interface Segregation Priciple�Q�，在Door的定义中把Door概念本��n固有的行为方法和另外一个概�?报警�?的行为方法�؜在了一赗��这样引��L��一个问题是那些仅仅依赖于Door�q�个概念的模块会因�ؓ"报警�?�q�个概念的改变（比如�Q�修改alarm�Ҏ��的参敎ͼ�而改变，反之依然。 �?br />
解决�Ҏ��二：

既然open、close和alarm属于两个不同的概念，�Ҏ��ISP原则应该把它们分别定义在代表�q�两个概�늚�抽象�c�M��。定义方式有�Q�这两个概念都��用abstract class方式定义�Q�两个概念都使用interface方式定义�Q�一个概念��用abstract class方式定义�Q�另一个概念��用interface方式定义。 �?br />
昄��Q�由于Java语言不支持多重��承，所以两个概念都使用abstract class方式定义是不可行的。后面两�U�方式都是可行的�Q�但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意囄��反映是否正确、合理。我们一一来分析、说明。 �?br />
如果两个概念都��用interface方式来定义，那么��反映出两个问题�Q?、我们可能没有理解清楚问题领域，AlarmDoor在概忉|��质上到底是Door�q�是报警器？2、如果我们对于问题领域的理解没有问题�Q�比如：我们通过对于问题领域的分析发现AlarmDoor在概忉|��质上和Door是一致的�Q�那么我们在实现时就没有能够正确的揭�C�我们的设计意图�Q�因为在�q�两个概�늚�定义上（均��用interface方式定义�Q�反映不��Z��q�含义。 �?br />
如果我们对于问题领域的理解是�Q�AlarmDoor在概忉|��质上是Door�Q�同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢�Q�前面已�l�说�q�，abstract class在Java语言中表�C�Z��U��承关�p�，而��承关�p�d��本质上是"is a"关系。所以对于Door�q�个概念�Q�我们应该��用abstarct class方式来定义。另外，AlarmDoor又具有报警功能，说明它又能够完成报警概念中定义的行�ؓ�Q�所以报警概念可以通过interface方式定义。如下所�C�：

abstract class Door {
abstract void open();
abstract void close()�Q� �?br />}
interface Alarm {
void alarm();
}
class AlarmDoor extends Door implements Alarm {
void open() { … }
void close() { … }
    void alarm() { … }
}


�q�种实现方式基本上能够明��的反映出我们对于问题领域的理解�Q�正��的揭示我们的设计意图。其实abstract class表示的是"is a"关系�Q�interface表示的是"like a"关系�Q�大家在选择时可以作��Z��个依据，当然�q�是建立在对问题领域的理解上的，比如�Q�如果我们认为AlarmDoor在概忉|��质上是报警器�Q�同时又��h��Door的功能，那么上述的定义方式就要反�q�来了�?/font>

刘璐 2007-03-08 13:27 发表评论

刘璐 — Thu, 28 Dec 2006 09:36:00 GMT

主要��我所了解的J2EE开发的框架或开源项目做个介�l?可以�Ҏ��需求选用适当的开源组件进行开�?主要�q�是以Spring为核�?也�ȝ��了一些以前web开发常用的开源工具和开源类�?/div>

1持久�?

1)Hibernate

�q�个不用介绍�?用的很频�J?用的比较多的是映��?包括�l�承映射和父子表映射

对于DAO在这里介�l�个在它基础上开发的包bba96,目前最新版本是bba96 2.0它对Hibernate�q�行了封�? 查询功能包括执行hsql或者sql查询/更新的方法，如果你要多层�ơ逻辑的条件查询可以自��q��装QueryObject.可以参考它做HibernateDAO.也可以直接利用它

2) iBATIS

另一个ORM工具,Apache�?没有Hibernate那么集成,自由度比较大

2:SpringMVC

原理说明和快速入�?

配置文�g�?

Spring的配�|�文仉��认�ؓWEB-INF/xxxx-servelet.xm其中xxx为web.xml中org.springframework.web.servlet.DispatcherServlet的servlet-name�?/div>

Action分发:

Spring��按照配�|�文件定义的URL�Q�Mapping到具体Controller�c�，再根据URL里的action= xxx或其他参敎ͼ�利用反射调用Controller里对应的Action�Ҏ��?/div>

输入数据�l�定:

Spring提供Binder 通过名字的一一对应反射�l�定Pojo�Q�也可以直接从request.getParameter()取数据�?/div>

输入数据验证

Sping 提供了Validator接口当然�q�可以��用开源的Commons-Validaor支持最�?/div>

Interceptor(拦截�?

Spring的拦截器提供接口需要自��q��?在这点不如WebWork做的�?全面

(�q�里提一下WebWork和Struts的区别最主要的区别在于WebWork在徏立一个Action时是新New一个对象而Struts是SingleMoule所有的都��承它的一个Action,所以根据项目需要合适的选择.)

3:View�?/div>

1) 标签�?JSP2.0/JSTL

�׃��Webwork或Spring的标�{��实很有限,一般view层用JSTL标签,而且据说JSTL设计很好速度是所有标�{�中最快的使用��h��也很��?/div>

2) 富客��L��:DOJO Widgets, YUI(YahooUI),FCKEditor, Coolest日历控�g

Dojo主要提供Tree, Tab�{�富客户端控�?可以用其�q�行辅助客户端开�?/div>

YahooUI和DOJO一样它有自��q��一套javascript调试控制�?主要支持ajax开发也有很多Tree,Table,Menu�{�富客户端控�?/div>

FCKEditor 最��行的文本编辑器

Coolest日历控�g 目前很多日历控�g可用,集成在项目中也比较简�?�q�个只是其中的一�?界面不错的说..

3) JavaScript:Prototype.js

Prototype.js作�ؓjavascript的成功的开源框�Ӟ��装了很多好用的功能,通过它很�Ҏ��~�写AJAX应用,现在AJAX技术逐渐成熟,框架资源比较丰富,比如YUI,DWR�{�等,也是因�ؓJavaScript没有合适的调试工具,所以没有必要从零开始编写AJAX应用,个�h认�ؓ多用一些成熟的Ajax框架实现无刷新更新页面是不错的选择.

4)表格控�g:Display Tag ,Extreme Table

�q�两个的功能差不�?都是View层表格的生成,界面也比较相�?可以导出Excel,Pdf,对Spring支持很容�?

相比较而言比较推荐ExtremeTable,它的设计很好功能上比DisplayTag多一�?支持Ajax,��装了一些拦截器,而且最斚w��的是在主��wiki中有详细的中文��用文�?

5):OSCache

OSCache是OpenSymphony�l�织提供的一个J2EE架构中Web应用层的�~�存技术实现组�?Cache是一�U�用于提高系�l�响应速度、改善系�l�运行性能的技术。尤其是在Web应用中，通过�~�存��面的输出结果，可以很显著的改善�pȝ��的稳定性和�q�行性能�?/div>

它主要用在处理短旉��或一定时间内一些数据或��面不会发生变化,或将一些不变的�l�计报表,�~�冲在内�?可以充分的减��L��务器的压�?防治负蝲�q��,快速重启服务器(通过��盘�~�存).

6)SiteMesh

sitemesh应用Decorator模式主要用于提高��面的可�l�护性和复用性，其原理是用Filter截取request和response,把页面组件head,content,banner�l�合��Z��个完整的视图。通常我们都是用include标签在每个jsp��面中来不断的包含各�U�header, stylesheet, scripts and footer�Q�现在，在sitemesh的帮助下�Q�我们删掉他们轻松达到复合视图模�?

Sitemesh也是 OpenSymphony的一个项目现在最�q�的版本�?.2,目前OpenSymphony自从04�q�就没有更新的版本了..感觉它还是比较有创新的一�U�页面组装方�? OpenSymphony开源组�l�的代码一般写的比较漂�?可以改其源代码对自己的项目进行适配.

��试发现Sitemesh�q�存在一些问�?比如中文问题,它的默认�~�码是iso-8859-1在��用时候需要做一些改�?

7)CSS,XHTML

�q�个不用说了,遵��@W3C标准的web��面开�?

8)分页标签: pager-taglib�l��g

Pager-taglib 是一套分��|��{�ֺ��Q�可以灵�z�d��实现多种不同风格的分��导航页面，�q�且可以很好的与服务器分��逻辑分离.使用��h��也比较简�?

9)Form: Jodd Form taglib

Jodd Form taglib使用比较��?只要�?lt;form>的头��以包住

��׃��自动�l�定mybean, 自动�l�定mybean的所有同名属性到普通html标记input, selectbox, checkbox,radiobox.....在这些input框里不用再写��M��代码�?/div>

10)Ajax:DWR

J2EE应用最常用的ajax框架

11)报表图表

Eclipse BIRT功能比较强大,也很庞大..好几�?span twffan="done">M,一般没有特别需求或别的图表设计软�g可以解决的不用它

JasperReports+ iReport是一个基于Java的开源报表工��P��它可以在Java环境下像其它IDE报表工具一��h��制作报表。JasperReports支持PDF、HTML、XLS、CSV和XML文�g输出格式。JasperReports是当前Java开发者最常用的报表工兗��?/div>

JFreeChart主要是用来制作各�U�各��L��图表�Q�这些图表包括：饼图、柱状图(普通柱状图以及堆栈��q��?、线图、区域图、分布图、�؜合图、甘特图以及一些��A表盘�{�等�?/div>

琴棋报表,国��?.重点推荐,适合中国的情�?开放源代码�Q��用完全免贏V��纯JAVA开发，适用多种�pȝ��q�_��。特别适合B/S�l�构的系�l�。官方网站有其优点介�l?看来用它�q�是不错的选择,最重要的是支持国��呵呵

4:权限控制: Acegi

Acegi是Spring Framework 下最成熟的安全系�l�，它提供了强大灉|��的企业��安全服务�Q�如完善的认证和授权机制�Q�Http资源讉K��控制�Q�Method 调用讉K��控制�{�等,支持CAS

(耉��大学的单点登陆技�?�q�个单点登陆�Ҏ��比较出名.我也�q�行�q�配�|��?可以�Ҏ��目需�?如果用户分布在不同的地方不同的系�l�通用一套登陆口令可以用它进行解�?一般注册机登陆机就是这栯��决的)

Acegi只是于Spring�l�合最好的安全框架,功能比较强大,当然�q�有一些其他的安全框架,�q�里列�D一些比较流行的是我从网上找到的,使用�Ҏ��看其官方文档把�?/div>

JAAS, Seraph, jSai - Servlet Security, Gabriel, JOSSO, Kasai, jPAM, OpenSAML都是些安全控制的框架..真够多的呵呵

5:全文��?/div>

1) Lucene

Lucene是一套全文烦引接�?可以通过它将数据�q�行倒排文�g处理加入索引文�g,它的索引速度和查询速度是相当快�?查询百万�U�数据毫�U��出结�?现在最火的Apache开源项�?版本更新速度很快现在已经��C��2.0,每个版本更新的都比较�?目前用的最多的版本应该�?.4.3,但它有个不太斚w��的地方单个烦引文件有2G文�g限制,现在2.0版本没有�q�个限制,我研�I�的比较�?它的扩展性比较好,可以很方面的扩充其分词接口和查询接口.

��Z��它的开发的�pȝ��很多,比如最常用的Eclipse的搜索功�?�q�有一些开源的软�g比如Compass,Nutch,Lius,�q�有我最�q�做的InSearch(企业�U�FTP文�g�|�页搜烦)

6:公共Util�c?/div>

主要是Jakarta-Commons�c�d��,其中最常用得是以下几个�c�d��

1) Jakarta-Commons-Language

最常用得类是StringUtils�c?提供了��用的字符串处理的常用�Ҏ��效率比较�?/div>

2) Jakarta-Commons-Beantuils

主要用Beantuils能够获得反射函数��装及对嵌套属性，map,array型属性的��d��?/div>

3) Jakarta-Commons-Collections

里面有很多Utils�Ҏ��

7 日志��理

Log4J

��d��是日志记�?分�ؓInfo,Warn,error几个层次可以更好的调试程�?/div>

8 开源的J2EE框架

1) Appfuse

Appfuse是Matt Raible 开发的一个指导性的入门�U�J2EE框架, 它对如何集成��行的Spring、Hibernate、iBatis、Struts、Xdcolet、JUnit�{�基��框架�l�出了示�? 在持久层�Q�AppFuse采用了Hibernate O/R映射工具�Q�在容器斚w��Q�它采用了Spring,用户可以自由选择Struts、Spring/MVC�Q�Webwork�Q�JSF�q�几个Web框架�?/div>

2) SpringSide

.SpringSide较完整的演示了企业应用的各个斚w��,是一个电子商务网站的应用 SpringSide也大量参考了Appfuse中的优秀�l�验。最重要的是它是国内的一个开源项�?可以了解到国内现在的一些实际技术动态和方向很有指导意义�?/div>

9:模版 Template

主要有Veloctiy和Freemarker

模板用Servlet提供的数据动态地生成 HTML。编译器速度快，输出接近静态HTML ��面的速度�?/div>

10:工作��?/div>

我所知道比较出名的主要有JBpm Shark Osworkflow,�׃��对它没有�q�多的研�I�所以还不是很清楚之间有什么区�?

��目��理软�g

dotProject:是一个基于LAMP的开源项目管理��Y件。最出名的项目管理��Y�?/div>

JIRA: ��目计划�Q��Q务安排，错误��理

Bugzilla:提交和管理bug,和eclipse集成,可以通过安装MyEclipse配置一下即可��?/div>

BugFree借鉴微��Y公司软�g研发理念、免费开放源代码、基于Web的精��版Bug��理

CVS:�q�个��׃��介绍了都在用.

SVN: SubVersion已逐渐��越CVS�Q�更适应于JavaEE的项目。Apache用了它很久后�Q�Sourceforge刚刚推出SVN的支持�?/div>

��试用例:主要JUnit单元��试,�~�写TestCase,Spring也对Junit做了很好的支�?/div>

后记:

以Spring��Z��的应用开发可选用的组件中间�g真是��D��~��ؕ,所以针对不同的��目需求可以利用不同的开源��品解�?比如用Spring+Hibernate/ iBATIS或Spring+WebWork+Hibernate/ iBATIS或Spring+Struts+Hibernate/ iBATIS,合理的框架设计和代码复用设计寚w��目开发效率和�E�序性能有很大的提高,也有利于后期的维�?

刘璐 2006-12-28 17:36 发表评论

JAVA断言使用

刘璐 — Tue, 24 Oct 2006 08:17:00 GMT

�怿�学过c,c++的朋友一定不会对断言感到陌生。下面介�l�一下断�a�在JAVA中的使用�Q�JAVA是从JDK1.4才开始支持断�a�的（��d��了关键字assert�Q?��h��意老版的JRE不支持�?br />

断言概述

  �~�写代码�Ӟ��我们��L��会做��Z��些假设，断言��是用于在代码中捕捉�q�些假设
  可以��断�a�看作�?b>异常处理的一�U�高�U��Ş�?/b>
  断言表示��Z��些布��表辑ּ��Q�程序员�怿�在程序中的某个特定点该表辑ּ��gؓ�?br />  可以在�Q何时候启用和��用断言验证�Q�因此可以在��试时启用断�a�而在部��v时禁用断�a�。同��P��E�序投入�q�行后，最�l�用户在遇到问题时可以重新�v用断�a��?br />  使用断言可以创徏更稳定，品质更好且易于除错的代码
  当需要在一个��gؓFALSE时中断当前操作的话，可以使用断言
  单元��试必须使用断言�Q�Junit/JunitX�Q?br />  除了�c�d��查和单元��试外，断言�q�提供了一�U�确定个�U�特性是否在�E�序中得到维护的极好的方�?br />  使用断言使我们向按契�U�式设计更近了一�?br />

常见的断�a��Ҏ�?/h3>
前置条�g断言�Q�代码执行之前必��d��备的�Ҏ�?br /> 后置条�g断言�Q�代码执行之后必��d��备的�Ҏ�?br /> 前后不变断言�Q�代码执行前后不能变化的�Ҏ�?br />

断言使用方式

  断言可以有两�U��Ş�?br />  1.assert Expression1
  2.assert Expression1:Expression2
  其中Expression1应该��L��一个布��|��Expression2是断�a��p�|时输出的��p�|消息的字�W�串。如果Expression1为假�Q�则抛出一个 AssertionError�Q�这是一个错误，而不是一个异常，也就是说是一个不可控制异常（unchecked Exception),AssertionError�׃��是错误，所以可以不捕获�Q�但不推荐这样做�Q�因为那样会使你的系�l�进入不�E�_��状态�?br />

��L��断言

  断言在默认情况下是关闭的�Q�要在编译时启用断言�Q�需要��用source1.4标记既javac source1.4 Test.java ,在运行时启用断言需要��用�?ea参数。要在系�l�类中启用和��用断言可以使用 -esa 和�?dsa参数�?br />
例如�Q?br />public class AssertExampleOne{
   public AssertExampleOne(){}
   public static void main(String args[]){
      int x=10;
      System.out.println("Testing Assertion that x==100");
      assert x==100:"Out assertion failed!";
      System.out.println("Test passed!");
   }
}

如果�~�译时未加�?source1.4,则编译通不�q?br />在执行时未加 -ea 时输��Zؓ
Testing Assertion that x==100
Test passed
jre忽略了断�a�的就代码�Q�而��用了该参数就会输��Zؓ
Testing Assertion that x==100
Exception in thread "main" java.lang.AssertionError: Out assertion failed!
        at AssertExampleOne.main(AssertExampleOne.java:6)

断言的副作用

  �׃��E�序员的问题�Q�断�a�的��用可能会带来副作用，例如�Q?br />  boolean isEnable=false;
  //...
  assert isEnable=true;
  �q�个断言的副作用是因为它修改了程序中变量的值�ƈ且未抛出错误�Q�这��L��错误如果不细心的��查是很难发现的。但是同时我们可以根据以上的副作用得��C��个有用的�Ҏ��，�Ҏ��它来��试断言是否打开�?br />
public class AssertExampleTwo{

   public static void main(String args[]){
     boolean isEnable=false;
     //...
     assert isEnable=true;
     if(isEnable==false){
       throw new RuntimeException("Assertion shoule be enable!");
     }
   }
}

何时需要��用断�a�

  1.可以在预计正常情况下�E�序不会到达的地�Ҏ��|�断�a� �Q�assert false
  2.断言可以用于��查传递给�U�有�Ҏ��的参数。（对于公有�Ҏ��Q�因为是提供�l�外部的接口�Q�所以必��d��Ҏ��中有相应的参数检验才能保证代码的健壮性）
  3.使用断言��试�Ҏ��执行的前�|�条件和后置条�g
  4.使用断言��查类的不变状态，��保��M��情况下，某个变量的状态必��L��뀂（如age属性应大于0��于某个合适��|��

什么地方不要��用断�a�

断言语句不是永远会执行，可以屏蔽也可以启�?br />因此�Q?br /> 1.不要使用断言作�ؓ公共�Ҏ��的参数检查，公共�Ҏ��的参数永�q�都要执�?br /> 2.断言语句不可以有��M��边界效应�Q�不要��用断�a�语句��M��改变量和改变�Ҏ��的返回�?br />
参考：
http://jcp.org/en/jsr/detail?id=41
http://java.sun.com/j2se/1.4.2/docs/guide/lang/assert.html
http://www-128.ibm.com/developworkers/cn/java/jdiag0723/
http://www-128.ibm.com/developworkers/cn/java/jmerlin/part9/

刘璐 2006-10-24 16:17 发表评论

static�Ҏ��不应该被重写

刘璐 — Tue, 24 Oct 2006 03:47:00 GMT

如果你认为重写只是在子类中简单的替换了一个方法，你就很容易认为static �Ҏ��也能
被重写。事实上�Q�我有很多包含�h们�D例指明static �Ҏ��能被重写的代码的邮�g。然而，�q?br />些�ƈ没有考虑�Ҏ��重写在运行时军_��哪个版本的方法被调用的细节问题。下面的代码��g��?br />明static �Ҏ��是怎样被重写的�?br />class Base{
   static void amethod(){
   System.out.println("Base.amethod");
   }
}
public class Cravengib extends Base{
   public static void main(String arg[]){
      Cravengib cg = new Cravengib();
      cg.amethod();
   }
   static void amethod(){
      System.out.println("Cravengib.amethod");
   }
}
如果你编译�ƈ�q�行�q�段代码�Q�你会发现输出文本Cravengib.amethod�Q�这��g��很好的指
明了重写。然而，对于重写�Q�还有相对于在子�c�M��使用一个方法简单替换另一个方法更多的
东西。还有运行时军_��的方法基于引用的�cȝ��c�d��的问题，�q�可以通过刉��正在被实例化的
�cȝ��引用�c�d��Q�实例初始化语句的左半部分）来说明�?br />在上面的例子中，因�ؓ名字叫amethod 的方法与�c�d��生了兌��Q�而不是与特定的类的实
例相兌��Q�它不在乎什么类型的�c�L��在创建它�Q�而仅仅在意引用的�c�d��。因此，如果你在�?br />用amethod 前改变一下这一行，
Base cg= new Cravengib()
你就会发现当你运行程序时�Q�你会得到输出：Base.amethod
cg 是一个类Cravengib 在内存中的一个Base �c�d��的实例的引用�Q�或者指针）。如果一个static
�Ҏ��被调用了�Q�JVM 不会��查什么类型正在指向它�Q�它只会调用跟Base �cȝ��兌��的方法的
实例�?br />与上面的情况相对比：当一个方法被重写�Ӟ��JVM ��查通过引用正在指向的类的类型，
�q�调用此�c�d��相关的方法。可以结束这个例子了�Q�如果你��两个版本的amethod �Ҏ��改变�?br />非static�Q��ƈ依然创徏�c�：
Base cg= new Cravengib()
�~�译�q�运行上�q�C��码，你会发现amethod 已经被重写了�Q��ƈ且输出Cravengib.amethod�?/p>

刘璐 2006-10-24 11:47 发表评论

java反射机制

刘璐 — Fri, 08 Sep 2006 09:56:00 GMT

Reflection �?Java �E�序开发语�a�的特征之一�Q�它允许�q�行中的 Java �E�序对自�w�进行检查，或者说“自审”，�q�能直接操作�E�序的内部属性。例如，使用它能获得 Java �c�M��各成员的名称�q�显�C�出来�?br />
Java 的这一能力在实际应用中也许用得不是很多�Q�但是在其它的程序设计语�a�中根本就不存在这一�Ҏ��。例如，Pascal、C 或�?C++ 中就没有办法在程序中获得函数定义相关的信息�?br />
JavaBean �?reflection 的实际应用之一�Q�它能让一些工具可视化的操作��Y件组件。这些工具通过 reflection 动态的载入�q�取�?Java �l��g(�c? 的属性�?br />

1. 一个简单的例子

考虑下面�q�个��单的例子�Q�让我们看看 reflection 是如何工作的�?br />
import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++)
System.out.println(m[i].toString());
} catch (Throwable e) {
System.err.println(e);
}
}
}

按如下语句执行：

java DumpMethods java.util.Stack

它的�l�果输出为：

public java.lang.Object java.util.Stack.push(java.lang.Object)

public synchronized java.lang.Object java.util.Stack.pop()

public synchronized java.lang.Object java.util.Stack.peek()

public boolean java.util.Stack.empty()

public synchronized int java.util.Stack.search(java.lang.Object)

�q�样��列��Z��java.util.Stack �cȝ��各方法名以及它们的限制符和返回类型�?br />
�q�个�E�序使用 Class.forName 载入指定的类�Q�然后调�?getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描�q�某个类中单个方法的一个类�?br />
2.开始��?Reflection

用于 reflection 的类�Q�如 Method�Q�可以在 java.lang.relfect 包中扑ֈ�。��用这些类的时候必��要遵��@三个步骤�Q�第一步是获得你想操作的类�?java.lang.Class 对象。在�q�行中的 Java �E�序中，�?java.lang.Class �c�L��描述�c�d��接口�{��?br />
下面��是获得一�?Class 对象的方法之一�Q?br />
Class c = Class.forName("java.lang.String");

�q�条语句得到一�?String �cȝ��c�d��象。还有另一�U�方法，如下面的语句�Q?br />
Class c = int.class;

或�?br />
Class c = Integer.TYPE;

它们可获得基本类型的�c�M��息。其中后一�U�方法中讉K��的是基本�c�d��的封装类 (�?Integer) 中预先定义好�?TYPE 字段�?br />
�W�二步是调用诸如 getDeclaredMethods 的方法，以取得该�c�M��定义的所有方法的列表�?br />
一旦取得这个信息，��可以进行第三步了——��?reflection API 来操作这些信息，如下面这�D�代码：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的�W�一个方法的原型�?br />
在下面的例子中，�q�三个步骤将��Z��?reflection 处理�Ҏ��应用�E�序提供例证�?br />
模拟 instanceof 操作�W?br />
得到�c�M��息之后，通常下一个步骤就是解军_��?Class 对象的一些基本的问题。例如，Class.isInstance �Ҏ��可以用于模拟 instanceof 操作�W�：

class A {
}

public class instance1 {
public static void main(String args[]) {
try {
Class cls = Class.forName("A");
boolean b1 = cls.isInstance(new Integer(37));
System.out.println(b1);
boolean b2 = cls.isInstance(new A());
System.out.println(b2);
} catch (Throwable e) {
System.err.println(e);
}
}
}

在这个例子中创徏了一�?A �cȝ�� Class 对象�Q�然后检查一些对象是否是 A 的实例。Integer(37) 不是�Q�但 new A() 是�?br />
3.扑և��cȝ��Ҏ��

扑և�一个类中定义了些什么方法，�q�是一个非常有价��g��非常基础�?reflection 用法。下面的代码��实��C��q�一用法�Q?br />
import java.lang.reflect.*;

public class method1 {
private int f1(Object p, int x) throws NullPointerException {
if (p == null)
throw new NullPointerException();
return x;
}

public static void main(String args[]) {
try {
Class cls = Class.forName("method1");
Method methlist[] = cls.getDeclaredMethods();
for (int i = 0; i < methlist.length; i++) {
Method m = methlist[i];
System.out.println("name = " + m.getName());
System.out.println("decl class = " + m.getDeclaringClass());
Class pvec[] = m.getParameterTypes();
for (int j = 0; j < pvec.length; j++)
System.out.println("param #" + j + " " + pvec[j]);
Class evec[] = m.getExceptionTypes();
for (int j = 0; j < evec.length; j++)
System.out.println("exc #" + j + " " + evec[j]);
System.out.println("return type = " + m.getReturnType());
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}

�q�个�E�序首先取得 method1 �cȝ��描述�Q�然后调�?getDeclaredMethods 来获取一�p�d��?Method 对象�Q�它们分别描�q�C��定义在类中的每一个方法，包括 public �Ҏ��、protected �Ҏ��、package �Ҏ��?private �Ҏ��{�。如果你在程序中使用 getMethods 来代�?getDeclaredMethods�Q�你�q�能获得�l�承来的各个�Ҏ��的信息�?br />
取得�?Method 对象列表之后�Q�要昄��q�些�Ҏ��的参数类型、异常类型和�q�回值类型等��׃��难了。这些类型是基本�c�d��q�是�cȝ��型，都可以由描述�cȝ��对象按顺序给出�?br />
输出的结果如下：

name = f1

decl class = class method1

param #0 class java.lang.Object

param #1 int

exc #0 class java.lang.NullPointerException

return type = int

-----

name = main

decl class = class method1

param #0 class [Ljava.lang.String;

return type = void

-----

4.获取构造器信息

获取�c�L��造器的用法与上述获取�Ҏ��的用法类��|��如：

import java.lang.reflect.*;

public class constructor1 {
public constructor1() {
}

protected constructor1(int i, double d) {
}

public static void main(String args[]) {
try {
Class cls = Class.forName("constructor1");
Constructor ctorlist[] = cls.getDeclaredConstructors();
for (int i = 0; i < ctorlist.length; i++) {
Constructor ct = ctorlist[i];
System.out.println("name = " + ct.getName());
System.out.println("decl class = " + ct.getDeclaringClass());
Class pvec[] = ct.getParameterTypes();
for (int j = 0; j < pvec.length; j++)
System.out.println("param #" + j + " " + pvec[j]);
Class evec[] = ct.getExceptionTypes();
for (int j = 0; j < evec.length; j++)
System.out.println("exc #" + j + " " + evec[j]);
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}

�q�个例子中没能获得返回类型的相关信息�Q�那是因为构造器没有�q�回�c�d��?br />
�q�个�E�序�q�行的结果是�Q?br />
name = constructor1

decl class = class constructor1

-----

name = constructor1

decl class = class constructor1

param #0 int

param #1 double

-----

5.获取�cȝ��字段(�?

扑և�一个类中定义了哪些数据字段也是可能的，下面的代码就在干�q�个事情�Q?br />

import java.lang.reflect.*;

public class field1 {
private double d;
public static final int i = 37;
String s = "testing";

public static void main(String args[]) {
try {
Class cls = Class.forName("field1");
Field fieldlist[] = cls.getDeclaredFields();
for (int i = 0; i < fieldlist.length; i++) {
Field fld = fieldlist[i];
System.out.println("name = " + fld.getName());
System.out.println("decl class = " + fld.getDeclaringClass());
System.out.println("type = " + fld.getType());
int mod = fld.getModifiers();
System.out.println("modifiers = " + Modifier.toString(mod));
System.out.println("-----");
}
} catch (Throwable e) {
System.err.println(e);
}
}
}

�q�个例子和前面那个例子非常相伹{��例中��用了一个新东西 Modifier�Q�它也是一�?reflection �c�，用来描述字段成员的修饰语�Q�如“private int”。这些修饰语自��n由整数描�q�ͼ�而且使用 Modifier.toString 来返回以“官方”顺序排列的字符串描�q?(如“static”在“final”之�?。这个程序的输出是：

name = d

decl class = class field1

type = double

modifiers = private

-----

name = i

decl class = class field1

type = int

modifiers = public static final

-----

name = s

decl class = class field1

type = class java.lang.String

modifiers =

-----

和获取方法的情况一下，获取字段的时候也可以只取得在当前�c�M��x��了的字段信息 (getDeclaredFields)�Q�或者也可以取得父类中定义的字段 (getFields) �?br />

6.�Ҏ��Ҏ��的名�U�来执行�Ҏ��

文本到这里，所丄��例子无一例外都与如何获取�cȝ��信息有关。我们也可以�?reflection 来做一些其它的事情�Q�比如执行一个指定了名称的方法。下面的�C�Z��演示了这一操作�Q?br />
import java.lang.reflect.*;
public class method2 {
public int add(int a, int b) {
return a + b;
}
public static void main(String args[]) {
try {
Class cls = Class.forName("method2");
Class partypes[] = new Class[2];
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
Method meth = cls.getMethod("add", partypes);
method2 methobj = new method2();
Object arglist[] = new Object[2];
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
Object retobj = meth.invoke(methobj, arglist);
Integer retval = (Integer) retobj;
System.out.println(retval.intValue());
} catch (Throwable e) {
System.err.println(e);
}
}
}

假如一个程序在执行的某处的时候才知道需要执行某个方法，�q�个�Ҏ��的名�U�是在程序的�q�行�q�程中指定的 (例如�Q�JavaBean 开发环境中��׃��做这��L��?�Q�那么上面的�E�序演示了如何做到�?br />
上例中，getMethod 用于查找一个具有两个整型参��C��名�ؓ add 的方法。找到该�Ҏ��q�创��Z��相应�?Method 对象之后�Q�在正确的对象实例中执行它。执行该�Ҏ��的时候，需要提供一个参数列表，�q�在上例中是分别包装了整�?37 �?47 的两�?Integer 对象。执行方法的�q�回的同��h��一�?Integer 对象�Q�它��装了返回�?84�?br />
7.创徏新的对象

对于构造器�Q�则不能像执行方法那栯��行，因�ؓ执行一个构造器��意味着创徏了一个新的对�?(准确的说�Q�创��Z��个对象的�q�程包括分配内存和构造对�?。所以，与上例最�怼�的例子如下：

import java.lang.reflect.*;

public class constructor2 {
public constructor2() {
}

public constructor2(int a, int b) {
System.out.println("a = " + a + " b = " + b);
}

public static void main(String args[]) {
try {
Class cls = Class.forName("constructor2");
Class partypes[] = new Class[2];
partypes[0] = Integer.TYPE;
partypes[1] = Integer.TYPE;
Constructor ct = cls.getConstructor(partypes);
Object arglist[] = new Object[2];
arglist[0] = new Integer(37);
arglist[1] = new Integer(47);
Object retobj = ct.newInstance(arglist);
} catch (Throwable e) {
System.err.println(e);
}
}
}

�Ҏ��指定的参数类型找到相应的构造函数�ƈ执行它，以创��Z��个新的对象实例。��用这�U�方法可以在�E�序�q�行时动态地创徏对象�Q�而不是在�~�译的时候创建对象，�q�一炚w��常有价倹{�?br />
8.改变字段(�?的�?br />
reflection 的还有一个用处就是改变对象数据字�D늚�倹{��reflection 可以从正在运行的�E�序中根据名�U�找到对象的字段�q�改变它�Q�下面的例子可以说明�q�一点：

import java.lang.reflect.*;

public class field2 {
public double d;

public static void main(String args[]) {
try {
Class cls = Class.forName("field2");
Field fld = cls.getField("d");
field2 f2obj = new field2();
System.out.println("d = " + f2obj.d);
fld.setDouble(f2obj, 12.34);
System.out.println("d = " + f2obj.d);
} catch (Throwable e) {
System.err.println(e);
}
}
}

�q�个例子中，字段 d 的��D��变�ؓ�?12.34�?br />
9.使用数组

本文介绍�?reflection 的最后一�U�用法是创徏的操作数�l�。数�l�在 Java 语言中是一�U�特�D�的�cȝ��型，一个数�l�的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的：

import java.lang.reflect.*;

public class array1 {
public static void main(String args[]) {
try {
Class cls = Class.forName("java.lang.String");
Object arr = Array.newInstance(cls, 10);
Array.set(arr, 5, "this is a test");
String s = (String) Array.get(arr, 5);
System.out.println(s);
} catch (Throwable e) {
System.err.println(e);
}
}
}

例中创徏�?10 个单位长度的 String 数组�Q��ؓ�W?5 个位�|�的字符串赋了��|��最后将�q�个字符串从数组中取得�ƈ打印了出来�?br />
下面�q�段代码提供了一个更复杂的例子：

import java.lang.reflect.*;

public class array2 {
public static void main(String args[]) {
int dims[] = new int[]{5, 10, 15};
Object arr = Array.newInstance(Integer.TYPE, dims);
Object arrobj = Array.get(arr, 3);
Class cls = arrobj.getClass().getComponentType();
System.out.println(cls);
arrobj = Array.get(arrobj, 5);
Array.setInt(arrobj, 10, 37);
int arrcast[][][] = (int[][][]) arr;
System.out.println(arrcast[3][5][10]);
}
}
例中创徏了一�?5 x 10 x 15 的整型数�l�，�q��ؓ处于 [3][5][10] 的元素赋了��gؓ 37。注意，数组实际上就是数�l�的数组�Q�例如，�W�一�?Array.get 之后�Q�arrobj 是一�?10 x 15 的数�l�。进而取得其中的一个元素，即长度�ؓ 15 的数�l�，�q��?Array.setInt 为它的第 10 个元素赋倹{�?br />
注意创徏数组时的�c�d��是动态的�Q�在�~�译时�ƈ不知道其�c�d��

刘璐 2006-09-08 17:56 发表评论

什么是POJO

刘璐 — Mon, 28 Aug 2006 03:35:00 GMT

��单的JAVA对象�Q�Plain Old Java Objects�Q�实际就是普通JavaBeans,使用POJO名称是�ؓ了和EJB��h��h��, 而且��U�比较直�? 有一些属性及其getter setter�Ҏ��的类,有时可以作�ؓvalue object或dto来��?当然,如果你有一个简单的�q�算属性也是可以的,但不允许有业务方�?不能携带有connection之类�?/span>

刘璐 2006-08-28 11:35 发表评论