abstract class和interface在Java语言中都是用来进行抽象类Q本文中的抽象类q从abstract class译而来Q它表示的是一个抽象体Q而abstract class为Java语言中用于定义抽象类的一U方法，误者注意区分）定义的，那么什么是抽象c，使用抽象c能为我们带来什么好处呢Q?br>在面向对象的概念中，我们知道所有的对象都是通过cL描绘的，但是反过来却不是q样。ƈ不是所有的c都是用来描l对象的Q如果一个类中没有包含够的信息来描l一个具体的对象Q这Lcd是抽象类。抽象类往往用来表征我们在对问题领域q行分析、设计中得出的抽象概念，是对一pd看上M同，但是本质上相同的具体概念的抽象?br>比如Q如果我们进行一个图形编辑Y件的开发，׃发现问题领域存在着圆、三角Şq样一些具体概念，它们是不同的Q但是它们又都属于Ş状这样一个概念，形状q个概念在问题领域是不存在的Q它是一个抽象概c正是因为抽象的概念在问题领域没有对应的具体概念Q所以用以表征抽象概늚抽象cL不能够实例化的?br>在面向对象领域，抽象cM要用来进行类型隐藏。我们可以构造出一个固定的一l行为的抽象描述Q但是这l行为却能够有Q意个可能的具体实现方式。这个抽象描q就是抽象类Q而这一lQ意个可能的具体实现则表现为所有可能的zcR模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允怿改的Q同Ӟ通过从这个抽象体zQ也可扩展此模块的行为功能。熟悉OCP的读者一定知道，Z能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)Q抽象类是其中的关键所在?br>二、从语法定义层面看abstract class和interface
在语法层面，Java语言对于abstract class和interfacel出了不同的定义方式Q下面以定义一个名为Demo的抽象类Z来说明这U不同。用abstract class的方式定义Demo抽象cȝ方式如下Q?br>
abstract class Demo ?br>abstract void method1();
abstract void method2();
…
?br>
使用interface的方式定义Demo抽象cȝ方式如下Q?br>
interface Demo {
void method1();
void method2();
…
}
在abstract class方式中，Demo可以有自q数据成员Q也可以有非abstarct的成员方法，而在interface方式的实CQDemo只能够有静态的不能被修改的数据成员Q也是必须是static final的，不过在interface中一般不定义数据成员Q，所有的成员Ҏ都是abstract的。从某种意义上说Qinterface是一U特DŞ式的abstract class?br>从编E的角度来看Qabstract class和interface都可以用来实?design by contract"的思想。但是在具体的用上面还是有一些区别的?br>首先Qabstract class在Java语言中表C的是一U承关p，一个类只能使用一ơ承关pR但是，一个类却可以实现多个interface。也许，q是Java语言的设计者在考虑Java对于多重l承的支持方面的一U折中考虑吧?br>其次Q在abstract class的定义中Q我们可以赋予方法的默认行ؓ。但是在interface的定义中Q方法却不能拥有默认行ؓQؓ了绕q这个限Ӟ必须使用委托Q但是这?nbsp;增加一些复杂性，有时会造成很大的麻烦?br>在抽象类中不能定义默认行存在另一个比较严重的问题Q那是可能会造成l护上的ȝ。因为如果后来想修改cȝ界面Q一般通过abstract class或者interface来表C）以适应新的情况Q比如，d新的Ҏ或者给已用的方法中d新的参数Q时Q就会非常的ȝQ可能要p很多的时_对于zcd多的情况Q尤为如此）。但是如果界面是通过abstract class来实现的Q那么可能就只需要修改定义在abstract class中的默认行ؓ可以了?br>同样Q如果不能在抽象cM定义默认行ؓQ就会导致同LҎ实现出现在该抽象cȝ每一个派生类中，q反?nbsp;"one ruleQone place"原则Q造成代码重复Q同样不利于以后的维护。因此，在abstract class和interface间进行选择时要非常的小心?br>三、从设计理念层面看abstract class和interface
上面主要从语法定义和~程的角度论qCabstract class和interface的区别，q些层面的区别是比较低层ơ的、非本质的。本文将从另一个层面：abstract class和interface所反映出的设计理念Q来分析一下二者的区别。作者认为，从这个层面进行分析才能理解二者概늚本质所在?br>前面已经提到q，abstarct class在Java语言中体C一U承关p，要想使得l承关系合理Q父cdzcM间必d?is a"关系Q即父类和派生类在概忉|质上应该是相同的。对于interface 来说则不Ӟq不要求interface的实现者和interface定义在概忉|质上是一致的Q仅仅是实现了interface定义的契U而已。ؓ了便于理解Q下面将通过一个简单的实例q行说明?br>考虑q样一个例子，假设在我们的问题领域中有一个关于Door的抽象概念，该Doorh执行两个动作open和closeQ此时我们可以通过abstract class或者interface来定义一个表C抽象概念的类型，定义方式分别如下所C：
使用abstract class方式定义DoorQ?br>
abstract class Door {
abstract void open();
abstract void close()Q?br>}
使用interface方式定义DoorQ?br>
interface Door {
void open();
void close();
}
其他具体的Doorcd可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看h好像使用abstract class和interface没有大的区别?br>如果现在要求Doorq要h报警的功能。我们该如何设计针对该例子的cȝ构呢Q在本例中，主要是ؓ了展Cabstract class和interface反映在设计理念上的区别，其他斚w无关的问题都做了化或者忽略）下面罗列出可能的解x案，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反了面向对象设计中的一个核心原则ISPQInterface Segregation PricipleQ，在Door的定义中把Door概念本n固有的行为方法和另外一个概?报警?的行为方法在了一赗这样引L一个问题是那些仅仅依赖于Doorq个概念的模块会因ؓ"报警?q个概念的改变（比如Q修改alarmҎ的参敎ͼ而改变，反之依然?br>解决Ҏ二：
既然open、close和alarm属于两个不同的概念，ҎISP原则应该把它们分别定义在代表q两个概늚抽象cM。定义方式有Q这两个概念都?nbsp;abstract class方式定义Q两个概念都使用interface方式定义Q一个概念用abstract class方式定义Q另一个概念用interface方式定义?br>昄Q由于Java语言不支持多重承，所以两个概念都使用abstract class方式定义是不可行的。后面两U方式都是可行的Q但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意囄反映是否正确、合理。我们一一来分析、说明?br>如果两个概念都用interface方式来定义，那么反映出两个问题Q?br>1、我们可能没有理解清楚问题领域，AlarmDoor在概忉|质上到底是Doorq是报警器？
2、如果我们对于问题领域的理解没有问题Q比如：我们通过对于问题领域的分析发现AlarmDoor在概忉|质上和Door是一致的Q那么我们在实现时就没有能够正确的揭C我们的设计意图Q因为在q两个概늚定义上（均用interface方式定义Q反映不Zq含义?br>如果我们对于问题领域的理解是QAlarmDoor在概忉|质上是DoorQ同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢Q前面已l说q， abstract class在Java语言中表CZU承关p，而承关pd本质上是"is a"关系。所以对于Doorq个概念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"关系Qinterface表示的是"like a"关系Q大家在选择时可以作Z个依据，当然q是建立在对问题领域的理解上的，比如Q如果我们认为AlarmDoor在概忉|质上是报警器Q同时又h Door的功能，那么上述的定义方式就要反q来了?br>abstract class和interface是Java语言中的两种定义抽象cȝ方式Q它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概忉|质的理解、对于设计意囄反映是否正确、合理，因ؓ它们表现了概念间的不同的关系Q虽焉能够实现需求的功能Q。这其实也是语言的一U的惯用法，希望读者朋友能够细l体?
]]>
xieccQ?br />我们的项目从d12月䆾启动Q采用了Struts+Hibernate的架构，一开始用Hibernate的时候速度极快Q对象操作异常方便，大家都说爽歪歪?
可惜好景不长Q随着我们对象关系的不断复杂，数据量的不断增加QHibernate的性能急剧下降。具体表CؓQ我们在设计对象旉用了很多的one-to-many和many-to-one的关p，在取某个对象的几个简单的属性时Q它会把所有关联的子对象都取出来，l常出在取一个简单属性的时候，调试H口的ＳQＬ语句一屏一屏地往下闪。到最后我的一个test跑完需要１Q分钟?
在忍无可忍之下，我们开始性能优化ҎQ以下我们优化所做的一些事情：
1、将所以one-to-many的关p里lazy设成true
2、修改hibernate.propertiesQ增加了以下两句Q?
hibernate.jdbc.fetch_size=50
hibernate.jdbc.batch_size=100
3、调整WebLogic的pool
4、利用Hibernate提供的CGLIB Proxy机制Qmany-to-one关系的子对象也可以lazy initialization
Q但是我发现调试H口里仍会有取子对象的SQL语句Q但速度实快了Q?
5、利用Hibernate提供的Cache机制Q对关键对象使用Cache
l果优化以后Q我的test可以从原来的12分钟变成50U钟跑完?
原以Z事大吉了Q但当我们面对客L时候，才发现我们系l的性能q远q不够?
我们现在pȝ试运行约两个月，l常在数据保存或者查询时{上一分钟甚至两分钟?
׃客户原来的系l用asp+SQL Server写的Q速度很快。二者一ҎQ我们就被客户骂得惨不忍睏V?
优化真是一件很烦h的事Q在不改动系l框架的情况下，不知q有哪些提高pȝ性能的方法？
freecodeQ?br />同感Q虽然我不用Q不懂hibernate.
前段旉Q我们做了个目Q对一些取数的q程Q采用了javascript脚本Q再通过bsf~译Q运行时Q时间巨长，人家说以前用foxpro做的Q快多了Q弄得我们很没面子?/p>
dhj1Q?br />我也?Struts+Hibernate 做大型项?在ƈ发很高时,每天4500人次讉K量的情况?性能也相当不?
做的旉有几点考虑:
1.大东?如果很多很多的one-to-many和many-to-one的关p? 必定会媄响性能,我刚学习Hibernate 时就有这U直?所以我们没有用one-to-many和many-to-one的关p?而是象SQL一LL作表的关pL识符.
2.如果大的系l?最l必ȝ成HTML的文?是有数据库中有数据更新?自动生成一个HTML文g.大多数用h在只ȝ?在只ȝ态下只LCHTML文g,节省很多资源.
3.更用CHACHE表技?把访问量高的记录自动提到CACHE表中.
xieccQ?br />谢谢dhj1l我提的?
在hibernate|站上看到的好多资源几乎都说hibernate的性能不错Q而且很多人开发的pȝ性能也不错，包括dhj1的，看来hibernate无罪Q是我们设计得太滥了?
不过q是有点疑问?
1、dhj1提到的第一点很有道理。我们确实在有些关键的地方用了标识符来关联。但是我们这个系l的兌实现太多了，如果所以有东西都用标识W作兌的话Q那我们的实体层设计退化成为面向关pȝER图设计，那我们要Hibernate何用Q我用感觉用Hibernate时最大的便利不是在写代码的时候用对象的操作代替SQL语句,而是在徏模的时候可以用面向对象的思维把很复杂的逻辑用UML图表C出?然后直接转化成实体。所以我们在性能影响太大的地斚w用了面向对象和关pȝl合的方式，但在更多的地方仍然只能采用对象关联的方式?
Q、生成静态ￃQ_Q，对特定的pȝ实有用Q但我们pȝ中的数据几乎都是动态的Q所以实现v来有困难。而且我也不太清楚q样做的隑ֺ有多高，具体怎么实现Q请dhj1指点qh|?
Q、Cache我们已经采用了。但proxy的用法我至今仍然有点qL?
在Hibernate的文档里g只要在定义文仉加这么一句就可以了：
<class name="eg.Order" proxy="eg.Order">
但实际用时我们发现q样做之后，Hibernate取数据时的SQL语句g一句都没有?
我们现在的想法是自已来实现Proxyc，它的接口与实体完全一P在Proxy里SQL语句来实现取数据操作。不知是否可行？
sanwaQ?br />我在设计pȝ?Ҏ个对象图都会采用两套映射模型,
一套用于映实际的UML,当然包括引用,q套对象图主要用于根据关联对象的属性来查询对象时?很少用于更新数据,除非是聚集类.
另一套映?把对象引用映ؓLong型的属?传递到业务层或表示?需要相关的对象引用?再用q个引用来load对象.而且,对于需要load的对象可以用代理或直接多映一个简单类来处?
另外,对于大数据量的查询或表的兌层次较深(过三层),采用jdbc直接处理.
方世玉：
我们现在也正在用hibernateq行目开?
我认Z是所有相关的表都要做one ManyQmany one映射?
比如说一个用户和他的定购业务Q我们做了双向关联?
但是q个用户的话单就不能和用户做M兌了。话单表每天都有数十万条Q就是做manyone兌也非常吓人，宁可到时候用hql来查?/p>
xieccQ?br />呵呵,hsanwaQ这两套映射模型如何在一个应用中同时使用Q?/p>
dhj1Q?br />我用hibernate,是可以减开发工作量. 特别在开发中或维护过E中对表l构的改?用HIBERNATE是很方便?
做了DAO?对表的父子关pȝ的处?通过ID标识,也只是两三句E序语句.操作也很方便,而且更灵z?
生成静态ￃQ_Q?以后我做q这Lpȝ,q在XXX省信息港|站上大量?性能当然不错,同时1400人在U?真正的在U?不是那种用网|个几分钟h一ơg时的那种在线),性能也不?开发当然会有一些难?
我说的CACHE不是说用HIBERNATE的CACHE.而是自已开发的,把访问量高的信息自动攑ֈ一个表中去,q个表保证只?00讉K量最高的条记?多于100条记录的出M.
sanwaQ?br />举个例子,比如用户的权?在我们的pȝ中涉及用PUserQ、权?Acl)、组?Component)、组件类(componentDomain){几个对象的兌?
W一套映图Q反映他们的实际关系Q即对应UML模型。User和Acl的关联映ؓidbagQ不要直接映ؓset,因ؓ在我设计的关联表中存在代理主键，代理主键在第二套映射图中实际为用h限的id.
W二套映图Q只映射用户QUserSOQ和用户拥有的权?UserAclSO)Q是one to many的关pR?
后缀SO表示相关cȝ单对象映类?
q样Q当客户端需要获取某个用L所有权限时Q直接用W二套映图。返回的集合中就只包括Acl的id。如果要获取用户Ҏ个组件域的权限，则用W一套映图Q用强大的HQL查询Q再转换为第二套映射图返回到客户端?
当更新用L权限Ӟ也用W二套映图Q直接操作UserSO和UserAclSOQ传回更新?
使用cM的设计策略时Q对many to many的关联表Q都采用代理主键Q而不是联合主键，q样Q两套映图都较Ҏ存取数据。只是，多数情况下用W二套映图?
当然,我的E序架构是Swing + Session Bean + DAO + Hibernate + DB,Swing和Session Bean的通信可以用HTTP或RMI,在我的架构中,lazy loading发挥不了多大的作用，才采取这U策略。如果在lazy loading可以发挥作用的地方，对大多数对象图，是没有必要采取这U策略的?
另外Q在我的架构中，swing层有一个组件是可以Ҏ一个ID来加载这个类的属性，直接用jdbc实现的，独立于Hibernate
xiaoyuQ?br />我也说上一句吧?
虽然HB是好Q方便，但有x据库设计的一些性能原则q是要考虑的?
毕竟它只是Mapping而已?
所以也要设|烦引等东西?/p>
jxb8901Q?br />上面的proxy和cache没有M关系Q只是用于lazy loadingQ请看hibernate中文文档W?章：
java代码:
proxy (可?: 指定一个接口，在gq装载时作ؓ代理使用。你可以在这里用该c自q名字?
coolwycQ?br />Z在性能上得到^?对many-to-one不直接用关q?例如:user&ACL,取user?不取ACL,要取ACL先取user,再取ACL,毕竟应用取user的频率比取ACL?没必要在取user是硬要把ACL一起取出来.
q有其他many-to-one都和q个很类?如果many很少的话没问题,例如:?amp;宠物,通常一个h只有于{于一个宠?q种情况取h的时候把宠物一起取出对pȝ影响不大
willmacQ?br />hibernate本n的性能非常好，关键在设计本w?
和你的数据库本nQ以及你的访问量和数据库的性质
针对不同的环境一定要有不同的设计的，一套设计肯定不能适用于全部的环境
我D个典型例子来说吧
你的hibernate设计可以采用单session的方式，也可以采用多session的方式，应用环境不同Q结果也大大的不同。当用户人群，数据库记录两低的时候，多session的设计是非常有优势的Q这是Z么那么多?
反对使用threadlocal理session的主要理由把Q的?
把两U设计都攑֜q里Q你会发现多session的性效要比
threadlocal的强太多了，q且~程也异常的ҎQ这U例子，我不再D了，你在q个论坛上都可以下的到。可?
当h变多，数据库记录v量增长的时候，我们发现问题来了Q我们做的应用无限制的吃d存，应用的响应开始变慢，q是Z么呢Q不知道大家是否理解I竟什么是sessionQ其实从Ҏ上说是一张hashmap,q样大家好理解了，当不同的用户Q同时访问应用的时候，不同的h建立不同的连表，然后释放Q而当q发人群急速增长的时候，于是问题来了。那怎么办，threadlocal没有其他的办法，你要解决一个同步的问题Q我们只有一个session,你不能够同时往里读取数据，然后又写入数据的Qƈ发用戯么多Q你只可以让他们一个一个得来！Q！
哇，q样效率不是太低了，的确Q我一开始就说了Q小型系l，使用threadlocall对是低效的做法的，可是当规模上来了之后Q我们再来看Q内存不再无限制的开销Qcpu徯荷也降下来了Q唯一一点发生变化的是，用户的客L可能多等?.001U钟Q一个在服务D队列的旉Q这是设计?
讲了一个设计的例子Q我们来看多对一Q一对多Q会让我们应用的效率降低么？
h意hibernate只是帮助我们完成了mapping 的工?
原来的一对多也好或者多对一也好Q本来就存在的，之所以让你觉得效率低Q是因ؓ在得到父亲后Q还要去把每一个儿子给d来，可是注意Q你只是多执行了一条sql而已Qؓ什么会慢的呢，我想问题q是在设计之?
]]>
private static final String L = "Decompiling this copyrighted software is a violation of both your license agreement and the Digital Millenium Copyright Act of 1998 (http://www.loc.gov/copyright/legislation/dmca.pdf). Under section 1204 of the DMCA, penalties range up to a $500,000 fine or up to five years imprisonment for a first offense. Think about it; pay for a license, avoid prosecution, and feel better about yourself.";
public static void main(String[] args) {
//"csdn"为用户名?br /> String userId = "csdn";
//其中491Q?.9.1Q?400Q?.0Q?401Q?.1Q?501Q?.1.0Q，Q）内ؓ版本?br /> //9912310代表注册码过期时?099/12/31
//MyEclipse4.1 GA
//String need = userId.substring(0,1) + "YE3MP-401-00-9912310";
//MyEclipse4.0.0 GA
//String need = userId.substring(0,1) + "YE3MP-400-01-9912310";
//MyEclipse4.9.1
//String need = userId.substring(0,1) + "YE3MP-491-01-9912310";
//MyEclipse5.1.0 GA
String need = userId.substring(0,1) + "YE3MP-501-00-9912310";
String dx = need + L + userId;
int suf = decode(dx);
//System.out.println("SUF:"+suf);
String code = need + suf;
System.out.println(change(code));
}
static int decode(String s) {
int i = 0;
char ac[] = s.toCharArray();
int j = 0;
for(int k = ac.length; j < k; j++) {
i = 31 * i + ac[j];
}
return Math.abs(i);
}
static String change(String s) {
byte abyte0[] = s.getBytes();
char ac[] = new char[s.length()];
int i = 0;
for(int k = abyte0.length; i < k; i++) {
//..............................
int j = abyte0;
if(j >= 48 && j <= 57)
j = ((j - 48) + 5) % 10 + 48;
else
if(j >= 65 && j <= 90)
j = ((j - 65) + 13) % 26 + 65;
else
if(j >= 97 && j <= 122)
j = ((j - 97) + 13) % 26 + 97;
//.....................................
ac = (char)j;
}
return String.valueOf(ac);
}
}
]]>
JAVA中的代理可以在运行时创徏一个实Cl接口的新类Q这U功能只有在~译时无法确定需要实现哪个接口时才有必要使用Q对于应用程序设计h员来_遇到q种情况的机会很。然而对于系l程序设计h员来_代理带来的灵zL却十分重要。 ? Q－Q摘自《JAVA核心技术卷2?/font>
有一些初学者对反射和代理有一点害怕，觉得q是高深的技术，不敢ȝQ其实Q何东襉K没有那么复杂Q只要你L触，׃有收Pq篇文章主要讲解了反和代理、AOP斚w的知识，但是非常基本Q如果有朋友不太明白可以发表评论Q我会认真的解答的，下面我脓上两个程序的代码Q很单大家看一下?/font>
Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－
/**
*q个E序的功能是通过反射技术得C个类QSrcClassQ的两个Stringcd的成员变?br /> *然后l过判断对字W串q行处理
*q个题目的特点：通过对API的阅M解Classcȝ使用Ҏ
*1、getDeclaredFields()得到所有的成员变量
*2、FieldcM的一些方法getTypeQ）
*3、Fieldcȝ承于AccessibleObjectc，有一个setAccessibleQ）ҎQ查看API得到他的用?br /> **/
import java.lang.reflect.Field;
class SrcClass
{
private String name = "BeiJing.2008";//定义来两个Stringcd的变量，讉K修饰都是U有?br /> private String eMail = "BeiJing.2008@163.com";
private int age = 25;
public String toString()//覆盖父类的toStringҎQ打印数?br /> {
return "Name:[ " + this.name + " ] EMail: [ " + this.eMail + " ] Age: [ " + this.age + " ]";
}
}
public class TestClass
{
public static void main(String[] args)
{
SrcClass srcclass = new SrcClass();//首先实例化一个SrcClasscȝ实例Q用于给amendStringҎ传?br /> TestClass testclass = new TestClass();//再实力化一个TestClass的实?br />
System.out.println(srcclass);//打印一遍原始信?/p>
testclass.amendString(srcclass);//调用amendStringҎ
System.out.println(srcclass);//打印一遍修改后的信?/p>
}
public void amendString(Object cls)//用于修改通过代理得到srcclass的String成员变量Q进行替换处?br /> {
try
{
Field[] fidles = cls.getClass().getDeclaredFields();//得到srcclass.getClass()cM的所有成员变?br /> for(Field field : fidles)//增强for循环
{
if(field.getType().equals(java.lang.String.class))//判断q个成员变量的类型是不是Stringcd?br /> { //如果q回truep行处?br /> field.setAccessible(true);//讄q个变量不进行访问权限检查（我在SrcClass里设|的变量为privateQ?br /> String newString = (String)field.get(cls);//通过FieldcȝgetҎ得到String成员变量
field.set(cls,newString.replaceAll("BeiJing","China"));//q行替换Q再调用FieldcȝsetҎq行修改
}
}
}
catch(SecurityException e)//
{
e.printStackTrace();
}
catch (IllegalArgumentException e)
{
e.printStackTrace();
}
catch (IllegalAccessException e)
{
e.printStackTrace();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－
下面是代理了，实现代理必须?个类Q一个接?各类Q?/p>
public interface FooInterface {
public String printMassage();
}
Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q?/p>
class ImplementFoo implements FooInterface {
public String printMassage()
{
return "This is ImplementFoo ...";
}
}
Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q?/p>
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Date;
class ImplementInvocationHandler implements InvocationHandler
{
private Object foo;
public ImplementInvocationHandler(Object foo) //获得要q行cȝ实际对象
{
this.foo = foo;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable //
{
System.out.println("You want use " + proxy.getClass().getName() + "." +
method.getName() + " at " + new Date());
return method.invoke(foo);//Ҏ调用
}
}
Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q－Q?/p>
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;
/**
* InvocationHandler handler = new MyInvocationHandler(...);
Class proxyClass = Proxy.getProxyClass(
Foo.class.getClassLoader(), new Class[] { Foo.class });
Foo f = (Foo) proxyClass.
getConstructor(new Class[] { InvocationHandler.class }).
newInstance(new Object[] { handler });
*
*/
public class TestProxy {
public static void main(String[] args)
{
ImplementFoo foo = new ImplementFoo();//实例化一个实CFooInterfaceQ自己定义的Q接口的c?br /> InvocationHandler handler = new ImplementInvocationHandler(foo);
//自己~写实现InvocationHandler接口的类
//q且他实例?ImplementInvocationHandlercM有一个构造函数需要接受一个ImplementFoocȝ对象Q?因ؓ我们来
//要用ImplementFoo.printMassageҎQImplementInvocationHandlercL法invoke中的method.invoke(foo)
//需要知道他调用谁的printMassageҎQ所以我们要lImplementInvocationHandlercM递一个ImplementFoocȝ对象
Class proxyClass = Proxy.getProxyClass(FooInterface.class.getClassLoader(),FooInterface.class);
//此时我们p刉出一个代理类了，使用Proxycȝ静态方法getProxyClassQ查看API得到{案
FooInterface f;
try
{
f = (FooInterface) proxyClass.getConstructor(new Class[] { InvocationHandler.class }).newInstance(handler);
System.out.println(f.hashCode());//动态实例化Z个代理类Qƈ且调用他的hashCode、printMassageҎ
System.out.println(f.printMassage());
} catch (SecurityException ex) {
ex.printStackTrace();
} catch (IllegalArgumentException ex) {
ex.printStackTrace();
} catch (IllegalAccessException ex) {
ex.printStackTrace();
} catch (InstantiationException ex) {
ex.printStackTrace();
} catch (NoSuchMethodException ex) {
ex.printStackTrace();
} catch (InvocationTargetException ex) {
ex.printStackTrace();
}
}
}
]]>
[separator]
Java 的这一能力在实际应用中也许用得不是很多Q但是在其它的程序设计语a中根本就不存在这一Ҏ。例如，Pascal、C 或?C++ 中就没有办法在程序中获得函数定义相关的信息?br />
JavaBean ?reflection 的实际应用之一Q它能让一些工具可视化的操作Y件组件。这些工具通过 reflection 动态的载入q取?Java lg(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样列Zjava.util.Stack cȝ各方法名以及它们的限制符和返回类型?br />
q个E序使用 Class.forName 载入指定的类Q然后调?getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描q某个类中单个方法的一个类?br />
2.开始?Reflection
用于 reflection 的类Q如 MethodQ可以在 java.lang.relfect 包中扑ֈ。用这些类的时候必要遵@三个步骤Q第一步是获得你想操作的类?java.lang.Class 对象。在q行中的 Java E序中，?java.lang.Class cL描述cd接口{?br />
下面是获得一?Class 对象的方法之一Q?br />
Class c = Class.forName("java.lang.String");
q条语句得到一?String cȝcd象。还有另一U方法，如下面的语句Q?br />
Class c = int.class;
或?br />
Class c = Integer.TYPE;
它们可获得基本类型的cM息。其中后一U方法中讉K的是基本cd的封装类 (?Integer) 中预先定义好?TYPE 字段?br />
W二步是调用诸如 getDeclaredMethods 的方法，以取得该cM定义的所有方法的列表?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 />
得到cM息之后，通常下一个步骤就是解军_?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 用法。下面的代码实Cq一用法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 来获取一pd?Method 对象Q它们分别描qC定义在类中的每一个方法，包括 public Ҏ、protected Ҏ、package Ҏ?private Ҏ{。如果你在程序中使用 getMethods 来代?getDeclaredMethodsQ你q能获得l承来的各个Ҏ的信息?br />
取得?Method 对象列表之后Q要昄q些Ҏ的参数类型、异常类型和q回值类型等׃难了。这些类型是基本cdq是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.获取构造器信息
获取cL造器的用法与上述获取Ҏ的用法类|如：
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回cd?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个例子和前面那个例子非常相伹{例中用了一个新东西 ModifierQ它也是一?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 =
-----
和获取方法的情况一下，获取字段的时候也可以只取得在当前cMx了的字段信息 (getDeclaredFields)Q或者也可以取得父类中定义的字段 (getFields) ?br />
6.ҎҎ的名U来执行Ҏ
文本到这里，所丄例子无一例外都与如何获取cȝ信息有关。我们也可以?reflection 来做一些其它的事情Q比如执行一个指定了名称的方法。下面的CZ演示了这一操作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程中指定的 (例如QJavaBean 开发环境中׃做这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 之后Qarrobj 是一?10 x 15 的数l。进而取得其中的一个元素，即长度ؓ 15 的数l，q?Array.setInt 为它的第 10 个元素赋倹{?br />
注意创徏数组时的cd是动态的Q在~译时ƈ不知道其cd?br />
]]>
Java中一些关于日期、日期格式、日期的解析和日期的计算[转脓]
sunmoon | 2005q?4?1? 11:45Java中一些关于日期、日期格式、日期的解析和日期的计算
Java 语言的Calendar(日历),Date(日期), 和DateFormat(日期格式)l成了Java标准的一个基本但是非帔R要的部分. 日期是商业逻辑计算一个关键的部分. 所有的开发者都应该能够计算未来的日? 定制日期的显C格? q将文本数据解析成日期对? 我们写了两篇文章, q是W一? 我们大概的学习日期, 日期格式, 日期的解析和日期的计?
我们讨Z面的c?
1、具体类(和抽象类相对)java.util.Date
2、抽象类java.text.DateFormat 和它的一个具体子c?java.text.SimpleDateFormat
3、抽象类java.util.Calendar 和它的一个具体子c?java.util.GregorianCalendar
具体cd以被实例? 但是抽象cd不能. 你首先必d现抽象类的一个具体子c?
Date cMJava 开发包(JDK) 1.0 开始进? 当时它只包含了几个取得或者设|一个日期数据的各个部分的方? 比如说月, ? 和年. q些Ҏ现在遭到了批评ƈ且已l被转移CCalendarc里M, 我们在本文中进一步讨论它. q种改进旨在更好的处理日期数据的国际化格? p在JDK 1.1中一? Date cd际上只是一个包裹类, 它包含的是一个长整型数据, 表示的是从GMT(格林治标准旉)1970q? 1 ?1?0:00:00q一M前或者是之后l历的毫U数.
一、创Z个日期对?
让我们看一个用系l的当前日期和时间创Z个日期对象ƈq回一个长整数的简单例? q个旉通常被称为Java 虚拟?JVM)L环境的系l时?
//------------------------------------------------------
import java.util.Date;
public class DateExample1
{
public static void main(String[] args)
{
// Get the system date/time
Date date = new Date();
System.out.println(date.getTime());
}
}
//------------------------------------------------------
在星期六, 2001q??9? 下午大约?:50的样? 上面的例子在pȝ输出讑֤上显C的l果?1001803809710. 在这个例子中,值得注意的是我们使用了Date 构造函数创Z个日期对? q个构造函数没有接受Q何参? 而这个构造函数在内部使用了System.currentTimeMillis() Ҏ来从pȝ获取日期.
那么, 现在我们已经知道了如何获取从1970q??日开始经历的毫秒C. 我们如何才能以一U用h白的格式来显C个日期呢? 在这里类java.text.SimpleDateFormat 和它的抽象基c?java.text.DateFormat 派得上用场?
二、日期数据的定制格式
假如我们希望定制日期数据的格? 比方星期?9?29?2001q? 下面的例子展CZ如何完成q个工作:
//------------------------------------------------------
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateExample2
{
public static void main(String[] args)
{
SimpleDateFormat bartDateFormat =
new SimpleDateFormat("EEEE-MMMM-dd-yyyy");
Date date = new Date();
System.out.println(bartDateFormat.format(date));
}
}
//------------------------------------------------------
只要通过向SimpleDateFormat 的构造函C递格式字W串"EEE-MMMM-dd-yyyy", 我们p够指明自己想要的格式. 你应该可以看? 格式字符串中的ASCII 字符告诉格式化函C面显C日期数据的哪一个部? EEEE是星? MMMM是月, dd是日, yyyy是年. 字符的个数决定了日期是如何格式化?传?EE-MM-dd-yy"会显C?Sat-09-29-01. 请察看Sun 公司的Web 站点获取日期格式化选项的完整的指示.
三、将文本数据解析成日期对?
假设我们有一个文本字W串包含了一个格式化了的日期对象, 而我们希望解析这个字W串q从文本日期数据创徏一个日期对? 我们再ơ以格式化字W串"MM-dd-yyyy" 调用SimpleDateFormatc? 但是q一? 我们使用格式化解析而不是生成一个文本日期数? 我们的例? 昄在下? 解析文本字W串"9-29-2001"q创Z个gؓ001736000000 的日期对?
//------------------------------------------------------
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateExample3
{
public static void main(String[] args)
{
// Create a date formatter that can parse dates of
// the form MM-dd-yyyy.
SimpleDateFormat bartDateFormat =
new SimpleDateFormat("MM-dd-yyyy");
// Create a string containing a text date to be parsed.
String dateStringToParse = "9-29-2001";
try {
// Parse the text version of the date.
// We have to perform the parse method in a
// try-catch construct in case dateStringToParse
// does not contain a date in the format we are expecting.
Date date = bartDateFormat.parse(dateStringToParse);
// Now send the parsed date as a long value
// to the system output.
System.out.println(date.getTime());
}
catch (Exception ex) {
System.out.println(ex.getMessage());
}
}
}
//------------------------------------------------------
四、用标准的日期格式化过E?
既然我们已经可以生成和解析定制的日期格式? 让我们来看一看如何用内建的格式化过E? Ҏ DateFormat.getDateTimeInstance() 让我们得以用几种不同的方法获得标准的日期格式化过E? 在下面的例子? 我们获取了四个内建的日期格式化过E? 它们包括一个短? 中等? 长的, 和完整的日期格式.
//------------------------------------------------------
import java.text.DateFormat;
import java.util.Date;
public class DateExample4
{
public static void main(String[] args)
{
Date date = new Date();
DateFormat shortDateFormat =
DateFormat.getDateTimeInstance(
DateFormat.SHORT,
DateFormat.SHORT);
DateFormat mediumDateFormat =
DateFormat.getDateTimeInstance(
DateFormat.MEDIUM,
DateFormat.MEDIUM);
DateFormat longDateFormat =
DateFormat.getDateTimeInstance(
DateFormat.LONG,
DateFormat.LONG);
DateFormat fullDateFormat =
DateFormat.getDateTimeInstance(
DateFormat.FULL,
DateFormat.FULL);
System.out.println(shortDateFormat.format(date));
System.out.println(mediumDateFormat.format(date));
System.out.println(longDateFormat.format(date));
System.out.println(fullDateFormat.format(date));
}
}
//------------------------------------------------------
注意我们在对 getDateTimeInstance的每ơ调用中都传递了两个? W一个参数是日期风格, 而第二个参数是时间风? 它们都是基本数据cdint(整型). 考虑到可L? 我们使用了DateFormat cL供的帔R: SHORT, MEDIUM, LONG, ?FULL. 要知道获取时间和日期格式化过E的更多的方法和选项, LSun 公司Web 站点上的解释.
q行我们的例子程序的时? 它将向标准输备输Z面的内容:
9/29/01 8:44 PM
Sep 29, 2001 8:44:45 PM
September 29, 2001 8:44:45 PM EDT
Saturday, September 29, 2001 8:44:45 PM EDT
五、Calendar c?
我们现在已经能够格式化ƈ创徏一个日期对象了, 但是我们如何才能讄和获取日期数据的特定部分? 比如说小? ? 或者分? 我们又如何在日期的这些部分加上或者减d呢? {案是用Calendar c? 如我们前面提到的那? Calendar cM的方法替代了Date cM被hN的方?
假设你想要设|? 获取, 和操U一个日期对象的各个部分, 比方一个月的一天或者是一个星期的一? Z演示q个q程, 我们用具体的子类 java.util.GregorianCalendar. 考虑下面的例? 它计得C面的W十个星期五?3?
//------------------------------------------------------
import java.util.GregorianCalendar;
import java.util.Date;
import java.text.DateFormat;
public class DateExample5
{
public static void main(String[] args)
{
DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.FULL);
// Create our Gregorian Calendar.
GregorianCalendar cal = new GregorianCalendar();
// Set the date and time of our calendar
// to the system&s date and time
cal.setTime(new Date());
System.out.println("System Date: " +
dateFormat.format(cal.getTime()));
// Set the day of week to FRIDAY
cal.set(GregorianCalendar.DAY_OF_WEEK,
GregorianCalendar.FRIDAY);
System.out.println("After Setting Day of Week to Friday: " +
dateFormat.format(cal.getTime()));
int friday13Counter = 0;
while (friday13Counter <= 10)
{
// Go to the next Friday by adding 7 days.
cal.add(GregorianCalendar.DAY_OF_MONTH, 7);
// If the day of month is 13 we have
// another Friday the 13th.
if (cal.get(GregorianCalendar.DAY_OF_MONTH) == 13)
{
friday13Counter++;
System.out.println(dateFormat.format(cal.getTime()));
}
}
}
}
//------------------------------------------------------
在这个例子中我们作了有趣的函数调?
cal.set(GregorianCalendar.DAY_OF_WEEK,
GregorianCalendar.FRIDAY);
?
cal.add(GregorianCalendar.DAY_OF_MONTH, 7);
set Ҏ能够让我们通过单的讄星期中的哪一天这个域来将我们的时间调整ؓ星期? 注意到这里我们用了帔R DAY_OF_WEEK ?FRIDAY来增Z码的可读? add Ҏ让我们能够在日期上加上数? 润年的所有复杂的计算都由q个Ҏ自动处理.
我们q个例子的输出结果是:
System Date: Saturday, September 29, 2001
当我们将它设|成星期五以后就成了: Friday, September 28, 2001
Friday, September 13, 2002
Friday, December 13, 2002
Friday, June 13, 2003
Friday, February 13, 2004
Friday, August 13, 2004
Friday, May 13, 2005
Friday, January 13, 2006
Friday, October 13, 2006
Friday, April 13, 2007
Friday, July 13, 2007
Friday, June 13, 2008
六、时间掌握在你的手里
有了q些Date 和Calendar cȝ例子, 你应该能够?java.util.Date, java.text.SimpleDateFormat, ?java.util.GregorianCalendar 创徏许多Ҏ?
]]>
鲲鹏|?/a>
在这文章中Q我用的API是SimpleDateFormatQ它是属于java.text.SimpleDateFormatQ所以请记得importq来Q?
用法Q?/font>
q一行最重要Q它立了{换的格式Qyyyy是完整的公元q_MM是月份，dd是日期，至于HH:mm:ss׃需要我再解释了吧！
ps:Z么有的格式大写，有的格式写Q那是怕避免淆，例如MM是月份，mm是分QHH?4时Ӟ而hh?2时?
1.字符串{日期Q?
2002-10-8 15:30:22要把它{成日期，可以?/font>
2.日期转字W串
假如把今天的日期转成字符串可?/font>
q个字符串的内容便类?002-10-08 14:55:38
透过q个API我们便可以随心所Ʋ的日期{成我们想要的字符串格式，例如希望日期输出成
我们可以q么写：
String datestr = sdf.format( new Date());
datestr便会依照我们讑֮的格式输?/font>
]]>
|
早在Java 1.2推出之时QJavaq_中就引入了一个新的支持：java.lang.ThreadLocalQ给我们在编写多U程E序时提供了一U新的选择。用这个工L可以很简z地~写Z的多线E程序，虽然ThreadLocal非常有用Q但是似乎现在了解它、用它的朋友还不多? ThreadLocal是什?/p> ThreadLocal是什么呢Q其实ThreadLocalq是一个线E的本地实现版本Q它q不是一个ThreadQ而是thread local variableQ线E局部变量）。也许把它命名ؓThreadLocalVar更加合适。线E局部变量（ThreadLocalQ其实的功用非常单，是为每一个用该变量的线E都提供一个变量值的副本Q是每一个线E都可以独立地改变自q副本Q而不会和其它U程的副本冲H。从U程的角度看Q就好像每一个线E都完全拥有该变量。线E局部变量ƈ不是Java的新发明Q在其它的一些语a~译器实玎ͼ如IBM XL FORTRANQ中Q它在语a的层ơ提供了直接的支持。因为Java中没有提供在语言层次的直接支持，而是提供了一个ThreadLocal的类来提供支持，所以，在Java中编写线E局部变量的代码相对比较W拙Q这也许是线E局部变量没有在Java中得到很好的普及的一个原因吧?/p> ThreadLocal的设?/p> 首先看看ThreadLocal的接口： Object get() ; // q回当前U程的线E局部变量副?protected Object initialValue(); // q回该线E局部变量的当前U程的初始值void set(Object value); // 讄当前U程的线E局部变量副本的?/p> ThreadLocal?个方法，其中值得注意的是initialValue()Q该Ҏ是一个protected的方法，昄是ؓ了子c重写而特意实现的。该Ҏq回当前U程在该U程局部变量的初始|q个Ҏ是一个gq调用方法，在一个线E第1ơ调用get()或者set(Object)时才执行Qƈ且仅执行1ơ。ThreadLocal中的实实现直接q回一个nullQ?/p> protected Object initialValue() { return null; } ThreadLocal是如何做Cؓ每一个线E维护变量的副本的呢Q其实实现的思\很简单，在ThreadLocalcM有一个MapQ用于存储每一个线E的变量的副本。比如下面的CZ实现Q?/p> public class ThreadLocal public void set(Object newValue) public Object initialValue() 当然Q这q不是一个工业强度的实现Q但JDK中的ThreadLocal的实现M思\也类g此?/p> ThreadLocal的?/p> 如果希望U程局部变量初始化其它|那么需要自己实现ThreadLocal的子cdƈ重写该方法，通常使用一个内部匿名类对ThreadLocalq行子类化，比如下面的例子，SerialNumcMؓ每一个类分配一个序P public class SerialNum private static int nextSerialNum = 0; public static int get() SerialNumcȝ使用非常地单，因ؓget()Ҏ是static的，所以在需要获取当前线E的序号Ӟ单地调用Q?/p> int serial = SerialNum.get(); 卛_?/p> 在线E是zd的ƈ且ThreadLocal对象是可讉K的时Q该U程持有一个到该线E局部变量副本的隐含引用Q当该线E运行结束后Q该U程拥有的所以线E局部变量的副本都将失效Qƈ{待垃圾攉器收集?/p> ThreadLocal与其它同步机制的比较 ThreadLocal和其它同步机制相比有什么优势呢QThreadLocal和其它所有的同步机制都是Z解决多线E中的对同一变量的访问冲H，在普通的同步机制中，是通过对象加锁来实现多个线E对同一变量的安全访问的。这时该变量是多个线E共享的Q用这U同步机刉要很l致地分析在什么时候对变量q行dQ什么时候需要锁定某个对象，什么时候释放该对象的锁{等很多。所有这些都是因为多个线E共享了资源造成的。ThreadLocal׃另一个角度来解决多线E的q发讉KQThreadLocal会ؓ每一个线E维护一个和该线E绑定的变量的副本，从而隔M多个U程的数据，每一个线E都拥有自己的变量副本，从而也没有必要对该变量进行同步了。ThreadLocal提供了线E安全的׃n对象Q在~写多线E代码时Q可以把不安全的整个变量装qThreadLocalQ或者把该对象的特定于线E的状态封装进ThreadLocal?/p> ׃ThreadLocal中可以持有Q何类型的对象Q所以用ThreadLocal get当前U程的值是需要进行强制类型{换。但随着新的Java版本Q?.5Q将模版的引入，新的支持模版参数的ThreadLocal<T>cd从中受益。也可以减少强制cd转换Qƈ一些错误检查提前到了编译期Q将一定程度地化ThreadLocal的用?/p> ȝ 当然ThreadLocalq不能替代同步机Ӟ两者面向的问题领域不同。同步机制是Z同步多个U程对相同资源的q发讉KQ是Z多个U程之间q行通信的有效方式；而ThreadLocal是隔d个线E的数据׃nQ从Ҏ上就不在多个U程之间׃n资源Q变量）Q这样当然不需要对多个U程q行同步了。所以，如果你需要进行多个线E之间进行通信Q则使用同步机制Q如果需要隔d个线E之间的׃n冲突Q可以用ThreadLocalQ这极大地化你的程序，使程序更加易诅R简z?br /> |
]]>