Java作為一門優(yōu)秀的面向?qū)ο蟮某绦蛟O(shè)計語言,正在被越來越多的人使用。本文試圖列出作者在實(shí)際開發(fā)中碰到的一些
Java語言的容易被人忽視的細(xì)節(jié),希望能給正在學(xué)習(xí)Java語言的人有所幫助。
1，位移運(yùn)算越界怎么處理
考察下面的代碼輸出結(jié)果是多少?
int a=5;
System.out.println(a < <33);
按照常理推測,把a(bǔ)左移33位應(yīng)該將a的所有有效位都移出去了，那剩下的都是零啊，所以輸出結(jié)果應(yīng)該是0才對啊，可是執(zhí)行后發(fā)現(xiàn)輸出結(jié)果是10，為什么呢？因為Java語言對位移運(yùn)算作了優(yōu)化處理，Java語言對a < <b轉(zhuǎn)化為a < <(b%32)來處理，所以當(dāng)要移位的位數(shù)b超過32時，實(shí)際上移位的位數(shù)是b%32的值，那么上面的代碼中a < <33相當(dāng)于a < <1，所以輸出結(jié)果是10。
2，可以讓i!=i嗎？
當(dāng)你看到這個命題的時候一定會以為我瘋了，或者Java語言瘋了。這看起來是絕對不可能的，一個數(shù)怎么可能不等于它自己呢？或許就真的是Java語言瘋了，不信看下面的代碼輸出什么？
double i=0.0/0.0;
if(i==i){
System.out.println("Yes i==i");
}else{
System.out.println("No i!=i");
}
上面的代碼輸出"No i!=i"，為什么會這樣呢？關(guān)鍵在0.0/0.0這個值，在IEEE 754浮點(diǎn)算術(shù)規(guī)則里保留了一個特殊的值用來表示一個不是數(shù)字的數(shù)量。這個值就是NaN("Not a Number"的縮寫)，對于所有沒有良好定義的浮點(diǎn)計算都將得到這個值，比如：0.0/0.0；其實(shí)我們還可以直接使用Double.NaN來得到這個值。在IEEE 754規(guī)范里面規(guī)定NaN不等于任何值，包括它自己。所以就有了i！=i的代碼。
3，怎樣的equals才安全？
我們都知道在Java規(guī)范里定義了equals方法覆蓋的5大原則：reflexive（反身性），symmetric（對稱性），transitive（傳遞性），consistent（一致性），non-null（非空性）。那么考察下面的代碼：
public class Student{
private String name;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public boolean equals(Object obj){
if(obj instanceof Student){
Student s=(Student)obj;
if(s.name.equals(this.name) && s.age==this.age){
return true;
}
}
return super.equals(obj);
}
}
你認(rèn)為上面的代碼equals方法的覆蓋安全嗎？表面看起來好像沒什么問題，這樣寫也確實(shí)滿足了以上的五大原則。但其實(shí)這樣的覆蓋并不很安全，假如Student類還有一個子類CollegeStudent,如果我拿一個Student對象和一個CollegeStudent對象equals,只要這兩個對象有相同的name和age，它們就會被認(rèn)為相等，但實(shí)際上它們是兩個不同類型的對象啊。問題就出在instanceof這個運(yùn)算符上，因為這個運(yùn)算符是向下兼容的，也就是說一個CollegeStudent對象也被認(rèn)為是一個Student的實(shí)例。怎樣去解決這個問題呢？那就只有不用instanceof運(yùn)算符，而使用對象的getClass()方法來判斷兩個對象是否屬于同一種類型，例如，將上面的equals()方法修改為：
public boolean equals(Object obj){
if(obj.getClass()==Student.class){
Student s=(Student)obj;
if(s.name.equals(this.name) && s.age==this.age){
return true;
}
}
return super.equals(obj);
}
這樣才能保證obj對象一定是Student的實(shí)例，而不會是Student的任何子類的實(shí)例。
4，淺復(fù)制與深復(fù)制
1）淺復(fù)制與深復(fù)制概念
⑴淺復(fù)制（淺克隆）
被復(fù)制對象的所有變量都含有與原來的對象相同的值，而所有的對其他對象的引用仍然指向原來的對象。換言之，淺復(fù)制僅僅復(fù)制所考慮的對象，而不復(fù)制它所引用的對象。
⑵深復(fù)制（深克隆）
被復(fù)制對象的所有變量都含有與原來的對象相同的值，除去那些引用其他對象的變量。那些引用其他對象的變量將指向被復(fù)制過的新對象，而不再是原有的那些被引用的對象。換言之，深復(fù)制把要復(fù)制的對象所引用的對象都復(fù)制了一遍。
2）Java的clone（）方法
⑴clone方法將對象復(fù)制了一份并返回給調(diào)用者。一般而言，clone（）方法滿足：
①對任何的對象x，都有x.clone() !=x//克隆對象與原對象不是同一個對象
②對任何的對象x，都有x.clone().getClass()= =x.getClass()//克隆對象與原對象的類型一樣
③如果對象x的equals()方法定義恰當(dāng)，那么x.clone().equals(x)應(yīng)該成立。
⑵Java中對象的克隆
①為了獲取對象的一份拷貝，我們可以利用Object類的clone()方法。
②在派生類中覆蓋基類的clone()方法，并聲明為public。
③在派生類的clone()方法中，調(diào)用super.clone()。
④在派生類中實(shí)現(xiàn)Cloneable接口。
請看如下代碼：
class Student implements Cloneable{
String name;
int age;
Student(String name,int age){
this.name=name;
this.age=age;
}
public Object clone(){
Object obj=null;
try{
obj=(Student)super.clone();
//Object中的clone()識別出你要復(fù)制的是哪一個對象。
}
catch(CloneNotSupportedException e){
e.printStackTrace();
}
return obj;
}
}
public static void main(String[] args){
Student s1=new Student("zhangsan",18);
Student s2=(Student)s1.clone();
s2.name="lisi";
s2.age=20;
System.out.println("name="+s1.name+","+"age="+s1.age);//修改學(xué)生2
//后，不影響學(xué)生1的值。
}
說明：
①為什么我們在派生類中覆蓋Object的clone()方法時，一定要調(diào)用super.clone()呢？在運(yùn)行時刻，Object中的clone()識別出你要復(fù)制的是哪一個對象，然后為此對象分配空間，并進(jìn)行對象的復(fù)制，將原始對象的內(nèi)容一一復(fù)制到新對象的存儲空間中。
②繼承自java.lang.Object類的clone()方法是淺復(fù)制。以下代碼可以證明之。
class Teacher{
String name;
int age;
Teacher(String name,int age){
this.name=name;
this.age=age;
}
}
class Student implements Cloneable{
String name;
int age;
Teacher t;//學(xué)生1和學(xué)生2的引用值都是一樣的。
Student(String name,int age,Teacher t){
this.name=name;
this.age=age;
this.t=t;
}
public Object clone(){
Student stu=null;
try{
stu=(Student)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
stu.t=(Teacher)t.clone();
return stu;
}
public static void main(String[] args){
Teacher t=new Teacher("tangliang",30);
Student s1=new Student("zhangsan",18,t);
Student s2=(Student)s1.clone();
s2.t.name="tony";
s2.t.age=40;
System.out.println("name="+s1.t.name+","+"age="+s1.t.age);
//學(xué)生1的老師成為tony,age為40。
}
}
那應(yīng)該如何實(shí)現(xiàn)深層次的克隆，即修改s2的老師不會影響s1的老師？代碼改進(jìn)如下。
class Teacher implements Cloneable{
String name;
int age;
Teacher(String name,int age){
this.name=name;
this.age=age;
}
public Object clone(){
Object obj=null;
try{
obj=super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return obj;
}
}
class Student implements Cloneable{
String name;
int age;
Teacher t;
Student(String name,int age,Teacher t){
this.name=name;
this.age=age;
this.t=t;
}
public Object clone(){
Student stu=null;
try{
stu=(Student)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
stu.t=(Teacher)t.clone();
return stu;
}
}
public static void main(String[] args){
Teacher t=new Teacher("tangliang",30);
Student s1=new Student("zhangsan",18,t);
Student s2=(Student)s1.clone();
s2.t.name="tony";
s2.t.age=40;
System.out.println("name="+s1.t.name+","+"age="+s1.t.age);
//學(xué)生1的老師不改變。
}
3）利用串行化來做深復(fù)制
把對象寫到流里的過程是串行化（Serilization）過程，Java程序員又非常形象地稱為“冷凍”或者“腌咸菜（picking）”過程；而把對象從流中讀出來的并行化（Deserialization）過程則叫做“解凍”或者“回鮮(depicking)”過程。應(yīng)當(dāng)指出的是，寫在流里的是對象的一個拷貝，而原對象仍然存在于JVM里面，因此“腌成咸菜”的只是對象的一個拷貝，Java咸菜還可以回鮮。
在Java語言里深復(fù)制一個對象，常常可以先使對象實(shí)現(xiàn)Serializable接口，然后把對象（實(shí)際上只是對象的一個拷貝）寫到一個流里（腌成咸菜），再從流里讀出來（把咸菜回鮮），便可以重建對象。
如下為深復(fù)制源代碼。
public Object deepClone(){
//將對象寫到流里
ByteArrayOutoutStream bo=new ByteArrayOutputStream();
ObjectOutputStream oo=new ObjectOutputStream(bo);
oo.writeObject(this);
//從流里讀出來
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi=new ObjectInputStream(bi);
return(oi.readObject());
}
這樣做的前提是對象以及對象內(nèi)部所有引用到的對象都是可串行化的，否則，就需要仔細(xì)考察那些不可串行化的對象可否設(shè)成transient，從而將之排除在復(fù)制過程之外。上例代碼改進(jìn)如下。
class Teacher implements Serializable{
String name;
int age;
Teacher(String name,int age){
this.name=name;
this.age=age;
}
}
class Student implements Serializable
{
String name;//常量對象。
int age;
Teacher t;//學(xué)生1和學(xué)生2的引用值都是一樣的。
Student(String name,int age,Teacher t){
this.name=name;
this.age=age;
this.p=p;
}
public Object deepClone() throws IOException,
OptionalDataException,ClassNotFoundException
{
//將對象寫到流里
ByteArrayOutoutStream bo=new ByteArrayOutputStream();
ObjectOutputStream oo=new ObjectOutputStream(bo);
oo.writeObject(this);
//從流里讀出來
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi=new ObjectInputStream(bi);
return(oi.readObject());
}
}
public static void main(String[] args){
Teacher t=new Teacher("tangliang",30);
Student s1=new Student("zhangsan",18,t);
Student s2=(Student)s1.deepClone();
s2.t.name="tony";
s2.t.age=40;
System.out.println("name="+s1.t.name+","+"age="+s1.t.age);
//學(xué)生1的老師不改變。
}