public static void main(String[] args) {

  short x = 100;
  long b = 2;
  int a = 2;
  double y=1.1;
  float z=(float) 1.2;
  double c=1.1;
  float d=(float) 1.2;
  
  a=x+a;
  x+=1.1;
  b=b+a;
  y=y-1;
  z=z-1;
  c=c+1;
  d=d+1;
  
  System.out.println(a);
  System.out.println(x);
  System.out.println(b);
  System.out.println(z);
  System.out.println(y);
  System.out.println(c);
  System.out.println(d);

  c=c+d;
  System.out.println(c);
  c=c-d;
  System.out.println(c);
  d=(float) (d-1.1);
  System.out.println(d);
 }

运行结果：

102
101
104
0.20000005
0.10000000000000009
2.1
2.2
4.3000000476837155
2.0999999999999996
1.1

测试说明：

不同类型数据做计算时按照计算中最大范围数据类型返回，例如：a=x+a;(如果负值对象是较小范围的类型就需要强转类型，否则会报错)
double类型做加时运算精度准确，做减运算时有精度偏差，且和float类型相互作加减操作都会出现精度缺失；
+=符号做运算不牵扯类型转换问题，按照负值对象的类型返回。

在读完robbin的这两个精华贴的时候，感觉清晰了很多，确实好文章。
http://www.javaeye.com/topic/2712
http://www.javaeye.com/topic/1604?page=1
还有这个精华贴
http://www.javaeye.com/topic/7484
也很不错。

里面总结的很好了，我结合以上三个帖子、自己的试验（版本hibernate-3.0.5）和Hibernate文档也总结了一点，加深理解。希望对刚开始学Hibernate的同学有所帮助。

一、saveorUpdate与unsaved-value
到底是sava还是update
Hibernate需要判断被操作的对象究竟是一个已经持久化过的持久对象还是临时对象。
1）．主键Hibernate的id generator产生
<id name="id" type="java.lang.Long">
<column name="ID" precision="22" scale="0" />
<generator class="increment" />
</id>

Project project = new Project();
project.setId(XXX);
this.projectDao.saveOrUpdate(project);

1、默认unsaved-value="null"
主键是对象类型，hebernate判断project的主键是否位null，来判断project是否已被持久化
是的话，对project对象发送save(project)，
若自己设置了主键则直接生成update的sql，发送update(project)，即便数据库里没有那条记录。
主键是基本类型如int/long/double/
自己设置unsaved-null="0"。
所以这样的话save和update操作肯定不会报错。

2、unsaved-value="none"，
由于不论主键属性为任何值，都不可能为none，因此Hibernate总是对project对象发送update(project)

3、unsaved-value="any"
由于不论主键属性为任何值，都肯定为any，因此Hibernate总是对project对象发送save(project)，hibernate生成主键。

Hibernate文档中写到
saveOrUpdate()完成了如下工作：
如果对象已经在这个session中持久化过了，什么都不用做
如果对象没有标识值，调用save()来保存它
如果对象的标识值与unsaved-value中的条件匹配，调用save()来保存它
如果对象使用了版本(version或timestamp),那么除非设置unsaved-value="undefined",版本检查会发生在标识符检查之前.
如果这个session中有另外一个对象具有同样的标识符，抛出一个异常

2）．主键由自己来赋值
<id name="id" type="java.lang.Long">
<column name="ID" precision="22" scale="0" />
<generator class="assigned" />
</id>

Project project = new Project();
project.setId(XXX);
this.projectDao.saveOrUpdate(project);

1、默认unsaved-value="null"
这时有所不同，hibernate会根据主键产生一个select，来判断此对象是否已被持久化
已被持久化则update，未被持久化则save。
2、unsaved-value="none"，update对象，同上

3、unsaved-value="any" ，save对象，
如果自己自己设置的ID在数据库中已存在，则报错。

二、save与update操作
显式的使用session.save()或者session.update()操作一个对象的时候，实际上是用不到unsaved-value的
在同一Session，save没什么可说得
update对象时, 最直接的更改一个对象的方法就是load()它，保持Session打开，然后直接修改即可:
Session s =…
Project p = (Project) sess.load(Project.class, id) );
p.setName(“test”);
s.flush();
不用调用s.update(p);hibernate能察觉到它的变化，会自动更新。当然显示调用的话也不会错

Hibernate文档中写到
update()方法在下列情形下使用：
程序在前面的session中装载了对象
对象被传递到UI（界面）层
对该对象进行了一些修改
对象被传递回业务层
应用程序在第二个session中调用update()保存修改

三、delete操作
删除时直接自己构造一个project即可删除
this.projectDao.delete(preojct);

以前删除我是这样写的
public void deleteProject(String id) {
Project project = (Project) this.projectDao.get(Project.class, id);
if (project != null) {
this.projectDao.delete(project);
}
即这样也是可以的
Project project = new Project();
project.setId(id);
this.projectDao.delete(project).

如果有级联关系，需要把级联的子类也构造出来add进去，同样可以删除。

　　此外，我对于static，public，private，Exception，try{ }catch {}finally{}等等一开始都不是很懂，都是把参考书上面的例子运行成功，然后就开始破坏它，不断的根据自己心里面的疑问来重新改写程序，看看能不能运行，运行出来是个什么样子，是否可以得到预期的结果。这样虽然比较费时间，不过一个例子程序这样反复破坏几次之后。我就对这个相关的知识彻底学通了。有时候甚至故意写一些错误的代码来运行，看看能否得到预期的运行错误。这样对于编程的掌握是及其深刻的。其中特别值得一提的是JDK有一个非常棒的调试功能-verbose。

　　java –verbose

　　javac –verbose 以及其它很多JDK工具都有这个选项

　　-verbose 可以显示在命令执行的过程中，JVM都依次加载哪里Class，通过这些宝贵的调试信息，可以帮助我们分析出JVM在执行的过程中都干了些什么。另外，自己在学习过程中，写的很多的这种破坏例程，应该有意识的分门别类的保存下来，在工作中积累的典型例程也应该定期整理，日积月累，自己就有了一个代码库了。遇到类似的问题，到代码库里面 Copy & Paste ，Search & Replace，就好了，极大提高了开发速度。最理想的情况是把一些通用的例程自己再抽象一层，形成一个通用的类库，封装好。那么可复用性就更强了。所以我觉得其实不是特别需要例程的，自己写的破坏例程就是最好的例子，如果你实在对自己写的代码不放心的话，我强烈推荐你看看JDK基础类库的Java源代码。在JDK安装目录下面会有一个src.zip，解开来就可以完整的看到整个JDK基础类库，也就是rt.jar的Java源代码，你可以参考一下Sun是怎么写Java程序的，规范是什么样子的。我自己在学习Java的类库的时候，当有些地方理解的不是很清楚的时候，或者想更加清晰的理解运作的细节的时候，往往会打开相应的类的源代码，通过看源代码，所有的问题都会一扫而空。

　　如今的网络用户都被宠坏了。他们一旦在谷歌公司(Google)或Flickr网站体验过快捷的响应和良好的互动功能后，传统的点击-等待式的Web界面就再也无法满足他们的需求了。这些功能正是通过Ajax来实现的。由于Ajax所带来的商业价值日益凸现，微软公司(Microsoft)和开源的开发者工作平台Eclipse的支持者们，最近正积极开发一些适合Ajax的平台，以便用户能够方便地利用这种工具来创建互动式的Web应用。

　　Ajax等网络开发工具和技术与传统的服务器端软件不同。服务器端软件普遍具有成熟的技术标准，而Ajax等网络开发技术尚还处在不断的变化中。Ajax是新兴的网络开发技术的象征。它将JavaScript和XML技术结合在一起，用户每次调用新数据时，无需反复向服务器发出请求，而是在浏览器的缓存区预先获取下次可能用到的数据，界面的响应速度因此得到了显著提升。Google公司的地图服务(Google Maps)就是Ajax应用最典型的例子之一。

　　不久前，Eclipse开源项目的领导厂商，包括国际商业机器公司(IBM)、英特尔公司(Intel)、红帽公司(Red Hat)和思爱普软件系统公司(SAP)等宣布，将把Eclipse从开发者工作平台扩展成能与微软公司在企业市场展开竞争的新平台。在日前召开的EclipseCon大会上，Eclipse基金会执行总监迈克·米林科维奇(Mike Milinkovich)表示：“今后3年，微软公司可能会不断说服一些企业放弃Win32 API，并转向(Windows)Vista。”然而，米林科维奇却建议企业最好采用Eclipse的富客户平台。因为开发者采用这套组件，就可以在企业桌面应用程序创建交互性更好的界面，一次开发完毕后，在视窗系统(Windows)、Linux或者苹果系统上都能够运行。

　　Eclipse行动

　　Eclipse项目组正在设法为用户提供除微软公司产品之外的更多选择。不久前，该项目组推出了一个开源项目Rich Ajax Platform(下称“RAP”)，吸引开发人员使用Eclipse来提供界面组件，包括视窗风格的菜单、拖动条以及支持拖曳功能的弹出窗口(Drag-and-Drop Window Expanders)等，目的是使Web应用在浏览器中更具有交互性。

　　不久前，IBM公司与Google公司、Laszlo系统公司、Mozilla公司、网威公司(Novell)、甲骨文公司(Oracle)、红帽公司和雅虎公司(Yahoo)等多家企业，共同合作创建了一项开源项目Ajax Toolkit Framework，旨在建立一种基于Eclipse的软件系统，以降低在Eclipse平台内使用Ajax工具的难度。在此之前，使用Ajax开发程序并不那么容易。Google公司是在开发Google Maps的过程中发现这一点的。它发现地图上标记下的阴影或者两点之间的驾驶路线，都会因为浏览器的使用差异而产生不同的显示效果。不过，Google Maps产品经理布莱特·泰勒(Bret Taylor)也表示：“Google公司在创建工具包方面投入了大量精力，因此大家对这些细节方面大可放心。”Eclipse项目在像Google公司这样的大公司帮助下，正在采用Google公司的方法，以便使所有企业都能更方便地使用Ajax技术。

　　而与此同时，微软公司也并没有在原地踏步。在日前举行的微软网络技术大会上，公司主席比尔·盖茨(Bill Gates)发表了一篇主题演讲。盖茨在讲话中承认，新一轮的Web应用热潮即将到来。一些网站变得像传统软件的组件一样，可以被API调用，以及像子程序一样运行。“现在，富有创新想法的时代已经到来。”盖茨表示，“这是软件的新时代。”

　　日前，微软公司发布了一个自有Ajax开发工具—Atlas的升级测试版。它可以在应用程序的客户端创建标准的JavaScript。微软公司也开发了基于JavaScript的服务器端扩展程序，来优化Ajax应用在视窗电脑上的执行。这样，用Atlas编写的软件，可以与Windows Vista的各种元素产生互动。而且，采用Atlas编写的Web应用特别能够与Vista的其他程序产生互动，比如日历、即时通讯联系人、照相簿和媒体播放软件等。微软公司Web工具产品经理布赖恩·戈德法伯(Brian Goldfarb)还透露说：“公司正在考虑其他更丰富的应用场景，从而可以更好地与IE浏览器和视窗系统进行配合。"

　　不过，微软公司在发布代号为“Orcas”的下一版本Visual Studio 时，才会正式推出Atlas工具。因此，距离Atlas的面世还要等上好几年的时间。而与此同时，Eclipse却在利用Ajax工具包而快速发展。

　　微软公司的优势就在于，能够把Atlas工具与公司的视窗系统、SQL Server数据库以及其他软件整合在一起。不过，IBM公司也以开源代码的形式，捐献出了Eclipse的核心工作平台技术，因为它也希望Java工具拥有与微软公司类似的集成度。

　　格雷格·斯坦因(Greg Stein)是Google公司的工程经理、Apache软件基金会主席以及Apache Web服务器等项目的赞助人。斯坦因认为：“Eclipse是一种集成的开发环境，因此将会在一定程度上简化Ajax应用的开发难度。”而德国小型软件公司Innoopract公司的管理总监约亨·克劳泽(Jochen Krause)也预测说，这个平台“将会把Eclipse的应用扩展到一个不同的领域，即互动Web应用领域。”RAP项目就是由这家公司提出的。

　　简单为上

　　Eclipse项目将会给企业带来一定的帮助。有了Eclipse工具包，他们就无需掌握专门的JavaScript知识，可以在Eclipse的框架下工作。而大多数C语言、C++、Cobol、Java和PHP程序员，对于Eclipse都不陌生。加拿大研究委员会(National Research Council Canada)计算机系统官员丹尼·达穆尔(Danny D’amours)表示：“我们的一些应用程序，响应时间会变得更快捷，而且还能够有更好的在线互动。”在Eclipse的Ajax framework项目中，“Ajax将会整合成为Eclipse开发环境的一部分。”达穆尔补充说道。

　　达穆尔会考虑使用微软公司的Atlas吗?看上去，他似乎对此不感兴趣。的确，微软和非微软阵营的对抗似乎依然处于紧张状态。尽管企业往往会同时采用Visual Studio与Eclipsebased的开发工具，很可能也包括两者的Ajax和Web应用技术。

　　企业通过使用Ajax，可以强化网站的功能，提高用户体验。他们可以滚动屏幕浏览大量的信息，或者方便地把物品拖入在线购物车，或者在线配置产品而无需不断地刷新页面。其实，不仅仅是Google这样的公司在使用Ajax，Lands’End网站和沃尔沃公司(Volvo)等也在使用Ajax技术让潜在的客户设计他们的产品或汽车，而且Sabre控股公司(Sabre Holdings)也采用了Ajax技术来减少其航空公司客户使用的飞行计划软件的响应时间。

　　

class c = Class.forName(“Example”); 　　factory = (ExampleInterface)c.newInstance();

      　　其中ExampleInterface是Example的接口，可以写成如下形式：

　　

String className = "Example"; 　　class c = Class.forName(className); 　　factory = (ExampleInterface)c.newInstance();

      　　进一步可以写成如下形式：

　　

String className = readfromXMlConfig;//从xml 配置文件中获得字符串 　　class c = Class.forName(className); 　　factory = (ExampleInterface)c.newInstance();

      　　上面代码已经不存在Example的类名称，它的优点是，无论Example类怎么变化，上述代码不变，甚至可以更换Example的兄弟类Example2 , Example3 , Example4……，只要他们继承ExampleInterface就可以。

　　从JVM的角度看，我们使用关键字new创建一个类的时候，这个类可以没有被加载。但是使用newInstance()方法的时候，就必须保证：1、这个类已经加载;2、这个类已经连接了。而完成上面两个步骤的正是Class的静态方法forName()所完成的，这个静态方法调用了启动类加载器，即加载java API的那个加载器。

　　现在可以看出，newInstance()实际上是把new这个方式分解为两步，即首先调用Class加载方法加载某个类，然后实例化。 这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了一种降耦的手段。

　　最后用最简单的描述来区分new关键字和newInstance()方法的区别：

　　newInstance: 弱类型。低效率。只能调用无参构造。

　　new: 强类型。相对高效。能调用任何public构造。

--ObjectOutputStream

ObjectInputStream 类恢复以前使用 ObjectOutputStream 类序列化后的基本类型数据和对象。

ObjectOutputStream 和 ObjectInputStream 分别利用 FileOutputStream 和 FileInputStream 能支持应用程序实现对象图象的稳定存储。

ObjectInputStream 可用于恢复以前序列化过的对象。另外其它一些情况也使用此类，诸如使用一个 Socket 在主机间传递对象时，

或在远程通讯系统中为实现参数和参变量的通讯而进行对象传递时。

ObjectInputStream 保证从流中创建的图象中的所有对象的类型与 Java 虚拟机中出现的类匹配。使用标准机制按需装载相应类。

只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流中读取。使用 readObject 方法从该流中

读取一个对象。 Java 的安全造型应该用于获取期望类型。在 Java 中, 串和数组都是对象且可当作是序列化过程中的对象。

读取时，它们需要转换为所需类型。

另外基类型也可使用 DataInput 中的正确方法从该流中读取。

对象的缺省逆序列化机制将每个域的内容恢复为它被写入时的值和类型。逆序列化过程中忽略申明为暂时的或静态的域。

对其它对象的引用促使那些对象必须从流中读取。使用引用共享机制正确地恢复对象的图象。逆序列化时总是分配新对象，

防止重写已存在的对象。

读取一个对象同运行一个新对象的构造子类似。为该对象分配的内存初始化为空(NULL)。为非序列化类调用无参构造子，

然后将序列化类的域从该流中恢复，恢复从最接近 java.lang.object 的序列化对象开始，到指定对象结束。

例如读取在示例中写入 ObjectOutputStream 中的流：

 FileInputStream istream = new FileInputStream("t.tmp");
 ObjectInputStream p = new ObjectInputStream(istream);
 int i = p.readInt();
 String today = (String)p.readObject();
 Date date = (Date)p.readObject();
 istream.close();
 
类通过实现 java.io.Serializable 或 java.io.Externalizable 接口来控制它们的序列化。

实现序列化接口可以使对象能保存和恢复它的完整状态，可以使类在写入流和从流中读取的期间内进行改进。

它自动地遍历对象间的引用，保存和恢复完整图象。在序列化和逆序列化处理过程中需要特定句柄的可序列化类，

必须实现如下这两个方法：

 private void writeObject(java.io.ObjectOutputStream stream)
     throws IOException;
 private void readObject(java.io.ObjectInputStream stream)
     throws IOException, ClassNotFoundException;
 
利用 writeObjectmethod 方法将一个特殊类的对象的状态写入某流后，相应的 readObject 方法将负责读取和恢复这些数据。

此方法不必关心状态是属于它的父类还是子类。 从 ObjectInputStream 读取数据恢复单个域的状态，并将之赋给该对象的恰当域。

使用 DataInput 方法读取基本数据类型。

序列化操作对没有实现 java.io.Serializable 接口的对象，不读取或分配它的域值。非序列化对象的子类可以是序列化的。

在这种情况下，非序列化类必须有一个无参构造子，使它的域能使用此构造子完成初始化。 在此情况下，

子类负责保存和恢复非序列化类的状态。通常情况父类的域是可存储的(公有的、包或保护的)，

或存在用于恢复它的状态的可使用的获取或设置方法。

ObjectInputStream 能获取逆序列化一个对象期间出现的任一异常，一旦出现异常，则放弃读过程。

实现外部接口可以使对象完全控制此对象序列化形式的内容和格式。

调用外部接口的方法：writeExternal 和 readExternal 保存和恢复对象状态。当一个类实现了这些方法时，

它们就能使用 ObjectOutput 和 ObjectInput 方法的所有方法写入或读取它们自己的状态。对象负责管理它出现的相应版本。

ObjectOutputStream

public class ObjectOutputStream
extends OutputStream
implements ObjectOutput, ObjectStreamConstants
类 ObjectOutputStream 将 Java 对象中的基本数据类型和图元写入到一个 OutputStream 对象中。可使用 ObjectInputStream 读取这些对象。

另外使用此流对应的文件能存储这些对象。如果该流是一个网络通讯流，则在另一台主机或另一个处理机上可重建这些对象。

只有支持 java.io.Serializable 接口的对象才能被写入该流。对每个可序列化的对象进行编码，包括相应类的名称和标记，

对象的属性和数组值，以及初始化对象时引用的任何其它对象等。

使用 writeObject 将一个对象写入该流。任一对象，包括串和数组，均采用 writeObject 方法被写入。

也能将多个对象或基类型对象写入此流。反过来，必须以这些对象被写入的相同类型和相同顺序，

从相应的 ObjectInputstream 流中读回这些对象。

基类型也可使用 DataOutput 中的正确方法写入此流。串对象也可使用 writeUTF 方法写入。

一个对象的缺省序列化机制将写入对象的类，类标记和所有的非暂时的和非静态的属性值。

其它对象(除暂时的或静态的属性)的引用也将促使以上这些对象被写入。 使用共享机制，对单一对象的多次引用进行编码，

以至对象的图元能被存储为与它原来写入时有相同的形状。

例如写入一个对象，此对象能从 ObjectInputStream 中读出：

 FileOutputStream ostream = new FileOutputStream("t.tmp");
 ObjectOutputStream p = new ObjectOutputStream(ostream);
 p.writeInt(12345);
 p.writeObject("Today");
 p.writeObject(new Date());
 p.flush();
 ostream.close();
 
在序列化处理过程中需要特定句柄的类，必须使用如下这些恰当的标记实现特定的方法：

 private void readObject(java.io.ObjectInputStream stream)
     throws IOException, ClassNotFoundException;
 private void writeObject(java.io.ObjectOutputStream stream)
     throws IOException
 
writeObject 方法负责写特定类的对象的状态，以使相应的 readObject 方法能存储它。

此方法不必关心写入对象的父类或子类的状态。使用 writeObject 方法或基本类型支持的 DataOutput

方法将每个域的状态保存到 ObjectOutputStream 中。

序列化操作不能输出没有实现 java.io.Serializable 接口的任一对象的域。非序列化对象的子类可以是序列化的。

在这种情况下，非序列化类必须有一个无参构造子，使它的域能被初始化。 在此情况下，子类负责保存和恢复非序列化类的状态。

通常情况父类的域是可存储的(公有的、包或保护的)，或存在用于恢复它的状态的可使用的获取或设置方法。

实现抛出 NotSerializableException 异常的 writeObject 和 readObject 方法能阻止一个对象的序列化。

ObjectOutputStream 将获取这个异常，并放弃这个序列化过程。实现外部接口可以使对象完全控制此对象序列化形式的内容和格式。

调用外部接口的方法：writeExternal 和 readExternal 保存和恢复对象状态。当一个类实现了这些方法时，

它们就能使用 ObjectOutput 和 ObjectInput 方法的所有方法写入或读取它们自己的状态。对象负责管理它出现的相应版本。

import java.io.*;
import java.util.*;

public class Logon implements Serializable {

       private Date date = new Date();
       private String username;
       private transient String password;

       Logon(String name, String pwd) {
              username = name;
              password = pwd;
       }

       public String toString() {
              String pwd = (password == null) ? "(n/a)" : password;
              return "logon info: \n " + "username: " + username + "\n date: " + date + "\n password: " + pwd;
       }

       public static void main(String[] args) throws IOException, ClassNotFoundException {
              Logon a = new Logon("Morgan", "morgan83");
              System.out.println( "logon a = " + a);
              ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Logon.out"));
              o.writeObject(a);
              o.close();

              int seconds = 5;
              long t = System.currentTimeMillis() + seconds * 1000;
              while(System.currentTimeMillis() < t) ;

              ObjectInputStream in = new ObjectInputStream( new FileInputStream("Logon.out"));
              System.out.println( "Recovering object at " + new Date());
              a = (Logon)in.readObject();
              System.out.println("logon a = " + a);
       }
}
 

类Logon是一个记录登录信息的类，包括用户名和密码。首先它实现了接口Serializable，这就标志着它可以被序列化。

之后再main方法里ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Logon.out"));

新建一个对象输出流包装一个文件流，表示对象序列化的目的地是文件Logon.out。然后用方法writeObject开始写入。

想要还原的时候也很简单ObjectInputStream in = new ObjectInputStream( new FileInputStream("Logon.out"));

新建一个对象输入流以文件流Logon.out为参数，之后调用readObject方法就可以了。