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的老师不改变。
}
升级会员 