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类型相互作加减操作都会出现精度缺失；
+=符号做运算不牵扯类型转换问题，按照负值对象的类型返回。

　　此外，我对于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的类库的时候，当有些地方理解的不是很清楚的时候，或者想更加清晰的理解运作的细节的时候，往往会打开相应的类的源代码，通过看源代码，所有的问题都会一扫而空。

　　

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方法就可以了。

二.在java.util这个包里面提供了一个Random的类，我们可以新建一个Random的对象来产生随机数，他可以产生随机整数、随机float、随机double，随机long，这个也是我们在j2me的程序里经常用的一个取随机数的方法。

三.在我们的System类中有一个currentTimeMillis()方法，这个方法返回一个从1970年1月1号0点0分0秒到目前的一个毫秒数，返回类型是long，我们可以拿他作为一个随机数，我们可以拿他对一些数取模，就可以把他限制在一个范围之内啦

其实在Random的默认构造方法里也是使用上面第三种方法进行随机数的产生的

对于方法二中的Random类有以下说明：

java.util.Random类有两种方式构建方式：带种子和不带种子

不带种子：

此种方式将会返回随机的数字，每次运行结果不一样

public class RandomTest {

public static void main(String[] args) {

java.util.Random r=new java.util.Random();

for(int i=0;i<10;i++){

System.out.println(r.nextInt());

}

}

带种子：

此种方式，无论程序运行多少次，返回结果都是一样的

public static void main(String[] args) {

java.util.Random r=new java.util.Random(10);

for(int i=0;i<10;i++){

System.out.println(r.nextInt());

}

}

两种方式的差别在于

(1) 首先请打开Java Doc，我们会看到Random类的说明：

此类的实例用于生成伪随机数流，此类使用 48 位的种子，该种子可以使用线性同余公式对其进行修改（请参阅 Donald Knuth 的《The Art of Computer Programming, Volume 2》，第 3.2.1 节）。

如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。为了保证实现这种特性，我们为类Random指定了特定的算法。为了 Java 代码的完全可移植性，Java 实现必须让类 Random 使用此处所示的所有算法。但是允许 Random 类的子类使用其他算法，只要其符合所有方法的常规协定即可。

Java Doc对Random类已经解释得非常明白，我们的测试也验证了这一点。

(2) 如果没有提供种子数，Random实例的种子数将是当前时间的毫秒数，可以通过System.currentTimeMillis()来获得当前时间的毫秒数。打开JDK的源代码，我们可以非常明确地看到这一点。

/**
* Creates a new random number generator. Its seed is initialized to
* a value based on the current time:
* Random() { this(System.currentTimeMillis()); }java.lang.System#currentTimeMillis()
*/
public Random() { this(System.currentTimeMillis()); }

另外：

random对象的nextInt(),nextInt(int n)方法的说明：

int nextInt()
返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。

int nextInt(int n)
返回一个伪随机数，它是从此随机数生成器的序列中取出的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。

源引自：http://okone96.itpub.net/post/9033/231699