2，可以让i!
=i吗？
当你看到这个命题的时候一定会以为我疯了，或者Java语言疯了。
这看起来是绝对不可能的，一个数怎么可能不等于它自己呢？
或许就真的是Java语言疯了，不信看下面的代码输出什么？
doublei=0.0/0.0;
if（i==i）{
System.out.println（"Yesi==i"）;
}else{
System.out.println（"Noi!
=i"）;
}
上面的代码输出"Noi!
=i"，为什么会这样呢？
关键在0.0/0.0这个值，在IEEE754浮点算术规则里保留了一个特殊的值用来表示一个不是数字的数量。
这个值就是NaN（"NotaNumber"的缩写），对于所有没有良好定义的浮点计算都将得到这个值，比如：
0.0/0.0；其实我们还可以直接使用Double.NaN来得到这个值。
在IEEE754规范里面规定NaN不等于任何值，包括它自己。
所以就有了i！
=i的代码。
3，怎样的equals才安全？
我们都知道在Java规范里定义了equals方法覆盖的5大原则：
reflexive（反身性），symmetric（对称性），transitive（传递性），consistent（一致性），non-null（非空性）。
那么考察下面的代码：
publicclassStudent{
privateStringname;
privateintage;
publicStudent（Stringname,intage）{
this.name=name;
this.age=age;
}
publicbooleanequals（Objectobj）{
if（objinstanceofStudent）{
Students=（Student）obj;
if（s.name.equals（this.name）&&s.age==this.age）{
returntrue;
}
}
returnsuper.equals（obj）;
}
}
你认为上面的代码equals方法的覆盖安全吗？
表面看起来好像没什么问题，这样写也确实满足了以上的五大原则。
但其实这样的覆盖并不很安全，假如Student类还有一个子类CollegeStudent,如果我拿一个Student对象和一个CollegeStudent对象equals,只要这两个对象有相同的name和age，它们就会被认为相等，但实际上它们是两个不同类型的对象啊。
问题就出在instanceof这个运算符上，因为这个运算符是向下兼容的，也就是说一个CollegeStudent对象也被认为是一个Student的实例。
怎样去解决这个问题呢？
那就只有不用instanceof运算符，而使用对象的getClass（）方法来判断两个对象是否属于同一种类型，例如，将上面的equals（）方法修改为：
publicbooleanequals（Objectobj）{
if（obj.getClass（）==Student.class）{
Students=（Student）obj;
if（s.name.equals（this.name）&&s.age==this.age）{
returntrue;
}
}
returnsuper.equals（obj）;
}
这样才能保证obj对象一定是Student的实例，而不会是Student的任何子类的实例。
4，浅复制与深复制
1）浅复制与深复制概念
⑴浅复制（浅克隆）
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。
换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
⑵深复制（深克隆）
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。
那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。
换言之，深复制把要复制的对象所引用的对象都复制了一遍。
2）Java的clone（）方法
⑴clone方法将对象复制了一份并返回给调用者。
一般而言，clone（）方法满足：
①对任何的对象x，都有x.clone（）!
=x//克隆对象与原对象不是同一个对象
②对任何的对象x，都有x.clone（）.getClass（）==x.getClass（）//克隆对象与原对象的类型一样
③如果对象x的equals（）方法定义恰当，那么x.clone（）.equals（x）应该成立。
⑵Java中对象的克隆
①为了获取对象的一份拷贝，我们可以利用Object类的clone（）方法。
②在派生类中覆盖基类的clone（）方法，并声明为public。
③在派生类的clone（）方法中，调用super.clone（）。
④在派生类中实现Cloneable接口。
请看如下代码：
classStudentimplementsCloneable{
Stringname;
intage;
Student（Stringname,intage）{
this.name=name;
this.age=age;
}
publicObjectclone（）{
Objectobj=null;
try{
obj=（Student）super.clone（）;
//Object中的clone（）识别出你要复制的是哪一个对象。
}
catch（CloneNotSupportedExceptione）{
e.printStackTrace（）;
}
returnobj;
}
}
publicstaticvoidmain（String[]args）{
Students1=newStudent（"zhangsan",18）;
Students2=（Student）s1.clone（）;
s2.name="lisi";
s2.age=20;
System.out.println（"name="+s1.name+","+"age="+s1.age）;//修改学生2
//后，不影响学生1的值。
}
说明：
①为什么我们在派生类中覆盖Object的clone（）方法时，一定要调用super.clone（）呢？
在运行时刻，Object中的clone（）识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。
②继承自java.lang.Object类的clone（）方法是浅复制。
以下代码可以证明之。
classTeacher{
Stringname;
intage;
Teacher（Stringname,intage）{
this.name=name;
this.age=age;
}
}
classStudentimplementsCloneable{
Stringname;
intage;
Teachert;//学生1和学生2的引用值都是一样的。
Student（Stringname,intage,Teachert）{
this.name=name;
this.age=age;
this.t=t;
}
publicObjectclone（）{
Studentstu=null;
try{
stu=（Student）super.clone（）;
}catch（CloneNotSupportedExceptione）{
e.printStackTrace（）;
}
stu.t=（Teacher）t.clone（）;
returnstu;
}
publicstaticvoidmain（String[]args）{
Teachert=newTeacher（"tangliang",30）;
Students1=newStudent（"zhangsan",18,t）;
Students2=（Student）s1.clone（）;
s2.t.name="tony";
s2.t.age=40;
System.out.println（"name="+s1.t.name+","+"age="+s1.t.age）;
//学生1的老师成为tony,age为40。
}
}
那应该如何实现深层次的克隆，即修改s2的老师不会影响s1的老师？
代码改进如下。
classTeacherimplementsCloneable{
Stringname;
intage;
Teacher（Stringname,intage）{
this.name=name;
this.age=age;
}
publicObjectclone（）{
Objectobj=null;
try{
obj=super.clone（）;
}catch（CloneNotSupportedExceptione）{
e.printStackTrace（）;
}
returnobj;
}
}
classStudentimplementsCloneable{
Stringname;
intage;
Teachert;
Student（Stringname,intage,Teachert）{
this.name=name;
this.age=age;
this.t=t;
}
publicObjectclone（）{
Studentstu=null;
try{
stu=（Student）super.clone（）;
}catch（CloneNotSupportedExceptione）{
e.printStackTrace（）;
}
stu.t=（Teacher）t.clone（）;
returnstu;
}
}
publicstaticvoidmain（String[]args）{
Teachert=newTeacher（"tangliang",30）;
Students1=newStudent（"zhangsan",18,t）;
Students2=（Student）s1.clone（）;
s2.t.name="tony";
s2.t.age=40;
System.out.println（"name="+s1.t.name+","+"age="+s1.t.age）;
//学生1的老师不改变。
}
3）利用串行化来做深复制
把对象写到流里的过程是串行化（Serilization）过程，Java程序员又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做“解冻”或者“回鲜（depicking）”过程。
应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。
在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。
如下为深复制源代码。
publicObjectdeepClone（）{
//将对象写到流里
ByteArrayOutoutStreambo=newByteArrayOutputStream（）;
ObjectOutputStreamoo=newObjectOutputStream（bo）;
oo.writeObject（this）;
//从流里读出来
ByteArrayInputStreambi=newByteArrayInputStream（bo.toByteArray（））;
ObjectInputStreamoi=newObjectInputStream（bi）;
return（oi.readObject（））;
}
这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。
上例代码改进如下。
classTeacherimplementsSerializable{
Stringname;
intage;
Teacher（Stringname,intage）{
this.name=name;
this.age=age;
}
}
classStudentimplementsSerializable
{
Stringname;//常量对象。
intage;
Teachert;//学生1和学生2的引用值都是一样的。
Student（Stringname,intage,Teachert）{
this.name=name;
this.age=age;
this.p=p;
}
publicObjectdeepClone（）throwsIOException,
OptionalDataException,ClassNotFoundException
{
//将对象写到流里
ByteArrayOutoutStreambo=newByteArrayOutputStream（）;
ObjectOutputStreamoo=newObjectOutputStream（bo）;
oo.writeObject（this）;
//从流里读出来
ByteArrayInputStreambi=newByteArrayInputStream（bo.toByteArray（））;
ObjectInputStreamoi=newObjectInputStream（bi）;
return（oi.readObject（））;
}
}
publicstaticvoidmain（String[]args）{
Teachert=newTeacher（"tangliang",30）;
Students1=newStudent（"zhangsan",18,t）;
Students2=（Student）s1.deepClone（）;
s2.t.name="tony";
s2.t.age=40;
System.out.println（"name="+s1.t.name+","+"age="+s1.t.age）;
//学生1的老师不改变。
}
5，String类和对象池我们知道得到String对象有两种办法：
Stringstr1="hello";Stringstr2=newString（"hello"）;这两种创建String对象的方法有什么差异吗？
当然有差异，差异就在于第一种方法在对象池中拿对象，第二种方法直接生成新的对象。
在JDK5.0里面，Java虚拟机在启动的时候会实例化9个对象池，这9个对象池分别用来存储8种基本类型的包装类对象和String对象。
当我们在程序中直接用双引号括起来一个字符串时，JVM就到String的对象池里面去找看是否有一个值相同的对象，如果有，就拿现成的对象，如果没有就在对象池里面创建一个对象，并返回。
所以我们发现下面的代码输出true：
Stringstr1="hello";Stringstr2="hello";System.out.println（str1==str2）;这说明str1和str2指向同一个对象，因为它们都是在对象池中拿到的，而下面的代码输出为false:
Stringstr3="hello"Stringstr4=newString（"hello"）;System.out.println（str3==str4）;因为在任何情况下，只要你去new一个String对象那都是创建了新的对象。
与此类似的，在JDK5.0里面8种基本类型的包装类也有这样的差异：
Integeri1=5;//在对象池中拿Integeri2=5;//所以i1==i2Integeri3=newInteger（5）;//重新创建新对象，所以i2!
=i3对象池的存在是为了避免频繁的创建和销毁对象而影响系统性能，那我们自己写的类是否也可以使用对象池呢？
当然可以，考察以下代码：
classStudent{privateStringname;privateintage;privatestaticHashSetpool=newHashSet（）;//对象池publicStudent（Stringname,intage）{this.name=name;this.age=age;}//使用对象池来得到对象的方法publicstaticStudentnewInstance（Stringname,intage）{//循环遍历对象池for（Studentstu:
pool）{if（stu.name.equals（name）&&stu.age==age）{returnstu;}}//如果找不到值相同的Student对象，则创建一个Student对象//并把它加到对象池中然后返回该对象。
Studentstu=newStudent（name,age）;pool.add（stu）;returnstu;}}publicclassTest{publicstaticvoidmain（String[]args）{Studentstu1=Student.newInstance（"tangliang",30）;//对象池中拿Studentstu2=Student.newInstance（"tangliang",30）;//所以stu1==stu2Studentstu3=newStudent（"tangliang",30）;//重新创建，所以stu1!
=stu3System.out.println（stu1==stu2）;System.out.println（stu1==stu3）;}}
6i=i+1和i+=1完全等价吗？
可能有很多程序员认为i+=1只是i=i+1的简写方式，其实不然，它们一个使用简单赋值运算，一个使用复合赋值运算，而简单赋值运算和复合赋值运算的最大差别就在于：
复合赋值运算符会自动地将运算结果转型为其左操作数的类型。
看看以下的两种写法，你就知道它们的差别在哪儿了：
（1）bytei=5;
i+=1;
（2）bytei=5;
i=i+1;
第一种写法编译没问题，而第二种写法却编译通不过。
原因就在于，当使用复合赋值运算符进行操作时，即使右边算出的结果是int类型，系统也会将其值转化为左边的byte类型，而使用简单赋值运算时没有这样的优待，系统会认为将i+1的值赋给i是将int类型赋给byte，所以要求强制转换。
理解了这一点后，我们再来看一个例子：
byteb=120;
b+=20;
System.out.println（"b="+b）;
说到这里你应该明白了，上例中输出b的值不是140，而是-116。
因为120+20的值已经超出了一个byte表示的范围，而当我们使用复合赋值运算时系统会自动作类型的转化，将140强转成byte，所以得到是-116。
由此可见，在使用复合赋值运算符时还得小心，因为这种类型转换是在不知不觉中进行的，所以得到的结果就有可能和你的预想不一样。
升级会员 